Moved all feature flags to src/features, made the CI run tests on all feature combinations

.github/workflows/rust.yml

@@ -91,11 +91,16 @@
           "name": "Install Rust ${{ matrix.rust }}"
         },
         {
-          "uses": "actions-rs/cargo@v1",
+          "uses": "actions-rs/install@v0.1",
           "with": {
-            "command": "test"
+            "crate": "cargo-all-features",
+            "version": "1.6.0"
           },
-          "name": "Run `cargo test`"
+          "name": "Install cargo-all-features"
+        },
+        {
+          "run": "cargo test-all-features",
+          "name": "Run `cargo test` on all features"
         }
       ]
     },

Cargo.toml

@@ -23,10 +23,11 @@ description = "A binary serialization / deserialization strategy for transformin
 edition = "2018"
 
 [features]
-default = ["std"]
-std = []
+default = ["std", "derive"]
+std = ["alloc"]
 alloc = []
+derive = ["bincode_derive"]
 
 [dependencies]
-bincode_derive = { path = "derive", version = "2.0.0-dev" }
+bincode_derive = { path = "derive", version = "2.0.0-dev", optional = true }
 # serde = { version = "1.0.130", optional = true }

derive/src/derive_enum.rs

@@ -1,13 +1,10 @@
 use crate::Result;
 use proc_macro::TokenStream;
-use proc_macro2::Span;
-use proc_macro2::TokenStream as TokenStream2;
-use quote::quote;
-use quote::ToTokens;
-use syn::GenericParam;
-use syn::Lifetime;
-use syn::LifetimeDef;
-use syn::{spanned::Spanned, Fields, Generics, Ident, Index, Variant};
+use proc_macro2::{Span, TokenStream as TokenStream2};
+use quote::{quote, ToTokens};
+use syn::{
+    spanned::Spanned, Fields, GenericParam, Generics, Ident, Index, Lifetime, LifetimeDef, Variant,
+};
 pub struct DeriveEnum {
     name: Ident,
     generics: Generics,

src/config.rs

@@ -1,5 +1,5 @@
 pub(crate) use self::internal::*;
-use std::marker::PhantomData;
+use core::marker::PhantomData;
 
 pub trait Config: InternalConfig + Copy + Clone + Sized {
     fn with_big_endian(self) -> BigEndian<Self> {

src/de/decoder.rs

@@ -6,7 +6,7 @@ use crate::{
     config::{Config, Endian, IntEncoding},
     error::DecodeError,
 };
-use std::marker::PhantomData;
+use core::marker::PhantomData;
 
 pub struct Decoder<R, C: Config> {
     reader: R,

src/de/read.rs

@@ -49,14 +49,3 @@ impl<'storage> BorrowReader<'storage> for SliceReader<'storage> {
         self.get_byte_slice(length)
     }
 }
-
-#[cfg(feature = "std")]
-impl<'storage, R: std::io::Read> Reader<'storage> for R {
-    #[inline(always)]
-    fn read(&mut self, bytes: &mut [u8]) -> Result<(), DecodeError> {
-        match self.read_exact(bytes) {
-            Ok(_) => Ok(()),
-            Err(_) => Err(DecodeError::UnexpectedEnd),
-        }
-    }
-}

src/enc/encoder.rs

@@ -1,5 +1,4 @@
-use super::write::Writer;
-use super::Encode;
+use super::{write::Writer, Encode};
 use crate::{
     config::{Config, Endian, IntEncoding},
     error::EncodeError,

src/features/derive.rs

@@ -0,0 +1 @@
+pub use bincode_derive::{Decodable, Encodable};

src/features/impl_alloc.rs

@@ -0,0 +1 @@
+

src/features/impl_std.rs

@@ -0,0 +1,29 @@
+use crate::{
+    config::{self, Config},
+    de::{read::Reader, Decodable, Decoder},
+    error::DecodeError,
+};
+
+pub fn decode_from<'__de, D: Decodable<'__de>, R: std::io::Read>(
+    src: &'__de mut R,
+) -> Result<D, DecodeError> {
+    decode_from_with_config(src, config::Default)
+}
+
+pub fn decode_from_with_config<'__de, D: Decodable<'__de>, C: Config, R: std::io::Read>(
+    src: &'__de mut R,
+    _config: C,
+) -> Result<D, DecodeError> {
+    let mut decoder = Decoder::<_, C>::new(src, _config);
+    D::decode(&mut decoder)
+}
+
+impl<'storage, R: std::io::Read> Reader<'storage> for R {
+    #[inline(always)]
+    fn read(&mut self, bytes: &mut [u8]) -> Result<(), DecodeError> {
+        match self.read_exact(bytes) {
+            Ok(_) => Ok(()),
+            Err(_) => Err(DecodeError::UnexpectedEnd),
+        }
+    }
+}

src/features/mod.rs

@@ -0,0 +1,14 @@
+#[cfg(feature = "alloc")]
+mod impl_alloc;
+#[cfg(feature = "alloc")]
+pub use self::impl_alloc::*;
+
+#[cfg(feature = "std")]
+mod impl_std;
+#[cfg(feature = "std")]
+pub use self::impl_std::*;
+
+#[cfg(feature = "derive")]
+mod derive;
+#[cfg(feature = "derive")]
+pub use self::derive::*;

src/lib.rs

@@ -12,19 +12,21 @@
 
 #[cfg(feature = "alloc")]
 extern crate alloc;
-#[cfg(feature = "std")]
+#[cfg(any(feature = "std", test))]
 extern crate std;
 
+mod features;
+pub(crate) mod varint;
+
+pub use features::*;
+
 pub mod config;
 pub mod de;
 pub mod enc;
 pub mod error;
 
-pub use bincode_derive::{Decodable, Encodable};
 use config::Config;
 
-pub(crate) mod varint;
-
 pub fn encode_into_slice<E: enc::Encodeable>(
     val: E,
     dst: &mut [u8],
@@ -57,19 +59,3 @@ pub fn decode_with_config<'__de, D: de::BorrowDecodable<'__de>, C: Config>(
     let mut decoder = de::Decoder::<_, C>::new(reader, _config);
     D::borrow_decode(&mut decoder)
 }
-
-#[cfg(feature = "std")]
-pub fn decode_from<'__de, D: de::Decodable<'__de>, R: std::io::Read>(
-    src: &'__de mut R,
-) -> Result<D, error::DecodeError> {
-    decode_from_with_config(src, config::Default)
-}
-
-#[cfg(feature = "std")]
-pub fn decode_from_with_config<'__de, D: de::Decodable<'__de>, C: Config, R: std::io::Read>(
-    src: &'__de mut R,
-    _config: C,
-) -> Result<D, error::DecodeError> {
-    let mut decoder = de::Decoder::<_, C>::new(src, _config);
-    D::decode(&mut decoder)
-}

src/varint/mod.rs

@@ -3,21 +3,23 @@ mod decode_unsigned;
 mod encode_signed;
 mod encode_unsigned;
 
-pub use self::decode_signed::{
-    varint_decode_i128, varint_decode_i16, varint_decode_i32, varint_decode_i64,
-    varint_decode_isize,
-};
-pub use self::decode_unsigned::{
-    varint_decode_u128, varint_decode_u16, varint_decode_u32, varint_decode_u64,
-    varint_decode_usize,
-};
-pub use self::encode_signed::{
-    varint_encode_i128, varint_encode_i16, varint_encode_i32, varint_encode_i64,
-    varint_encode_isize,
-};
-pub use self::encode_unsigned::{
-    varint_encode_u128, varint_encode_u16, varint_encode_u32, varint_encode_u64,
-    varint_encode_usize,
+pub use self::{
+    decode_signed::{
+        varint_decode_i128, varint_decode_i16, varint_decode_i32, varint_decode_i64,
+        varint_decode_isize,
+    },
+    decode_unsigned::{
+        varint_decode_u128, varint_decode_u16, varint_decode_u32, varint_decode_u64,
+        varint_decode_usize,
+    },
+    encode_signed::{
+        varint_encode_i128, varint_encode_i16, varint_encode_i32, varint_encode_i64,
+        varint_encode_isize,
+    },
+    encode_unsigned::{
+        varint_encode_u128, varint_encode_u16, varint_encode_u32, varint_encode_u64,
+        varint_encode_usize,
+    },
 };
 
 pub(self) const SINGLE_BYTE_MAX: u8 = 250;

tests/derive.rs

@@ -1,3 +1,5 @@
+#![cfg(feature = "derive")]
+
 use bincode::{de::Decodable, enc::Encodeable};
 use core::marker::PhantomData;
 

tests/test.rs

@@ -1,5 +1,3 @@
-extern crate bincode;
-
 use bincode::config::{self, Config};
 use core::fmt::Debug;