Add patches for feature configurations and serializing radices.

CHANGELOG

@@ -18,6 +18,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Have consistent errors when an invalid leading digit is found for floating point numbers to always be `Error::InvalidDigit`.
 - Incorrect parsing of consecutive digit separators.
 - Inaccuracies when parsing digit separators at various positions leading to incorect errors being returned.
+- Selecting only a subset of parse and/or write features would cause compilation errors.
+- Fixed bug with writing integers with custom radices.
 
 ## [1.0.1] 2024-09-16
 

ci/test.sh

@@ -31,6 +31,14 @@ FEATURES=(
     "format,radix"
 )
 
+check_error() {
+    local feature=$1
+    if 2>/dev/null cargo check --no-default-features --features="${feature}" ; then
+        >&2 echo "The feature ${feature} did not error..."
+        exit 1
+    fi
+}
+
 # Don't build the target, but ensure the syntax is correct.
 check() {
     if [ ! -z $NO_FEATURES ]; then
@@ -56,6 +64,18 @@ check() {
     cd ../lexical-write-integer
     cargo check --tests
 
+    # ensure our partial features aren't allowed, as are unsupported features
+    cd ../lexical-core
+    partial=(parse write floats integers)
+    for feature in "${partial[@]}"; do
+        check_error "${feature}"
+    done
+
+    cd ../lexical
+    for feature in "${partial[@]}"; do
+        check_error "${feature}"
+    done
+
     cd ..
 }
 
@@ -82,6 +102,20 @@ test() {
     cargo test --features=radix,format,compact $DOCTESTS --release
     # NOTE: This tests a regressions, related to #96.
     cargo test --features=format $DOCTESTS
+
+    # this fixes an issue where the lexical and lexical-core tests weren't being run
+    cd lexical-core
+    cargo test $test_features,format
+    cargo test $test_features,radix
+    cargo test $test_features,format,radix
+    cd ..
+
+    # this fixes an issue where the lexical and lexical-core tests weren't being run
+    cd lexical
+    cargo test $test_features,format
+    cargo test $test_features,radix
+    cargo test $test_features,format,radix
+    cd ..
 }
 
 # Dry-run bench target

lexical-core/Cargo.toml

@@ -107,7 +107,9 @@ f16 = [
     "lexical-write-float?/f16"
 ]
 
-# Internal only features.
+# INTERNAL ONLY
+# -------------
+# Internal only features. These are not meant to be used directly.
 # Enable the lint checks.
 lint = [
     "lexical-util/lint",
@@ -117,16 +119,23 @@ lint = [
     "lexical-parse-float?/lint"
 ]
 # Add support for writing numbers.
-write = []
+# Library users should use `write-integers` and `write-floats` instead.
+write = ["lexical-util/write"]
 # Add support for parsing numbers.
-parse = []
+# Library users should use `parse-integers` and `parse-floats` instead.
+parse = ["lexical-util/parse"]
 # Add support for conversions to or from integers.
-integers = []
+# Library users should use `write-integers` and `parse-integers` instead.
+integers = ["lexical-util/integers"]
 # Add support for conversions to or from floats.
-floats = []
+# Library users should use `write-floats` and `parse-floats` instead.
+floats = ["lexical-util/floats"]
 
-# Currently unsupported.
-# Enable support for 128-bit floats.
+# UNSUPPORTED
+# -----------
+# Currently unsupported features.
+# Enable support for 128-bit floats. Unsupported and unlikely to ever be.
+#   https://github.com/Alexhuszagh/rust-lexical/issues/46
 f128 = [
     "lexical-util/f128",
     "lexical-parse-float?/f128",

lexical-core/tests/float_pow2_tests.rs

@@ -0,0 +1,120 @@
+#![cfg(feature = "power-of-two")]
+#![cfg(feature = "parse-floats")]
+#![cfg(feature = "write-floats")]
+
+use approx::assert_relative_eq;
+
+const F32_DATA: [f32; 31] = [
+    0.,
+    0.1,
+    1.,
+    1.1,
+    12.,
+    12.1,
+    123.,
+    123.1,
+    1234.,
+    1234.1,
+    12345.,
+    12345.1,
+    123456.,
+    123456.1,
+    1234567.,
+    1234567.1,
+    12345678.,
+    12345678.1,
+    123456789.,
+    123456789.1,
+    123456789.12,
+    123456789.123,
+    123456789.1234,
+    123456789.12345,
+    1.2345678912345e8,
+    1.2345e+8,
+    1.2345e+11,
+    1.2345e+38,
+    1.2345e-8,
+    1.2345e-11,
+    1.2345e-38,
+];
+const F64_DATA: [f64; 33] = [
+    0.,
+    0.1,
+    1.,
+    1.1,
+    12.,
+    12.1,
+    123.,
+    123.1,
+    1234.,
+    1234.1,
+    12345.,
+    12345.1,
+    123456.,
+    123456.1,
+    1234567.,
+    1234567.1,
+    12345678.,
+    12345678.1,
+    123456789.,
+    123456789.1,
+    123456789.12,
+    123456789.123,
+    123456789.1234,
+    123456789.12345,
+    1.2345678912345e8,
+    1.2345e+8,
+    1.2345e+11,
+    1.2345e+38,
+    1.2345e+308,
+    1.2345e-8,
+    1.2345e-11,
+    1.2345e-38,
+    1.2345e-299,
+];
+
+macro_rules! test_radix {
+    ($f:ident, $radix:expr, $buffer:ident, $data:ident) => {{
+        use lexical_core::{
+            FromLexicalWithOptions,
+            NumberFormatBuilder,
+            ParseFloatOptions,
+            ToLexicalWithOptions,
+            WriteFloatOptions,
+        };
+
+        const FORMAT: u128 = NumberFormatBuilder::from_radix($radix);
+        println!("Testing radix {} for type {}...", $radix, stringify!($f));
+
+        let write_options = WriteFloatOptions::builder().exponent(b'^').build().unwrap();
+        let parse_options = ParseFloatOptions::builder().exponent(b'^').build().unwrap();
+        for &float in $data.iter() {
+            let data = float.to_lexical_with_options::<FORMAT>(&mut $buffer, &write_options);
+            let roundtrip = $f::from_lexical_with_options::<FORMAT>(data, &parse_options).unwrap();
+            assert_relative_eq!(float, roundtrip, epsilon = 1e-6, max_relative = 3e-6);
+        }
+    }};
+}
+
+macro_rules! test_all {
+    ($f:ident, $buffer:ident, $data:ident) => {{
+        test_radix!($f, 2, $buffer, $data);
+        test_radix!($f, 4, $buffer, $data);
+        test_radix!($f, 8, $buffer, $data);
+        test_radix!($f, 16, $buffer, $data);
+        test_radix!($f, 32, $buffer, $data);
+        test_radix!($f, 36, $buffer, $data);
+    }};
+}
+
+#[test]
+fn parse_f32_pow2_roundtrip_test() {
+    let mut buffer = [0u8; 1024];
+    test_all!(f32, buffer, F32_DATA);
+}
+
+#[test]
+fn parse_f64_pow2_roundtrip_test() {
+    let mut buffer = [0u8; 1024];
+    test_all!(f64, buffer, F64_DATA);
+}

lexical-core/tests/float_radix_tests.rs

@@ -84,6 +84,7 @@ macro_rules! test_radix {
         };
 
         const FORMAT: u128 = NumberFormatBuilder::from_radix($radix);
+        println!("Testing radix {} for type {}...", $radix, stringify!($f));
 
         let write_options = WriteFloatOptions::builder().exponent(b'^').build().unwrap();
         let parse_options = ParseFloatOptions::builder().exponent(b'^').build().unwrap();

lexical-parse-float/Cargo.toml

@@ -71,15 +71,20 @@ compact = [
 # Enable support for 16-bit floats.
 f16 = ["lexical-util/f16"]
 
-# Internal only features.
+# INTERNAL ONLY
+# -------------
+# Internal only features. These are not meant to be used directly.
 # Enable the lint checks.
 lint = [
     "lexical-util/lint",
     "lexical-parse-integer/lint"
 ]
 
-# Currently unsupported.
-# Enable support for 128-bit floats.
+# UNSUPPORTED
+# -----------
+# Currently unsupported features.
+# Enable support for 128-bit floats. Unsupported and unlikely to ever be.
+#   https://github.com/Alexhuszagh/rust-lexical/issues/46
 f128 = ["lexical-util/f128"]
 
 [package.metadata.docs.rs]

lexical-parse-integer/Cargo.toml

@@ -47,7 +47,9 @@ format = ["lexical-util/format"]
 # Reduce code size at the cost of performance.
 compact = ["lexical-util/compact"]
 
-# Internal only features.
+# INTERNAL ONLY
+# -------------
+# Internal only features. These are not meant to be used directly.
 # Enable the lint checks.
 lint = ["lexical-util/lint"]
 

lexical-util/Cargo.toml

@@ -55,6 +55,8 @@ parse-integers = ["parse", "integers"]
 parse-floats = ["parse", "floats"]
 # Reduce code size at the cost of performance.
 compact = []
+# Add support for the `f16` and `b16` half-point floating point numbers.
+f16 = ["parse-floats", "write-floats"]
 
 # Internal only features.
 # Enable the lint checks.
@@ -68,11 +70,14 @@ integers = []
 # Add support for conversions to or from floats.
 floats = []
 
-# Currently unsupported.
+# UNSUPPORTED
+# -----------
+# Currently unsupported features.
+# Enable support for 128-bit floats. Unsupported and unlikely to ever be.
+#   https://github.com/Alexhuszagh/rust-lexical/issues/46
 # Enable support for 16-bit floats.
-f16 = ["floats"]
 # Enable support for 128-bit floats.
-f128 = ["floats"]
+f128 = ["parse-floats", "write-floats"]
 
 [package.metadata.docs.rs]
 features = ["radix", "format", "write-integers", "write-floats", "parse-integers", "parse-floats"]

lexical-util/src/lib.rs

@@ -132,6 +132,26 @@
     clippy::semicolon_inside_block,
 )]
 
+// Ensure our features are properly enabled. This means no parse without
+// parse support, etc.
+#[cfg(all(feature = "parse", not(any(feature = "parse-integers", feature = "parse-floats"))))]
+compile_error!(
+    "Do not use the `parse` feature directly. Use `parse-integers` and/or `parse-floats` instead."
+);
+
+#[cfg(all(feature = "write", not(any(feature = "write-integers", feature = "write-floats"))))]
+compile_error!(
+    "Do not use the `write` feature directly. Use `write-integers` and/or `write-floats` instead."
+);
+
+#[cfg(all(feature = "integers", not(any(feature = "write-integers", feature = "parse-integers"))))]
+compile_error!("Do not use the `integers` feature directly. Use `write-integers` and/or `parse-integers` instead.");
+
+#[cfg(all(feature = "floats", not(any(feature = "write-floats", feature = "parse-floats"))))]
+compile_error!(
+    "Do not use the `floats` feature directly. Use `write-floats` and/or `parse-floats` instead."
+);
+
 pub mod algorithm;
 pub mod ascii;
 pub mod assert;

lexical-write-float/Cargo.toml

@@ -70,15 +70,20 @@ compact = [
 # Enable support for 16-bit floats.
 f16 = ["lexical-util/f16"]
 
-# Internal only features.
+# INTERNAL ONLY
+# -------------
+# Internal only features. These are not meant to be used directly.
 # Enable the lint checks.
 lint = [
     "lexical-util/lint",
     "lexical-write-integer/lint"
 ]
 
-# Currently unsupported.
-# Enable support for 128-bit floats.
+# UNSUPPORTED
+# -----------
+# Currently unsupported features.
+# Enable support for 128-bit floats. Unsupported and unlikely to ever be.
+#   https://github.com/Alexhuszagh/rust-lexical/issues/46
 f128 = ["lexical-util/f128"]
 
 [package.metadata.docs.rs]

lexical-write-integer/Cargo.toml

@@ -47,7 +47,9 @@ format = ["lexical-util/format"]
 # Reduce code size at the cost of performance.
 compact = ["lexical-util/compact"]
 
-# Internal only features.
+# INTERNAL ONLY
+# -------------
+# Internal only features. These are not meant to be used directly.
 # Enable the lint checks.
 lint = ["lexical-util/lint"]