provide no_std support

.github/workflows/rust.yml

@@ -42,6 +42,21 @@ jobs:
         with:
           command: test
 
+  no_std:
+    name: Test Suite (no_std)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          override: true
+      - uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --no-default-features
+
   fmt:
     name: Rustfmt
     runs-on: ubuntu-latest

Cargo.toml

@@ -25,7 +25,9 @@ image = { version = "0.25", default-features = false, optional = true }
 image = "0.25"
 
 [features]
-default = ["image", "svg", "pic"]
+default = ["std", "image", "svg", "pic"]
+image = ["dep:image", "std"]
+std = []
 bench = []
 svg = []
 pic = []

README.md

@@ -19,7 +19,7 @@ The default settings will depend on the `image` crate. If you don't need image g
 
 ```toml
 [dependencies]
-qrcode = { version = "0.14.1", default-features = false }
+qrcode = { version = "0.14.1", default-features = false, features = ["std"] }
 ```
 
 Example

src/bits.rs

@@ -1,6 +1,7 @@
 //! The `bits` module encodes binary data into raw bits used in a QR code.
 
-use std::cmp::min;
+use alloc::vec::Vec;
+use core::cmp::min;
 
 #[cfg(feature = "bench")]
 extern crate test;
@@ -117,6 +118,7 @@ impl Bits {
 
 #[test]
 fn test_push_number() {
+    use alloc::vec;
     let mut bits = Bits::new(Version::Normal(1));
 
     bits.push_number(3, 0b010); // 0:0 .. 0:3
@@ -281,6 +283,7 @@ impl Bits {
 mod eci_tests {
     use crate::bits::Bits;
     use crate::types::{QrError, Version};
+    use alloc::vec;
 
     #[test]
     fn test_9() {
@@ -351,6 +354,7 @@ impl Bits {
 mod numeric_tests {
     use crate::bits::Bits;
     use crate::types::{QrError, Version};
+    use alloc::vec;
 
     #[test]
     fn test_iso_18004_2006_example_1() {
@@ -459,6 +463,7 @@ impl Bits {
 mod alphanumeric_tests {
     use crate::bits::Bits;
     use crate::types::{QrError, Version};
+    use alloc::vec;
 
     #[test]
     fn test_iso_18004_2006_example() {
@@ -506,6 +511,7 @@ impl Bits {
 mod byte_tests {
     use crate::bits::Bits;
     use crate::types::{QrError, Version};
+    use alloc::vec;
 
     #[test]
     fn test() {
@@ -573,6 +579,7 @@ impl Bits {
 mod kanji_tests {
     use crate::bits::Bits;
     use crate::types::{QrError, Version};
+    use alloc::vec;
 
     #[test]
     fn test_iso_18004_example() {
@@ -758,6 +765,7 @@ impl Bits {
 mod finish_tests {
     use crate::bits::Bits;
     use crate::types::{EcLevel, QrError, Version};
+    use alloc::vec;
 
     #[test]
     fn test_hello_world() {
@@ -857,6 +865,8 @@ impl Bits {
 mod encode_tests {
     use crate::bits::Bits;
     use crate::types::{EcLevel, QrError, QrResult, Version};
+    use alloc::vec;
+    use alloc::vec::Vec;
 
     fn encode(data: &[u8], version: Version, ec_level: EcLevel) -> QrResult<Vec<u8>> {
         let mut bits = Bits::new(version);

src/canvas.rs

@@ -11,7 +11,10 @@
 //! let bools = c.to_bools();
 //! ```
 
-use std::{cmp::max, iter};
+use alloc::boxed::Box;
+use alloc::vec;
+use alloc::vec::Vec;
+use core::{cmp::max, iter};
 
 use crate::cast::As;
 use crate::types::{Color, EcLevel, Version};
@@ -102,9 +105,9 @@ impl Canvas {
 
     /// Converts the canvas into a human-readable string.
     #[cfg(test)]
-    fn to_debug_str(&self) -> String {
+    fn to_debug_str(&self) -> alloc::string::String {
         let width = self.width;
-        let mut res = String::with_capacity((width * (width + 1)) as usize);
+        let mut res = alloc::string::String::with_capacity((width * (width + 1)) as usize);
         for y in 0..width {
             res.push('\n');
             for x in 0..width {
@@ -1190,6 +1193,8 @@ impl Iterator for DataModuleIter {
 mod data_iter_tests {
     use crate::canvas::DataModuleIter;
     use crate::types::Version;
+    use alloc::vec::Vec;
+    use alloc::vec;
 
     #[test]
     fn test_qr() {

src/ec.rs

@@ -1,6 +1,7 @@
 //! The `ec` module applies the Reed-Solomon error correction codes.
 
-use std::ops::Deref;
+use alloc::vec::Vec;
+use core::ops::Deref;
 
 use crate::types::{EcLevel, QrResult, Version};
 

src/lib.rs

@@ -25,6 +25,7 @@
 //! # }
 //! ```
 
+#![cfg_attr(not(feature = "std"), no_std)]
 #![cfg_attr(feature = "bench", feature(test))] // Unstable libraries
 #![cfg_attr(docsrs, feature(doc_auto_cfg))]
 #![warn(clippy::pedantic)]
@@ -34,7 +35,11 @@
 #![cfg_attr(feature = "bench", doc = include_str!("../README.md"))]
 // ^ make sure we can test our README.md.
 
-use std::ops::Index;
+extern crate alloc;
+
+use alloc::string::String;
+use alloc::vec::Vec;
+use core::ops::Index;
 
 pub mod bits;
 pub mod canvas;

src/optimize.rs

@@ -1,6 +1,6 @@
 //! Find the optimal data mode sequence to encode a piece of data.
 use crate::types::{Mode, Version};
-use std::slice::Iter;
+use core::slice::Iter;
 
 #[cfg(feature = "bench")]
 extern crate test;
@@ -160,6 +160,7 @@ impl<'a> Iterator for Parser<'a> {
 mod parse_tests {
     use crate::optimize::{Parser, Segment};
     use crate::types::Mode;
+    use alloc::vec::Vec;
 
     fn parse(data: &[u8]) -> Vec<Segment> {
         Parser::new(data).collect()
@@ -342,6 +343,7 @@ pub fn total_encoded_len(segments: &[Segment], version: Version) -> usize {
 mod optimize_tests {
     use crate::optimize::{total_encoded_len, Optimizer, Segment};
     use crate::types::{Mode, Version};
+    use alloc::vec::Vec;
 
     fn test_optimization_result(given: &[Segment], expected: &[Segment], version: Version) {
         let prev_len = total_encoded_len(given, version);

src/render/image.rs

@@ -5,6 +5,8 @@ use crate::types::Color;
 
 use image::{ImageBuffer, Luma, LumaA, Primitive, Rgb, Rgba};
 
+use alloc::vec::Vec;
+
 // need to keep using this macro to implement Pixel separately for each color model,
 // otherwise we'll have conflicting impl with `impl Pixel for impl Element` 🤷
 macro_rules! impl_pixel_for_image_pixel {

src/render/mod.rs

@@ -2,7 +2,7 @@
 
 use crate::cast::As;
 use crate::types::Color;
-use std::cmp::max;
+use core::cmp::max;
 
 pub mod image;
 pub mod pic;

src/render/pic.rs

@@ -12,7 +12,9 @@
 
 #![cfg(feature = "pic")]
 
-use std::fmt::Write;
+use alloc::format;
+use alloc::string::String;
+use core::fmt::Write;
 
 use crate::render::{Canvas as RenderCanvas, Pixel};
 use crate::types::Color as ModuleColor;

src/render/string.rs

@@ -4,6 +4,10 @@ use crate::cast::As;
 use crate::render::{Canvas as RenderCanvas, Pixel};
 use crate::types::Color;
 
+use alloc::string::String;
+use alloc::vec;
+use alloc::vec::Vec;
+
 pub trait Element: Copy {
     fn default_color(color: Color) -> Self;
     fn strlen(self) -> usize;

src/render/svg.rs

@@ -12,8 +12,10 @@
 
 #![cfg(feature = "svg")]
 
-use std::fmt::Write;
-use std::marker::PhantomData;
+use alloc::format;
+use alloc::string::String;
+use core::fmt::Write;
+use core::marker::PhantomData;
 
 use crate::render::{Canvas as RenderCanvas, Pixel};
 use crate::types::Color as ModuleColor;

src/render/unicode.rs

@@ -2,6 +2,10 @@
 
 use crate::render::{Canvas as RenderCanvas, Color, Pixel};
 
+use alloc::string::String;
+use alloc::vec;
+use alloc::vec::Vec;
+
 const CODEPAGE: [&str; 4] = [" ", "\u{2584}", "\u{2580}", "\u{2588}"];
 
 #[derive(Copy, Clone, PartialEq, Eq)]

src/types.rs

@@ -1,8 +1,8 @@
 use crate::cast::As;
-use std::cmp::{Ordering, PartialOrd};
-use std::default::Default;
-use std::fmt::{Display, Error, Formatter};
-use std::ops::Not;
+use core::cmp::{Ordering, PartialOrd};
+use core::default::Default;
+use core::fmt::{Display, Error, Formatter};
+use core::ops::Not;
 
 //------------------------------------------------------------------------------
 //{{{ QrResult
@@ -41,6 +41,7 @@ impl Display for QrError {
     }
 }
 
+#[cfg(feature = "std")]
 impl ::std::error::Error for QrError {}
 
 /// `QrResult` is a convenient alias for a QR code generation result.