Merge pull request #6 from rodrimati1992/assertions

0.2.6 release

Author: rodrimati1992

Changelog.md

@@ -2,6 +2,16 @@ This is the changelog,summarising changes in each version(some minor changes may
 
 # 0.2 
 
+### 0.2.6
+
+Made the macros in `const_format` usable when the crate is renamed.
+
+Added a `#[cdeb(crate = "foo")]` helper attribute to
+pass the path to `const_format` to `ConstDebug`, useful when reexporting the derive macro.
+
+Documented that `writec!(buff, "{foo}")` (where `foo` is a local variable) works,
+and is equivelent to `writec!(buff, "{}", foo)`.
+
 ### 0.2.5
 
 Added the "assert" cargo feature,

README.md

@@ -237,6 +237,18 @@ assert_eq!(const_format::concatcp!(1 + 1, 2 + 1), "23");
 
 None right now.
 
+# Renaming crate
+
+All function-like macros from `const_format` can be used when the crate is renamed.
+
+The [`ConstDebug`] derive macro has the `#[cdeb(crate = "foo::bar")]` attribute to 
+tell it where to find the `const_format` crate.
+
+Example of renaming the `const_format` crate in the Cargo.toml file:
+```toml
+cfmt = {version = "0.*", package = "const_format"}
+```
+
 # Cargo features
 
 - "fmt": Enables the [`std::fmt`]-like API,

const_format/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "const_format"
-version = "0.2.5"
+version = "0.2.6"
 authors = ["rodrimati1992 <rodrimatt1985@gmail.com>"]
 edition = "2018"
 license = "Zlib"
@@ -34,7 +34,7 @@ only_new_tests = ["testing"]
 all = ["fmt", "derive", "constant_time_as_str", "assert"]
 
 [dependencies.const_format_proc_macros]
-version = "=0.2.5"
+version = "=0.2.6"
 path = "../const_format_proc_macros"
 
 [dev-dependencies]

const_format/src/const_debug_derive.rs

@@ -51,6 +51,16 @@
 /// When this attribute is used it disables the default implementation
 /// that uses the type parameters generically.
 ///
+/// ### `#[cdeb(crate = "foo::bar")]`
+///
+/// The path to the `const_format` crate, useful if you want to reexport the ConstDebug macro,
+/// or rename the const_format crate in the Cargo.toml .
+///
+/// Example of renaming the `const_format` crate in the Cargo.toml file:
+/// ```toml
+/// cfmt = {version = "0.*", package = "const_format"}
+/// ```
+///
 /// Example:
 /// 
 /// ```rust
@@ -298,5 +308,36 @@
 /// [`impls attribute`]: #cdebimpls
 ///
 ///
+///
+/// 
+/// ### Renamed import
+/// 
+/// This example demonstrates that you can use all the macros when the `const_format`
+/// crate is renamed.
+/// 
+/// ```rust
+/// #![feature(const_mut_refs)]
+/// # extern crate self as const_format;
+/// # extern crate const_format as cfmt;
+/// # fn main() {
+/// use cfmt::{
+///     for_examples::Unit,
+///     ConstDebug, formatc,
+/// };
+/// 
+/// #[derive(ConstDebug)]
+/// #[cdeb(crate = "cfmt")]
+/// struct Foo {
+///     bar: &'static str,
+///     baz: Unit
+/// }
+/// 
+/// const TEXT: &str = formatc!("{:?}", Foo{ bar: "hello", baz: Unit });
+/// 
+/// assert_eq!(TEXT, r#"Foo { bar: "hello", baz: Unit }"#);
+/// 
+/// # }
+/// ```
+///
 #[cfg(feature = "derive")]
 pub use const_format_proc_macros::ConstDebug;

const_format/src/fmt.rs

@@ -53,6 +53,10 @@
 //! - Named, from constant (eg: `formatc!("{FOO}")`):
 //! Uses the `FOO` constant from the enclosing scope.
 //!
+//! - Named, from locals (eg: `formatc!("{foo}")`):
+//! Uses the `foo` local variable from the enclosing scope,
+//! only usable with the [`writec`] macro.
+//!
 //! ### Formatters
 //!
 //! The format arguments can be formatted in these ways:
@@ -282,7 +286,7 @@
 //! ```
 //!
 //!
-//!
+//! [`writec`]: ../macro.writec.html
 //! [`Formatter`]: ./struct.Formatter.html
 //! [`FormatMarker`]: ../marker_traits/trait.FormatMarker.html
 //! [`ConstDebug`]: ../derive.ConstDebug.html

const_format/src/lib.rs

@@ -205,6 +205,7 @@
 //! So `#[doc = "foobar"]` cannot be replaced with `#[doc = concatcp!("foo", "bar") ]`.
 //!
 //! <span id="integer-args"></span>
+//!
 //! ### Integer arguments
 //!
 //! Integer arguments must have a type inferrable from context.
@@ -224,6 +225,18 @@
 //! assert_eq!(const_format::concatcp!(1 + 1, 2 + 1), "23");
 //! ```
 //!
+//! # Renaming crate
+//!
+//! All function-like macros from `const_format` can be used when the crate is renamed.
+//!
+//! The [`ConstDebug`] derive macro has the `#[cdeb(crate = "foo::bar")]` attribute to
+//! tell it where to find the `const_format` crate.
+//!
+//! Example of renaming the `const_format` crate in the Cargo.toml file:
+//! ```toml
+//! cfmt = {version = "0.*", package = "const_format"}
+//! ```
+//!
 //! # Cargo features
 //!
 //! - "fmt": Enables the [`std::fmt`]-like API,

const_format/src/macros/assertions.rs

@@ -141,11 +141,12 @@ with_shared_docs! {
     macro_rules! assertc {
         ($cond:expr $(, $fmt_literal:expr $(,$fmt_arg:expr)*)? $(,)? ) => (
             const _: () = {
+                use $crate::__cf_osRcTFl4A;
+
                 const PANIC_IF_TRUE_NHPMWYD3NJA: bool = !($cond);
 
-                const MSG_NHPMWYD3NJA: &str = $crate::assertc!(
-                    @fmt_string
-                    ($crate),
+                const MSG_NHPMWYD3NJA: &str = $crate::pmr::__formatc_if_impl!(
+                    (PANIC_IF_TRUE_NHPMWYD3NJA),
                     (concat!(
                         "{SEP_NHPMWYD3NJA}\
                         module_path: {MODULE_NHPMWYD3NJA}\n\
@@ -169,14 +170,6 @@ with_shared_docs! {
                 $crate::assert_with_str!(PANIC_IF_TRUE_NHPMWYD3NJA, MSG_NHPMWYD3NJA);
             };
         );
-        (@fmt_string ($path:path), ($fmt_literal:expr) $(,$($eveything:tt)*)? ) => (
-            $crate::pmr::__formatc_if_impl!(
-                (($path))
-                (PANIC_IF_TRUE_NHPMWYD3NJA),
-                ($fmt_literal),
-                $($($eveything)*)?
-            )
-        );
     }
 }
 
@@ -574,16 +567,16 @@ macro_rules! __assertc_equality_inner {
                 ),
                 $($($fmt_arg,)*)?
                 fmt_NHPMWYD3NJA = |__cf_fmt| {
-                    use $crate::try_ as __cf_try;
-                    use $crate::coerce_to_fmt as __cf_coerce_to_fmt;
+                    use __cf_osRcTFl4A::try_ as __cf_try;
+                    use __cf_osRcTFl4A::coerce_to_fmt as __cf_coerce_to_fmt;
 
                     #[allow(irrefutable_let_patterns)]
                     if let __cf_respan_to!(($left) [ref __cf_left, ref __cf_right]) =
                         [$left, $right]
                     {__cf_respan_to!{
                         ($left)
                         let __cf_fmt = &mut __cf_fmt
-                            .make_formatter($crate::FormattingFlags::__A_REG);
+                            .make_formatter(__cf_osRcTFl4A::FormattingFlags::__A_REG);
 
                         __cf_try!(__cf_fmt.write_str(" left: `"));
                         __cf_try!(__cf_coerce_to_fmt!(__cf_left).const_debug_fmt(__cf_fmt));

const_format/src/macros/fmt_macros.rs

@@ -54,14 +54,11 @@
 macro_rules! concatcp {
     ()=>{""};
     ($($arg: expr),* $(,)?)=>({
-        $crate::concatcp!(@inner (($crate)), $( ( $arg ), )* )
-    });
-    (@inner (($path:path)) $($everything:tt)*  ) => (
+        use $crate::__cf_osRcTFl4A;
         $crate::pmr::__concatcp_impl!{
-            (($path))
-            $($everything)*
+            $( ( $arg ), )*
         }
-    );
+    });
 }
 
 #[doc(hidden)]
@@ -219,20 +216,14 @@ macro_rules! __concatcp_inner {
 ///
 #[macro_export]
 macro_rules! formatcp {
-    ($format_string:expr $( $(, $expr:expr )+ )? $(,)? ) => (
-        $crate::formatcp!(
-            @inner
-            (($crate))
+    ($format_string:expr $( $(, $expr:expr )+ )? $(,)? ) => ({
+        use $crate::__cf_osRcTFl4A;
+
+        $crate::pmr::__formatcp_impl!(
             ($format_string)
             $(, $(($expr),)+)?
         )
-    );
-    (@inner (($path:path)) $($everything:tt)*  ) => (
-        $crate::pmr::__formatcp_impl!(
-            (($path))
-            $($everything)*
-        )
-    );
+    });
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -287,9 +278,11 @@ macro_rules! formatcp {
 #[macro_export]
 macro_rules! concatc {
     ()=>{""};
-    ($($anything:tt)*)=>(
+    ($($anything:tt)*)=>({
+        use $crate::__cf_osRcTFl4A;
+
         $crate::__concatc_expr!(($($anything)*) ($($anything)*))
-    )
+    })
 }
 
 #[doc(hidden)]
@@ -322,11 +315,7 @@ macro_rules! __concatc_expr {
 #[macro_export]
 macro_rules! __concatc_inner{
     ($debug_fmt_fn:ident, $cond:expr, $($span:tt)*)=>{{
-        use $crate::__cf_osRcTFl4A;
-
         $crate::pmr::respan_to!{($($span)*) {
-
-
             const fn len_nhpmwyd3nj() -> usize {
                 if $cond {
                     let mut strlen = __cf_osRcTFl4A::pmr::ComputeStrLength::new();
@@ -455,18 +444,12 @@ macro_rules! __concatc_inner{
 #[macro_export]
 #[cfg(feature = "fmt")]
 macro_rules! formatc {
-    ($format_string:expr $( $(, $expr:expr )+ )? $(,)? ) => (
-        $crate::formatc!(
-            @inner
-            (($crate))
+    ($format_string:expr $( $(, $expr:expr )+ )? $(,)? ) => ({
+        use $crate::__cf_osRcTFl4A;
+
+        $crate::pmr::__formatc_impl!{
             ($format_string)
             $(, $(($expr),)+)?
-        )
-    );
-    (@inner (($path:path)) $($everything:tt)*  ) => ({
-        $crate::pmr::__formatc_impl!{
-            (($path))
-            $($everything)*
         }
     });
 }
@@ -491,7 +474,7 @@ macro_rules! formatc {
 /// ```
 ///
 /// The syntax is otherwise the same as described in
-/// [the const_format::fmt module](./fmt/index.html#fmtsyntax).
+/// [the `const_format::fmt` module](./fmt/index.html#fmtsyntax).
 ///
 /// # Writers
 ///
@@ -624,6 +607,31 @@ macro_rules! formatc {
 /// # Ok::<(), const_format::Error>(())
 /// ```
 ///
+/// ### Locals in the format string
+///
+/// This example demonstrates how you can format local variables,
+/// by using their identifiers in the format string.
+///
+/// ```rust
+/// #![feature(const_mut_refs)]
+///
+/// use const_format::{Formatter, FormattingFlags, StrWriter, try_, writec};
+///
+/// const fn writeit(mut fmt: Formatter<'_>, foo: u32, bar: &str) -> const_format::Result {
+///     try_!(writec!(fmt, "{foo},{foo:?},{foo:#x},{foo:#b};"));
+///     try_!(writec!(fmt, "{bar},{bar:?}"));
+///     Ok(())
+/// }
+///
+/// let writer: &mut StrWriter = &mut StrWriter::new([0; 128]);
+///
+/// writeit(writer.make_formatter(FormattingFlags::NEW), 100, "hello")?;
+///
+/// assert_eq!(writer.as_str(), r#"100,100,0x64,0b1100100;hello,"hello""#);
+///
+/// # Ok::<(), const_format::Error>(())
+/// ```
+///
 /// [`Formatter`]: ./fmt/struct.Formatter.html
 /// [`WriteMarker`]: ./marker_traits/trait.WriteMarker.html
 ///
@@ -633,19 +641,13 @@ macro_rules! formatc {
 #[macro_export]
 #[cfg(feature = "fmt")]
 macro_rules! writec {
-    ( $writer:expr, $format_string:expr $( $(, $expr:expr )+ )? $(,)? ) => (
-        $crate::writec!(
-            @inner
-            (($crate))
+    ( $writer:expr, $format_string:expr $( $(, $expr:expr )+ )? $(,)? ) => ({
+        use $crate::__cf_osRcTFl4A;
+
+        $crate::pmr::__writec_impl!{
             ($writer)
             ($format_string)
             $(, $(($expr),)+)?
-        )
-    );
-    (@inner (($path:path)) $($everything:tt)*  ) => ({
-        $crate::pmr::__writec_impl!{
-            (($path))
-            $($everything)*
         }
     });
 }

const_format/tests/fmt_tests/display_formatting.rs

@@ -1,4 +1,4 @@
-use const_format::{
+use cfmt_a::{
     fmt::{ComputeStrLength, Error, Formatter, FormattingFlags, StrWriter},
     try_,
     wrapper_types::PWrapper,
@@ -145,8 +145,8 @@ macro_rules! unwrap_opt {
 
 #[test]
 fn display_fmt_other_types() {
-    const fn inner(fmt: &mut Formatter<'_>) -> const_format::Result {
-        const_format::writec!(
+    const fn inner(fmt: &mut Formatter<'_>) -> cfmt_a::Result {
+        cfmt_a::writec!(
             fmt,
             concat!("{},{};", "{},{};{},{};{},{};{},{};",),
             false,

const_format/tests/fmt_tests/formatted_writing.rs

@@ -1,4 +1,4 @@
-use const_format::{
+use cfmt_a::{
     __for_range,
     fmt::{ComputeStrLength, Error, Formatter, FormattingFlags, StrWriter},
     try_,