Merge pull request #373 from Ogeon/alloc_and_any_features_in_tests

Add an "alloc" feature and make tests work with any feature combination

Author: Ogeon

.github/workflows/ci.yml

@@ -24,6 +24,7 @@ jobs:
       - uses: dtolnay/rust-toolchain@1.60.0
         with:
           components: clippy
+      - uses: taiki-e/install-action@cargo-hack
       - name: Minimal check
         run: cargo clippy -v -p palette --no-default-features --features std
       - name: find-crate check
@@ -33,9 +34,7 @@ jobs:
       - name: Test all features
         run: cargo test -v -p palette --all-features
       - name: Test each feature
-        shell: bash
-        working-directory: palette
-        run: bash ../scripts/test_features.sh
+        run: cargo hack test --tests --feature-powerset --ignore-private --skip default,find-crate --optional-deps libm --depth 2
   integration_tests:
     name: integration tests
     strategy:
@@ -63,8 +62,13 @@ jobs:
         with:
           toolchain: ${{ matrix.toolchain }}
           components: clippy
+      - uses: taiki-e/install-action@cargo-hack
       - name: Check all features
         run: cargo clippy -v -p palette --all-features
+      - name: Check each feature with libm
+        run: cargo hack clippy --each-feature --ignore-private --features libm --skip default,find-crate --ignore-unknown-features
+      - name: Check each feature with std
+        run: cargo hack clippy --each-feature --ignore-private --features std --skip default,find-crate --optional-deps libm --ignore-unknown-features
   no_std:
     name: "Test #[no_std]"
     runs-on: ubuntu-latest

benchmarks/Cargo.toml

@@ -7,6 +7,7 @@ description = "Benchmark crate for palette."
 repository = "https://github.com/Ogeon/palette"
 license = "MIT OR Apache-2.0"
 edition = "2018"
+publish = false
 
 [[bench]]
 path = "benches/cie.rs"

integration_tests/Cargo.toml

@@ -7,6 +7,7 @@ description = "Integration test crate for palette."
 repository = "https://github.com/Ogeon/palette"
 license = "MIT OR Apache-2.0"
 edition = "2018"
+publish = false
 
 [[example]]
 name = "issue_283"

no_std_test/Cargo.toml

@@ -7,6 +7,7 @@ description = "Test crate for #[no_std]."
 repository = "https://github.com/Ogeon/palette"
 license = "MIT OR Apache-2.0"
 edition = "2018"
+publish = false
 
 [[bin]]
 name = "no_std_test"

palette/Cargo.toml

@@ -33,9 +33,9 @@ named_from_str = ["named", "phf"]
 named = []
 random = ["rand"]
 serializing = ["serde", "std"]
-#ignore in feature test
 find-crate = ["palette_derive/find-crate"]
-std = ["approx?/std"]
+std = ["alloc", "approx?/std"]
+alloc = []
 
 [lib]
 bench = false

palette/README.md

@@ -41,7 +41,8 @@ These features are enabled by default:
 
 * `"named"` - Enables color constants, located in the `named` module.
 * `"named_from_str"` - Enables `named::from_str`, which maps name strings to colors.
-* `"std"` - Enables use of the standard library.
+* `"std"` - Enables use of the standard library. Also enables `"alloc"`.
+* `"alloc"` - Enables implementations for allocating types, such as `Vec` or `Box`.
 * `"approx"` - Enables approximate comparison using [`approx`].
 
 These features are disabled by default:
@@ -55,7 +56,7 @@ These features are disabled by default:
 
 ### Using palette in an embedded environment
 
-Palette supports `#![no_std]` environments by disabling the `"std"` feature. It uses [`libm`] to provide the floating-point operations that are typically in `std`. However, serializing with `serde` is not available without the standard library.
+Palette supports `#![no_std]` environments by disabling the `"std"` feature. It uses [`libm`], via the `"libm"` feature, to provide the floating-point operations that are typically in `std`, and the `"alloc"` feature to provide features that use allocating types. However, serializing with `serde` is not available without the standard library.
 
 ## Examples
 

palette/src/alpha/alpha.rs

@@ -1240,8 +1240,8 @@ mod test {
 
     #[test]
     fn check_min_max_components() {
-        assert_relative_eq!(Rgba::<Srgb>::min_alpha(), 0.0);
-        assert_relative_eq!(Rgba::<Srgb>::max_alpha(), 1.0);
+        assert_eq!(Rgba::<Srgb>::min_alpha(), 0.0);
+        assert_eq!(Rgba::<Srgb>::max_alpha(), 1.0);
     }
 
     #[cfg(feature = "serializing")]

palette/src/blend/test.rs

@@ -1,3 +1,5 @@
+#![cfg(feature = "approx")]
+
 use crate::{
     blend::{Blend, BlendWith, Compose},
     LinSrgb, LinSrgba,

palette/src/cast/array.rs

@@ -1,5 +1,8 @@
 use core::mem::{transmute_copy, ManuallyDrop};
 
+#[cfg(feature = "alloc")]
+use alloc::{boxed::Box, vec::Vec};
+
 pub use palette_derive::ArrayCast;
 
 use crate::ArrayExt;
@@ -958,7 +961,7 @@ where
 /// let color2 = Box::new(Srgb::new(23u8, 198, 76));
 /// let array2 = <Box<[_; 3]>>::from(color2);
 /// ```
-#[cfg(feature = "std")]
+#[cfg(feature = "alloc")]
 #[inline]
 pub fn into_array_box<T>(value: Box<T>) -> Box<T::Array>
 where
@@ -1000,7 +1003,7 @@ where
 /// let array2 = Box::new([23, 198, 76]);
 /// let color2 = <Box<Srgb<u8>>>::from(array2);
 /// ```
-#[cfg(feature = "std")]
+#[cfg(feature = "alloc")]
 #[inline]
 pub fn from_array_box<T>(value: Box<T::Array>) -> Box<T>
 where
@@ -1030,7 +1033,7 @@ where
 ///     vec![[64, 139, 10], [93, 18, 214]].into_boxed_slice()
 /// )
 /// ```
-#[cfg(feature = "std")]
+#[cfg(feature = "alloc")]
 #[inline]
 pub fn into_array_slice_box<T>(values: Box<[T]>) -> Box<[T::Array]>
 where
@@ -1053,7 +1056,7 @@ where
 ///     vec![64, 139, 10, 93, 18, 214].into_boxed_slice()
 /// )
 /// ```
-#[cfg(feature = "std")]
+#[cfg(feature = "alloc")]
 #[inline]
 pub fn into_component_slice_box<T>(values: Box<[T]>) -> Box<[<T::Array as ArrayExt>::Item]>
 where
@@ -1076,7 +1079,7 @@ where
 ///     vec![Srgb::new(64u8, 139, 10), Srgb::new(93, 18, 214)].into_boxed_slice()
 /// )
 /// ```
-#[cfg(feature = "std")]
+#[cfg(feature = "alloc")]
 #[inline]
 pub fn from_array_slice_box<T>(values: Box<[T::Array]>) -> Box<[T]>
 where
@@ -1116,7 +1119,7 @@ where
 /// let components = vec![64, 139, 10, 93, 18, 214, 0, 123].into_boxed_slice();
 /// cast::from_component_slice_box::<Srgb<u8>>(components);
 /// ```
-#[cfg(feature = "std")]
+#[cfg(feature = "alloc")]
 #[inline]
 pub fn from_component_slice_box<T>(values: Box<[<T::Array as ArrayExt>::Item]>) -> Box<[T]>
 where
@@ -1162,7 +1165,7 @@ where
 ///     unreachable!();
 /// }
 /// ```
-#[cfg(feature = "std")]
+#[cfg(feature = "alloc")]
 #[inline]
 pub fn try_from_component_slice_box<T>(
     values: Box<[<T::Array as ArrayExt>::Item]>,
@@ -1191,7 +1194,7 @@ where
 ///     vec![[64, 139, 10], [93, 18, 214]]
 /// )
 /// ```
-#[cfg(feature = "std")]
+#[cfg(feature = "alloc")]
 #[inline]
 pub fn into_array_vec<T>(values: Vec<T>) -> Vec<T::Array>
 where
@@ -1223,7 +1226,7 @@ where
 ///     vec![64, 139, 10, 93, 18, 214]
 /// )
 /// ```
-#[cfg(feature = "std")]
+#[cfg(feature = "alloc")]
 #[inline]
 pub fn into_component_vec<T>(values: Vec<T>) -> Vec<<T::Array as ArrayExt>::Item>
 where
@@ -1257,7 +1260,7 @@ where
 ///     vec![Srgb::new(64u8, 139, 10), Srgb::new(93, 18, 214)]
 /// )
 /// ```
-#[cfg(feature = "std")]
+#[cfg(feature = "alloc")]
 #[inline]
 pub fn from_array_vec<T>(values: Vec<T::Array>) -> Vec<T>
 where
@@ -1316,7 +1319,7 @@ where
 /// components.reserve_exact(2); // Not a multiple of 3
 /// cast::from_component_vec::<Srgb<u8>>(components);
 /// ```
-#[cfg(feature = "std")]
+#[cfg(feature = "alloc")]
 #[inline]
 pub fn from_component_vec<T>(values: Vec<<T::Array as ArrayExt>::Item>) -> Vec<T>
 where
@@ -1376,7 +1379,7 @@ where
 ///     unreachable!();
 /// }
 /// ```
-#[cfg(feature = "std")]
+#[cfg(feature = "alloc")]
 #[inline]
 pub fn try_from_component_vec<T>(
     values: Vec<<T::Array as ArrayExt>::Item>,
@@ -1419,7 +1422,7 @@ where
 /// Map values of color A to values of color B without creating a new `Vec`.
 ///
 /// This uses the guarantees of [`ArrayCast`] to reuse the allocation.
-#[cfg(feature = "std")]
+#[cfg(feature = "alloc")]
 #[inline]
 pub fn map_vec_in_place<A, B, F>(values: Vec<A>, mut map: F) -> Vec<B>
 where
@@ -1453,7 +1456,7 @@ where
 /// Map values of color A to values of color B without creating a new `Box<[B]>`.
 ///
 /// This uses the guarantees of [`ArrayCast`] to reuse the allocation.
-#[cfg(feature = "std")]
+#[cfg(feature = "alloc")]
 #[inline]
 pub fn map_slice_box_in_place<A, B, F>(values: Box<[A]>, mut map: F) -> Box<[B]>
 where
@@ -1499,20 +1502,20 @@ impl std::error::Error for SliceCastError {}
 
 /// The error type returned when casting a boxed slice of components fails.
 #[derive(Clone, PartialEq, Eq)]
-#[cfg(feature = "std")]
+#[cfg(feature = "alloc")]
 pub struct BoxedSliceCastError<T> {
     /// The original values.
     pub values: Box<[T]>,
 }
 
-#[cfg(feature = "std")]
+#[cfg(feature = "alloc")]
 impl<T> core::fmt::Debug for BoxedSliceCastError<T> {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.debug_struct("BoxedSliceCastError").finish()
     }
 }
 
-#[cfg(feature = "std")]
+#[cfg(feature = "alloc")]
 impl<T> core::fmt::Display for BoxedSliceCastError<T> {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.write_str("could not convert boxed component slice to colors")
@@ -1524,7 +1527,7 @@ impl<T> std::error::Error for BoxedSliceCastError<T> {}
 
 /// The error type returned when casting a `Vec` of components fails.
 #[derive(Clone, PartialEq, Eq)]
-#[cfg(feature = "std")]
+#[cfg(feature = "alloc")]
 pub struct VecCastError<T> {
     /// The type of error that occurred.
     pub kind: VecCastErrorKind,
@@ -1533,7 +1536,7 @@ pub struct VecCastError<T> {
     pub values: Vec<T>,
 }
 
-#[cfg(feature = "std")]
+#[cfg(feature = "alloc")]
 impl<T> core::fmt::Debug for VecCastError<T> {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.debug_struct("VecCastError")
@@ -1542,7 +1545,7 @@ impl<T> core::fmt::Debug for VecCastError<T> {
     }
 }
 
-#[cfg(feature = "std")]
+#[cfg(feature = "alloc")]
 impl<T> core::fmt::Display for VecCastError<T> {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.write_str("could not convert component vector to colors")
@@ -1554,7 +1557,7 @@ impl<T> std::error::Error for VecCastError<T> {}
 
 /// The type of error that is returned when casting a `Vec` of components.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-#[cfg(feature = "std")]
+#[cfg(feature = "alloc")]
 pub enum VecCastErrorKind {
     /// The type of error returned when the length of a `Vec` didn't match the
     /// requirements.
@@ -1567,9 +1570,10 @@ pub enum VecCastErrorKind {
 
 #[cfg(test)]
 mod test {
+    #[cfg(feature = "alloc")]
     use crate::{LinSrgb, Srgb};
 
-    #[cfg(feature = "std")]
+    #[cfg(feature = "alloc")]
     #[test]
     fn array_vec_len_cap() {
         let mut original = vec![
@@ -1596,11 +1600,12 @@ mod test {
         assert_eq!(colors.capacity(), 8);
     }
 
+    #[cfg(feature = "alloc")]
     #[test]
     fn map_vec_in_place() {
         fn do_things(rgb: Srgb) -> LinSrgb {
             let mut linear = rgb.into_linear();
-            std::mem::swap(&mut linear.red, &mut linear.blue);
+            core::mem::swap(&mut linear.red, &mut linear.blue);
             linear
         }
 
@@ -1615,11 +1620,12 @@ mod test {
         )
     }
 
+    #[cfg(feature = "alloc")]
     #[test]
     fn map_slice_box_in_place() {
         fn do_things(rgb: Srgb) -> LinSrgb {
             let mut linear = rgb.into_linear();
-            std::mem::swap(&mut linear.red, &mut linear.blue);
+            core::mem::swap(&mut linear.red, &mut linear.blue);
             linear
         }
 

palette/src/cast/as_arrays_traits.rs

@@ -78,8 +78,8 @@ macro_rules! impl_as_arrays {
 
 impl_as_arrays!([C], [C; M] where (const M: usize));
 
-#[cfg(feature = "std")]
-impl_as_arrays!(Box<[C]>, Vec<C>);
+#[cfg(feature = "alloc")]
+impl_as_arrays!(alloc::boxed::Box<[C]>, alloc::vec::Vec<C>);
 
 /// Trait for casting a reference to collection of arrays into a reference to
 /// collection of colors without copying.
@@ -167,8 +167,8 @@ macro_rules! impl_arrays_as {
 
 impl_arrays_as!([[T; N]], [[T; N]; M] where (const M: usize));
 
-#[cfg(feature = "std")]
-impl_arrays_as!(Box<[[T; N]]>, Vec<[T; N]>);
+#[cfg(feature = "alloc")]
+impl_arrays_as!(alloc::boxed::Box<[[T; N]]>, alloc::vec::Vec<[T; N]>);
 
 #[cfg(test)]
 mod test {

palette/src/cast/as_components_traits.rs

@@ -82,8 +82,8 @@ macro_rules! impl_as_components {
 
 impl_as_components!([C], [C; M] where (const M: usize));
 
-#[cfg(feature = "std")]
-impl_as_components!(Box<[C]>, Vec<C>);
+#[cfg(feature = "alloc")]
+impl_as_components!(alloc::boxed::Box<[C]>, alloc::vec::Vec<C>);
 
 /// Trait for trying to cast a reference to collection of color components into
 /// a reference to collection of colors without copying.
@@ -221,8 +221,8 @@ macro_rules! impl_try_components_as {
 
 impl_try_components_as!([T], [T; M] where (const M: usize));
 
-#[cfg(feature = "std")]
-impl_try_components_as!(Box<[T]>, Vec<T>);
+#[cfg(feature = "alloc")]
+impl_try_components_as!(alloc::boxed::Box<[T]>, alloc::vec::Vec<T>);
 
 /// Trait for casting a reference to collection of color components into a
 /// reference to collection of colors without copying.