├── .gitignore
├── src
    ├── lib.rs
    ├── utils.rs
    ├── error.rs
    ├── placeholder.rs
    ├── macros.rs
    ├── template.rs
    └── format_spec.rs
├── .github
    ├── FUNDING.yml
    └── workflows
    │   └── ci.yml
├── examples
    ├── simple.rs
    ├── struct.rs
    ├── language.rs
    └── advance.rs
├── Cargo.toml
├── LICENSE-MIT
├── CHANGELOG.md
├── README.md
└── LICENSE-APACHE


/.gitignore:
--------------------------------------------------------------------------------
1 | /target
2 | /Cargo.lock
3 | 


--------------------------------------------------------------------------------
/src/lib.rs:
--------------------------------------------------------------------------------
 1 | mod error;
 2 | mod format_spec;
 3 | mod macros;
 4 | mod placeholder;
 5 | mod template;
 6 | mod utils;
 7 | 
 8 | pub use error::{Error, ErrorKind};
 9 | pub use template::Template;
10 | 


--------------------------------------------------------------------------------
/.github/FUNDING.yml:
--------------------------------------------------------------------------------
1 | # https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/displaying-a-sponsor-button-in-your-repository
2 | 
3 | github: [clitic]
4 | buy_me_a_coffee: clitic
5 | 


--------------------------------------------------------------------------------
/examples/simple.rs:
--------------------------------------------------------------------------------
1 | use formatx::formatx;
2 | 
3 | fn main() {
4 |     let template = "{} {0:-^10} {percentage:.2}";
5 |     let text = formatx!(template, "world!", "hello", percentage = 99.9999);
6 |     println!("{}", text.unwrap());
7 | }
8 | 


--------------------------------------------------------------------------------
/.github/workflows/ci.yml:
--------------------------------------------------------------------------------
 1 | name: ci
 2 | 
 3 | on:
 4 |   push:
 5 |     branches: "main"
 6 |   pull_request:
 7 |     branches: "main"
 8 | 
 9 | env:
10 |   CARGO_TERM_COLOR: always
11 | 
12 | jobs:
13 |   build:
14 |     runs-on: ubuntu-latest
15 |     steps:
16 |     - uses: actions/checkout@v4
17 |     - name: Build
18 |       run: cargo build
19 |     - name: Test
20 |       run: cargo test
21 | 


--------------------------------------------------------------------------------
/examples/struct.rs:
--------------------------------------------------------------------------------
 1 | use formatx::formatx;
 2 | use std::fmt::Display;
 3 | 
 4 | #[derive(Debug)]
 5 | struct Foo {
 6 |     _bar: String,
 7 | }
 8 | 
 9 | impl Display for Foo {
10 |     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11 |         write!(f, "{:?}", self)
12 |     }
13 | }
14 | 
15 | fn main() {
16 |     let foo = Foo {
17 |         _bar: "foo-bar-struct".to_owned(),
18 |     };
19 | 
20 |     println!("{}", formatx!("{:#?}", foo).unwrap());
21 | }
22 | 


--------------------------------------------------------------------------------
/examples/language.rs:
--------------------------------------------------------------------------------
 1 | use formatx::formatx;
 2 | 
 3 | fn message(language: &str, name: &str, number: i32) -> String {
 4 |     let s = match language {
 5 |         "french" => "Bonjour {}, le nombre est {}",
 6 |         "spanish" => "Hola {}, el numero es {}",
 7 |         _ => "Hi {}, the number is {}",
 8 |     };
 9 |     formatx!(s, name, number).unwrap()
10 | }
11 | 
12 | fn main() {
13 |     println!("{}", message("french", "Léa", 1));
14 |     println!("{}", message("spanish", "Sofia", 2));
15 |     println!("{}", message("english", "Ashley", 3));
16 | }
17 | 


--------------------------------------------------------------------------------
/examples/advance.rs:
--------------------------------------------------------------------------------
 1 | use formatx::Template;
 2 | 
 3 | fn main() {
 4 |     let mut template = "{percentage color=true:.2} => {percentage color=false:.0}%"
 5 |         .parse::<Template>()
 6 |         .unwrap();
 7 | 
 8 |     template.replace_with_callback("percentage", 99.9999, |fmtval, placeholder| {
 9 |         if let Some(color) = placeholder.attr("color") {
10 |             if color == "true" {
11 |                 return "\x1b[31m".to_owned() + &fmtval + "\x1b[0m";
12 |             }
13 |         }
14 | 
15 |         fmtval
16 |     });
17 | 
18 |     println!("{}", template.text().unwrap());
19 | }
20 | 


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | authors = ["clitic <clitic21@gmail.com>"]
 3 | categories = ["rust-patterns", "template-engine"]
 4 | description = "A macro for formatting non literal strings at runtime"
 5 | documentation = "https://docs.rs/formatx"
 6 | edition = "2021"
 7 | exclude = [".github"]
 8 | keywords = ["string", "runtime", "format", "template"]
 9 | license = "MIT OR Apache-2.0"
10 | name = "formatx"
11 | readme = "README.md"
12 | repository = "https://github.com/clitic/formatx"
13 | version = "0.2.4"
14 | 
15 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
16 | 
17 | [dependencies]
18 | 


--------------------------------------------------------------------------------
/src/utils.rs:
--------------------------------------------------------------------------------
 1 | pub(crate) fn is_number(text: &str) -> bool {
 2 |     text.parse::<usize>().is_ok() || text.parse::<isize>().is_ok() || text.parse::<f64>().is_ok()
 3 | }
 4 | 
 5 | pub(crate) fn is_number_and_positive(text: &str) -> bool {
 6 |     if text.parse::<usize>().is_ok() {
 7 |         true
 8 |     } else if let Ok(num) = text.parse::<isize>() {
 9 |         num.is_positive()
10 |     } else if let Ok(num) = text.parse::<f64>() {
11 |         num.is_sign_positive()
12 |     } else {
13 |         false
14 |     }
15 | }
16 | 
17 | pub(crate) fn usize_token(spec: &str, match_index: usize) -> Option<usize> {
18 |     let mut token = None;
19 |     let mut token_index = match_index + 1;
20 | 
21 |     while let Ok(token_suffixed) = spec
22 |         .get(match_index..token_index)
23 |         .unwrap_or("null")
24 |         .parse::<usize>()
25 |     {
26 |         token = Some(token_suffixed);
27 |         token_index += 1;
28 |     }
29 | 
30 |     token
31 | }
32 | 


--------------------------------------------------------------------------------
/LICENSE-MIT:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2022-25 clitic
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/src/error.rs:
--------------------------------------------------------------------------------
 1 | /// Enum of different kinds of errors.
 2 | #[derive(Debug, Clone)]
 3 | pub enum ErrorKind {
 4 |     Parse,
 5 |     MissingValues,
 6 |     UnsupportedFormatSpec,
 7 | }
 8 | 
 9 | /// Error struct which implements [Error](std::error::Error) trait.
10 | #[derive(Debug)]
11 | pub struct Error {
12 |     message: String,
13 |     kind: ErrorKind,
14 | }
15 | 
16 | impl std::fmt::Display for Error {
17 |     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18 |         write!(f, "{}", self.message)
19 |     }
20 | }
21 | 
22 | impl std::error::Error for Error {}
23 | 
24 | impl Error {
25 |     /// Create new parse error.
26 |     pub(crate) fn new_parse(message: String) -> Self {
27 |         Self {
28 |             message,
29 |             kind: ErrorKind::Parse,
30 |         }
31 |     }
32 | 
33 |     /// Create new missing values error.
34 |     pub(crate) fn new_values(message: String) -> Self {
35 |         Self {
36 |             message,
37 |             kind: ErrorKind::MissingValues,
38 |         }
39 |     }
40 | 
41 |     /// Create new unsupported format spec error.
42 |     pub(crate) fn new_ufs(message: String) -> Self {
43 |         Self {
44 |             message,
45 |             kind: ErrorKind::UnsupportedFormatSpec,
46 |         }
47 |     }
48 | 
49 |     /// Returns error message.
50 |     pub fn message(&self) -> String {
51 |         self.message.clone()
52 |     }
53 | 
54 |     /// Returns `ErrorKind`
55 |     pub fn kind(&self) -> ErrorKind {
56 |         self.kind.clone()
57 |     }
58 | }
59 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
 1 | # Changelog
 2 | 
 3 | All notable changes to this project will be documented in this file.
 4 | 
 5 | The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0),
 6 | and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 7 | 
 8 | ## [Unreleased]
 9 | 
10 | ## [0.2.4] - 2024-05-04
11 | 
12 | ### Fixed
13 | 
14 | - Suppport for trailing commas when calling `formatx!` macro. ([#11](https://github.com/clitic/formatx/pull/11))
15 | 
16 | ## [0.2.3] - 2024-12-15
17 | 
18 | ### Fixed
19 | 
20 | - clippy warnings. ([#6](https://github.com/clitic/formatx/pull/6))
21 | 
22 | ## [0.2.2] - 2023-12-03
23 | 
24 | ### Fixed
25 | 
26 | - Use `std::result::Result` in `formatx!` macro. ([#4](https://github.com/clitic/formatx/pull/4))
27 | 
28 | ## [0.2.1] - 2023-02-03
29 | 
30 | ### Fixed
31 | 
32 | - `formatx!` macro clippy warnings.
33 | 
34 | ## [0.2.0] - 2022-12-06
35 | 
36 | ### Added
37 | 
38 | - Better `formatx!` macro expansion.
39 | 
40 | ### Changed
41 | 
42 | - `formatx!(template: expr)` macro returns `Result<String, formatx::Error>`.
43 | 
44 | ## [0.1.4] - 2022-08-15
45 | 
46 | ## [0.1.3] - 2022-08-05
47 | 
48 | ## [0.1.2] - 2022-08-05
49 | 
50 | ## [0.1.1] - 2022-08-05
51 | 
52 | ## [0.1.0] - 2022-08-03
53 | 
54 | [Unreleased]: https://github.com/clitic/formatx/compare/0.2.4...HEAD
55 | [0.2.4]: https://github.com/clitic/formatx/compare/v0.2.3...0.2.4
56 | [0.2.3]: https://github.com/clitic/formatx/compare/v0.2.2...0.2.3
57 | [0.2.2]: https://github.com/clitic/formatx/compare/v0.2.1...v0.2.2
58 | [0.2.1]: https://github.com/clitic/formatx/compare/v0.2.0...v0.2.1
59 | [0.2.0]: https://github.com/clitic/formatx/compare/c672c19...v0.2.0
60 | [0.1.4]: https://github.com/clitic/formatx/compare/b2ee21f...c672c19
61 | [0.1.3]: https://github.com/clitic/formatx/compare/39eb3ee...b2ee21f
62 | [0.1.2]: https://github.com/clitic/formatx/compare/0f282e2...39eb3ee
63 | [0.1.1]: https://github.com/clitic/formatx/compare/454cd82...0f282e2
64 | [0.1.0]: https://github.com/clitic/formatx/compare/0a4cc2d...454cd82
65 | 


--------------------------------------------------------------------------------
/src/placeholder.rs:
--------------------------------------------------------------------------------
 1 | use crate::error::Error;
 2 | use crate::format_spec::FormatSpec;
 3 | 
 4 | /// Template placeholder specifications.
 5 | #[derive(Debug, Clone)]
 6 | pub struct Placeholder {
 7 |     pub attributes: Option<String>,
 8 |     pub format_spec: FormatSpec,
 9 |     pub replacer: String,
10 | }
11 | 
12 | impl Placeholder {
13 |     /// Parse template string and deserialize it to `Self`.
14 |     pub fn new(template: &str, placeholder: &str) -> Result<Option<Self>, Error> {
15 |         if let Some(start) = template.find(&format!("{{{}", placeholder)) {
16 |             let matched = &template[(start + 1)..(start + template[start..].find('}').unwrap())];
17 | 
18 |             let attributes = if matched.rfind(':').is_some() {
19 |                 let mut attributes = matched.split(':').collect::<Vec<&str>>();
20 |                 let _ = attributes.pop();
21 |                 attributes
22 |                     .join(":")
23 |                     .trim_start_matches(placeholder)
24 |                     .trim()
25 |                     .to_owned()
26 |             } else {
27 |                 matched.trim_start_matches(placeholder).trim().to_owned()
28 |             };
29 | 
30 |             let attributes = if attributes.is_empty() {
31 |                 None
32 |             } else {
33 |                 Some(attributes)
34 |             };
35 | 
36 |             return Ok(Some(Self {
37 |                 attributes,
38 |                 format_spec: FormatSpec::new(matched)?,
39 |                 replacer: format!("{{{}}}", matched),
40 |             }));
41 |         }
42 | 
43 |         Ok(None)
44 |     }
45 | 
46 |     /// Get attribute value if present else returns `None`.
47 |     ///
48 |     /// Attributes can be defined for as:
49 |     ///
50 |     /// ```text
51 |     /// 1. name=emily -> Some("emily")
52 |     /// 2. name="emily cooper" -> Some("emily cooper")
53 |     /// 3. name='emily clarke' -> Some("emily clarke")
54 |     /// ```
55 |     pub fn attr(&self, attribute: &str) -> Option<String> {
56 |         if let Some(attributes) = &self.attributes {
57 |             let attribute_identifier = format!("{}=", attribute);
58 | 
59 |             if let Some(attribute_index) = attributes.find(&attribute_identifier) {
60 |                 let value = attributes[attribute_index..].trim_start_matches(&attribute_identifier);
61 | 
62 |                 if let Some(stripped) = value.strip_prefix('\"') {
63 |                     return Some(value[1..(stripped.find('\"')? + 1)].to_owned());
64 |                 } else if let Some(stripped) = value.strip_prefix('\'') {
65 |                     return Some(value[1..(stripped.find('\'')? + 1)].to_owned());
66 |                 } else {
67 |                     return value.split(' ').next().map(|x| x.to_owned());
68 |                 }
69 |             }
70 |         }
71 | 
72 |         None
73 |     }
74 | }
75 | 


--------------------------------------------------------------------------------
/src/macros.rs:
--------------------------------------------------------------------------------
  1 | /// Creates a `String` using interpolation of runtime expressions at runtime.
  2 | ///
  3 | /// The first argument `formatx!` receives is a format string.
  4 | /// The power of the formatting string is in the `{}`s contained.
  5 | ///
  6 | /// Additional parameters passed to `formatx!` replace the `{}`s within the
  7 | /// formatting string in the order given unless named or positional parameters
  8 | /// are used; see [std::fmt](std::fmt) for more information.
  9 | ///
 10 | /// A common use for `formatx!` is concatenation and interpolation of strings at runtime.
 11 | /// The same convention is used with [print!](std::print) and [write!](core::write) macros,
 12 | /// depending on the intended destination of the string.
 13 | ///
 14 | /// To convert a single value to a string, use the `to_string` method. This
 15 | /// will use the [Display](core::fmt::Display) formatting trait.
 16 | ///
 17 | /// # Panics
 18 | ///
 19 | /// `formatx!` panics if a formatting trait implementation returns an error.
 20 | /// This indicates an incorrect implementation
 21 | /// since `fmt::Write for String` never returns an error itself.
 22 | /// Additonally `formatx!` returns a `Result<String, formatx::Error>` type which can be resolved later.
 23 | ///
 24 | /// # Examples
 25 | ///
 26 | /// Any type could be formatted if it implements [Display](std::fmt::Display) + [Debug](std::fmt::Debug) traits.
 27 | ///
 28 | /// ```
 29 | /// use formatx::formatx;
 30 | ///
 31 | /// formatx!("test").unwrap();
 32 | /// formatx!("hello {}", "world!").unwrap();
 33 | /// formatx!("x = {}, y = {y}", 10, y = 30).unwrap();
 34 | /// ```
 35 | #[macro_export]
 36 | macro_rules! formatx {
 37 |     ($template: expr $(,)?) => {
 38 |         || -> ::std::result::Result<String, $crate::Error> {
 39 |             $crate::Template::new($template)?.text()
 40 |         }()
 41 |     };
 42 | 
 43 |     ($template: expr, $($values: tt)*) => {
 44 |         || -> ::std::result::Result<String, $crate::Error> {
 45 |             let mut template = $crate::Template::new($template)?;
 46 |             $crate::_formatx_internal!(template, $($values)*);
 47 |             template.text()
 48 |         }()
 49 |     };
 50 | }
 51 | 
 52 | #[macro_export]
 53 | #[doc(hidden)]
 54 | macro_rules! _formatx_internal {
 55 |     ($template: expr, $name: ident = $value: expr $(,)?) => {
 56 |         $template.replace(stringify!($name), $value);
 57 |     };
 58 | 
 59 |     ($template: expr, $value: expr $(,)?) => (
 60 |         $template.replace_positional($value);
 61 |     );
 62 | 
 63 |     ($template: expr, $name: ident = $value: expr, $($values: tt)*) => {
 64 |         $template.replace(stringify!($name), $value);
 65 |         $crate::_formatx_internal!($template, $($values)*);
 66 |     };
 67 | 
 68 |     ($template: expr, $value:expr, $($values: tt)*) => {
 69 |     	$template.replace_positional($value);
 70 |         $crate::_formatx_internal!($template, $($values)*);
 71 |     };
 72 | }
 73 | 
 74 | #[cfg(test)]
 75 | mod tests {
 76 |     use crate::formatx;
 77 | 
 78 |     macro_rules! formatx_test {
 79 |         ($template: expr, $($values: tt)*) => {
 80 |             assert_eq!(formatx!($template, $($values)*).unwrap(), format!($template, $($values)*))
 81 |         }
 82 |     }
 83 | 
 84 |     #[test]
 85 |     fn text() {
 86 |         assert_eq!(formatx!("Hello").unwrap(), format!("Hello"));
 87 |     }
 88 | 
 89 |     #[test]
 90 |     fn positional() {
 91 |         formatx_test!("Hello, {}!", "world");
 92 |         formatx_test!("The number is {}", 1);
 93 |         formatx_test!("{} {}", 1, 2);
 94 |     }
 95 | 
 96 |     #[test]
 97 |     fn named() {
 98 |         formatx_test!("{value}", value = 4);
 99 |         formatx_test!("{argument}", argument = "test");
100 |         formatx_test!("{a} {c} {b}", a = "a", b = 'b', c = 3);
101 |     }
102 | 
103 |     #[test]
104 |     fn intermixed() {
105 |         formatx_test!("{name} {}", 1, name = 2);
106 |     }
107 | 
108 |     #[test]
109 |     fn width() {
110 |         formatx_test!("Hello {:5}!", "x");
111 |         formatx_test!("Hello {:05}!", -5);
112 |     }
113 | 
114 |     #[test]
115 |     fn zero_width() {
116 |         formatx_test!("{:04}", 42);
117 |         formatx_test!("Hello {:05}!", 5);
118 |     }
119 | 
120 |     #[test]
121 |     fn align() {
122 |         formatx_test!("Hello {:<5}!", "x");
123 |         formatx_test!("Hello {:-<5}!", "x");
124 |         formatx_test!("Hello {:^5}!", "x");
125 |         formatx_test!("Hello {:>5}!", "x");
126 |     }
127 | 
128 |     #[test]
129 |     fn sign() {
130 |         formatx_test!("Hello {:+}!", 5)
131 |     }
132 | 
133 |     #[test]
134 |     fn precision() {
135 |         formatx_test!("Hello {0} is {1:.5}", "x", 0.01)
136 |     }
137 | 
138 |     #[test]
139 |     fn escaping() {
140 |         assert_eq!(formatx!("Hello {{}}").unwrap(), format!("Hello {{}}"));
141 |         assert_eq!(formatx!("{{ Hello").unwrap(), format!("{{ Hello"));
142 |     }
143 | 
144 |     #[test]
145 |     fn debug() {
146 |         formatx_test!("{} {:?}", 3, 4);
147 |         formatx_test!("{} {:?}", 'a', 'b');
148 |         formatx_test!("{} {:?}", "foo\n", "bar\n");
149 |     }
150 | 
151 |     #[test]
152 |     fn trailing_commas() {
153 |         formatx_test!("Hello",);
154 |         formatx_test!("Hello {}", "world",);
155 |         formatx_test!("Hello {1} {0}", "1", "0",);
156 |         formatx_test!("Hello {name}", name = "John",);
157 |     }
158 | }
159 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | <h1 align="center">formatx</h1>
  2 | 
  3 | <p align="center">
  4 |   <a href="https://crates.io/crates/formatx">
  5 |     <img src="https://img.shields.io/crates/d/formatx?style=flat-square">
  6 |   </a>
  7 |   <a href="https://crates.io/crates/formatx">
  8 |     <img src="https://img.shields.io/crates/v/formatx?style=flat-square">
  9 |   </a>
 10 |   <a href="https://github.com/clitic/formatx">
 11 |     <img src="https://img.shields.io/github/actions/workflow/status/clitic/formatx/ci.yml?logo=github&style=flat-square">
 12 |   </a>
 13 |   <a href="https://docs.rs/formatx/latest/formatx">
 14 |     <img src="https://img.shields.io/docsrs/formatx?logo=docsdotrs&style=flat-square">
 15 |   </a>
 16 |   <a href="https://github.com/clitic/formatx#license">
 17 |     <img src="https://img.shields.io/crates/l/formatx?style=flat-square">
 18 |   </a>
 19 |   <a href="https://github.com/clitic/formatx">
 20 |     <img src="https://img.shields.io/github/repo-size/clitic/formatx?style=flat-square">
 21 |   </a>
 22 | </p>
 23 | 
 24 | <p align="center">A macro for formatting non literal strings at runtime in Rust.</p>
 25 | 
 26 | `formatx` is a dependency free string templating library with syntax derived from [std::fmt](https://doc.rust-lang.org/std/fmt/#syntax). formatx exports [formatx!](https://docs.rs/formatx/latest/formatx/macro.formatx.html) macro which is similar to [format!](https://doc.rust-lang.org/std/macro.format.html) macro. formatx works by first parsing the template string and then it uses `format!` macro internally to replicate it's behaviour. formatx aims for formatting strings and numbers although an generic type can also be formatted like an [struct](https://github.com/clitic/formatx/blob/main/examples/struct.rs).
 27 | 
 28 | ## Getting Started
 29 | 
 30 | Add this to your Cargo.toml file.
 31 | 
 32 | ```toml
 33 | [dependencies]
 34 | formatx = "0.2.4"
 35 | ```
 36 | 
 37 | Or add from command line.
 38 | 
 39 | ```bash
 40 | $ cargo add formatx
 41 | ```
 42 | 
 43 | See [docs](https://docs.rs/formatx/latest/formatx) and [examples](https://github.com/clitic/formatx.rs/tree/main/examples) to 
 44 | know how to use it.
 45 | 
 46 | ## Example
 47 | 
 48 | SOURCE: [format! with non literal string](https://users.rust-lang.org/t/format-with-non-literal-string/2057)
 49 | 
 50 | ```rust
 51 | use formatx::formatx;
 52 | 
 53 | fn message(language: &str, name: &str, number: i32) -> String {
 54 |     let s = match language {
 55 |         "french" => "Bonjour {}, le nombre est {}",
 56 |         "spanish" => "Hola {}, el numero es {}",
 57 |         _ => "Hi {}, the number is {}",
 58 |     };
 59 |     formatx!(s, name, number).unwrap()
 60 | }
 61 | 
 62 | fn main() {
 63 |     println!("{}", message("french", "Léa", 1));
 64 |     println!("{}", message("spanish", "Sofia", 2));
 65 |     println!("{}", message("english", "Ashley", 3));
 66 | }
 67 | ```
 68 | 
 69 | OUTPUT
 70 | 
 71 | ```
 72 | Bonjour Léa, le nombre est 1
 73 | Hola Sofia, el numero es 2
 74 | Hi Ashley, the number is 3
 75 | ```
 76 | 
 77 | ## Syntax
 78 | 
 79 | The main goal of `formatx` is to provide a almost identical syntax as of rust's format syntax. The syntax of `formatx` is identical to [std::fmt](https://doc.rust-lang.org/std/fmt/#syntax). You can also see gettext [documentation](https://www.gnu.org/software/gettext/manual/html_node/rust_002dformat.html), the rust's format syntax specifications is mentioned there too.
 80 | 
 81 | ## Limitations
 82 | 
 83 | > **Warning**
 84 | > Examples given below will always panic.
 85 | 
 86 | 1. Only types which implements [Display](https://doc.rust-lang.org/std/fmt/trait.Display.html) + [Debug](https://doc.rust-lang.org/std/fmt/trait.Debug.html) traits are supported. Other [formatting-traits](https://doc.rust-lang.org/std/fmt/#formatting-traits) aren't supported.
 87 | 
 88 | 2. Local variable interpolation isn't supported.
 89 | 
 90 | ```rust
 91 | let people = "Rustaceans";
 92 | formatx!("Hello {people}!").unwrap();
 93 | ```
 94 | 
 95 | 3. Intermingling the two types of [positional](https://doc.rust-lang.org/std/fmt/#positional-parameters) specifiers isn't supported.
 96 | 
 97 | ```rust
 98 | formatx!("{1} {} {0} {}", 1, 2).unwrap();
 99 | ```
100 | 
101 | 4. Parameter setting through `$` sign argument isn't supported.
102 | 
103 | ```rust
104 | formatx!("{:width$}!", "x", width = 5).unwrap();
105 | ```
106 | 
107 | 5. An asterisk `.*` can't be used to set [precision](https://doc.rust-lang.org/std/fmt/#precision).
108 | 
109 | ```rust
110 | formatx!("{:.*}", 5, 0.01).unwrap();
111 | ```
112 | 
113 | ## Handling Of Positional Arguments
114 | 
115 | Positional arguments are handled by an internal key which increments itself whenever an postional argument is passed through the macro. So, the behaviour is very different when compared to `format` macro.
116 | 
117 | By default this internal key is set to `0` and when an positional argument is passed. `formatx` resolves the replacement by first checking if there is `0` key present in format string (eg. `Hello {0}`) or not, if the `0` is present then it replaces it, else if the `0` key is not present in the format string (eg.`Hello {}`) it replaces the first blank placeholder. After a replacement is made this internal key is increased by `1`.
118 | 
119 | ```rust
120 | asserteq!(
121 |   format!("{} {2} {} {1} {4} {} {3} {5} {6}", "zero", "one", "two", "three", "four", "five", "six"),
122 |   formatx!("{} {2} {} {1} {4} {} {3} {5} {6}", "zero", "one", "two", "three", "four", "five", "six", "seven", "eight").unwrap() // This line won't panic
123 | ); // This line will panic
124 | ```
125 | 
126 | An error cannot be raised in such cases because `formatx` works at runtime and it doesn't know the future upcoming postitional arguments. So while designing your app keep this point in mind or simply use key value arguments. See issue [#7](https://github.com/clitic/formatx/issues/7) for more info.
127 | 
128 | ## Handling Of Unused Arguments
129 | 
130 | Unlike rust's built-in `format!` macro, which reports an error if any provided arguments are not used in the format string, `formatx!` allows unused arguments. This can be particularly useful in localization scenarios, where translations may or may not require certain arguments depending on grammatical rules.
131 | 
132 | ## Packaging Status
133 | 
134 | [![Packaging status](https://repology.org/badge/vertical-allrepos/rust%3Aformatx.svg)](https://repology.org/project/rust%3Aformatx/versions)
135 | 
136 | ## Alternatives
137 | 
138 | 1. [strfmt](https://github.com/vitiral/strfmt)
139 | 2. [runtime-fmt](https://github.com/SpaceManiac/runtime-fmt)
140 | 
141 | ## License
142 | 
143 | Dual Licensed
144 | 
145 | - [Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0) ([LICENSE-APACHE](LICENSE-APACHE))
146 | - [MIT license](https://opensource.org/licenses/MIT) ([LICENSE-MIT](LICENSE-MIT))
147 | 


--------------------------------------------------------------------------------
/src/template.rs:
--------------------------------------------------------------------------------
  1 | use std::collections::HashMap;
  2 | use std::fmt::{Debug, Display};
  3 | use std::str::FromStr;
  4 | 
  5 | use crate::error::Error;
  6 | use crate::placeholder::Placeholder;
  7 | 
  8 | /// String template with [std::fmt](std::fmt) syntax.
  9 | ///
 10 | /// # Example
 11 | ///
 12 | /// ```
 13 | /// use formatx::Template;
 14 | ///
 15 | /// let mut template = "{percentage:.2}".parse::<Template>().unwrap();
 16 | /// template.replace("percentage", 67.7892);
 17 | /// assert_eq!(template.text().unwrap(), "67.79");
 18 | /// ```
 19 | #[derive(Debug, Clone)]
 20 | pub struct Template {
 21 |     template: String,
 22 |     position: usize,
 23 |     placeholders: HashMap<String, Vec<Placeholder>>,
 24 | }
 25 | 
 26 | impl Display for Template {
 27 |     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 28 |         write!(f, "{}", self.unchecked_text())
 29 |     }
 30 | }
 31 | 
 32 | impl FromStr for Template {
 33 |     type Err = Error;
 34 | 
 35 |     fn from_str(s: &str) -> Result<Self, Self::Err> {
 36 |         Self::new(s)
 37 |     }
 38 | }
 39 | 
 40 | impl Template {
 41 |     /// Create a new instance of `format_template::Template`.
 42 |     ///
 43 |     /// # Example
 44 |     ///
 45 |     /// ```
 46 |     /// use formatx::Template;
 47 |     ///
 48 |     /// let template = Template::new("{percentage:.2}").unwrap();
 49 |     /// ```
 50 |     pub fn new<T: Into<String>>(template: T) -> Result<Self, Error> {
 51 |         let mut template_struct = Self {
 52 |             template: {
 53 |                 // Escaping curly braces
 54 |                 let mut template = template.into().replace("{{", "[curly=open]");
 55 | 
 56 |                 while let Some(curly_close) = template.rfind("}}") {
 57 |                     template.replace_range(curly_close..=(curly_close + 1), "[curly=close]");
 58 |                 }
 59 | 
 60 |                 template
 61 |             },
 62 |             position: 0,
 63 |             placeholders: HashMap::new(),
 64 |         };
 65 | 
 66 |         // Checking number curly braces
 67 |         let curly_open_count = template_struct
 68 |             .template
 69 |             .chars()
 70 |             .filter(|x| x.to_string() == "{")
 71 |             .count();
 72 |         let curly_close_count = template_struct
 73 |             .template
 74 |             .chars()
 75 |             .filter(|x| x.to_string() == "}")
 76 |             .count();
 77 | 
 78 |         if curly_open_count != curly_close_count {
 79 |             return Err(Error::new_parse(format!(
 80 |                 "number of opening and closing curly braces are not equal i.e. {} != {}",
 81 |                 curly_open_count, curly_close_count
 82 |             )));
 83 |         }
 84 | 
 85 |         // Adding position for positional placeholders.
 86 |         let mut position = 0;
 87 |         let placeholders = template_struct.get_placeholders();
 88 | 
 89 |         while template_struct.template.contains("{}") || template_struct.template.contains("{:") {
 90 |             while placeholders.contains(&position.to_string()) {
 91 |                 position += 1;
 92 |             }
 93 | 
 94 |             match (
 95 |                 template_struct.template.find("{}"),
 96 |                 template_struct.template.find("{:"),
 97 |             ) {
 98 |                 (Some(_), None) => {
 99 |                     template_struct.template =
100 |                         template_struct
101 |                             .template
102 |                             .replacen("{}", &format!("{{{}}}", position), 1);
103 |                     position += 1;
104 |                 }
105 |                 (None, Some(_)) => {
106 |                     template_struct.template =
107 |                         template_struct
108 |                             .template
109 |                             .replacen("{:", &format!("{{{}:", position), 1);
110 |                     position += 1;
111 |                 }
112 |                 (Some(x), Some(y)) => {
113 |                     if y > x {
114 |                         template_struct.template = template_struct.template.replacen(
115 |                             "{}",
116 |                             &format!("{{{}}}", position),
117 |                             1,
118 |                         );
119 |                     } else {
120 |                         template_struct.template =
121 |                             template_struct
122 |                                 .template
123 |                                 .replacen("{:", &format!("{{{}:", position), 1);
124 |                     }
125 | 
126 |                     position += 1;
127 |                 }
128 |                 (None, None) => (),
129 |             }
130 |         }
131 | 
132 |         // Parsing placeholders
133 |         let mut query_template = template_struct.template.clone();
134 | 
135 |         for name in template_struct.get_placeholders() {
136 |             let placeholder = Placeholder::new(&query_template, &name);
137 |             let placeholder = placeholder?.unwrap();
138 |             query_template = query_template.replacen(&placeholder.replacer, "", 1);
139 | 
140 |             if let Some(children) = template_struct.placeholders.get_mut(&name) {
141 |                 children.push(placeholder);
142 |             } else {
143 |                 template_struct
144 |                     .placeholders
145 |                     .insert(name.to_owned(), vec![placeholder]);
146 |             }
147 |         }
148 | 
149 |         Ok(template_struct)
150 |     }
151 | 
152 |     /// Returns list of template placeholders names.
153 |     fn get_placeholders(&self) -> Vec<String> {
154 |         let mut placeholders = vec![];
155 |         let mut template = self.template.clone();
156 | 
157 |         while template.contains('{') && template.contains('}') {
158 |             if let (Some(start), Some(end)) = (template.find('{'), template.find('}')) {
159 |                 let placeholder = template[(start + 1)..end].to_owned();
160 |                 template.replace_range(start..=end, "");
161 | 
162 |                 if let Some(colon) = placeholder.find(':') {
163 |                     placeholders.push(placeholder[..colon].split(' ').next().unwrap().to_owned());
164 |                 } else {
165 |                     placeholders.push(placeholder.split(' ').next().unwrap().to_owned());
166 |                 }
167 |             }
168 |         }
169 | 
170 |         placeholders
171 |     }
172 | 
173 |     /// Checks wheter template contains placeholder or not.
174 |     pub fn contains<T: ToString>(&self, placeholder: T) -> bool {
175 |         self.placeholders.contains_key(&placeholder.to_string())
176 |     }
177 | 
178 |     /// Returns unchecked formatted template.
179 |     /// For `Result` version of fomatted template use `.text` method.
180 |     pub fn unchecked_text(&self) -> String {
181 |         self.template
182 |             .replace("[curly=open]", "{")
183 |             .replace("[curly=close]", "}")
184 |     }
185 | 
186 |     /// Checks wheter all placeholders are replaced or not and returns formatted template.
187 |     pub fn text(&self) -> Result<String, Error> {
188 |         if self.placeholders.is_empty() {
189 |             Ok(self.unchecked_text())
190 |         } else {
191 |             Err(Error::new_values(format!(
192 |                 "missing placeholders values for: {}",
193 |                 self.placeholders
194 |                     .keys()
195 |                     .map(|x| {
196 |                         if x.parse::<usize>().is_ok() {
197 |                             format!("{} (positional)", x)
198 |                         } else {
199 |                             format!("{} (named)", x)
200 |                         }
201 |                     })
202 |                     .collect::<Vec<String>>()
203 |                     .join(", ")
204 |             )))
205 |         }
206 |     }
207 | 
208 |     /// Replace a template placeholder with a value.
209 |     /// This change is inplace.
210 |     pub fn replace<T, U>(&mut self, placeholder: T, value: U)
211 |     where
212 |         T: ToString,
213 |         U: Display + Debug,
214 |     {
215 |         self.replace_with_callback(placeholder, value, |formatted_value, _| formatted_value)
216 |     }
217 | 
218 |     /// Replace a template positional placeholder with a value.
219 |     /// This change is inplace.
220 |     pub fn replace_positional<T>(&mut self, value: T)
221 |     where
222 |         T: Display + Debug,
223 |     {
224 |         self.replace_with_callback(self.position.to_string(), value, |formatted_value, _| {
225 |             formatted_value
226 |         });
227 |         self.position += 1;
228 |     }
229 | 
230 |     /// Replace a template placeholder from a callback `String`.
231 |     /// This change is inplace.
232 |     pub fn replace_from_callback<T, U>(&mut self, placeholder: T, callback: U)
233 |     where
234 |         T: ToString,
235 |         U: Fn(&Placeholder) -> String,
236 |     {
237 |         let placeholder = placeholder.to_string();
238 | 
239 |         if let Some(placeholders) = self.placeholders.get(&placeholder) {
240 |             for holder in placeholders {
241 |                 self.template = self.template.replace(&holder.replacer, &callback(holder));
242 |             }
243 | 
244 |             let _ = self.placeholders.remove(&placeholder);
245 |         }
246 |     }
247 | 
248 |     /// Replace a template placeholder with a value and do additional formatting using callback.
249 |     /// This change is inplace.
250 |     pub fn replace_with_callback<T, U, V>(&mut self, placeholder: T, value: U, callback: V)
251 |     where
252 |         T: ToString,
253 |         U: Display + Debug,
254 |         V: Fn(String, &Placeholder) -> String,
255 |     {
256 |         let placeholder = placeholder.to_string();
257 | 
258 |         if let Some(placeholders) = self.placeholders.get(&placeholder) {
259 |             for holder in placeholders {
260 |                 self.template = self.template.replace(
261 |                     &holder.replacer,
262 |                     &callback(holder.format_spec.format(&value), holder),
263 |                 );
264 |             }
265 | 
266 |             let _ = self.placeholders.remove(&placeholder);
267 |         }
268 |     }
269 | }
270 | 


--------------------------------------------------------------------------------
/LICENSE-APACHE:
--------------------------------------------------------------------------------
  1 |                                  Apache License
  2 |                            Version 2.0, January 2004
  3 |                         http://www.apache.org/licenses/
  4 | 
  5 |    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  6 | 
  7 |    1. Definitions.
  8 | 
  9 |       "License" shall mean the terms and conditions for use, reproduction,
 10 |       and distribution as defined by Sections 1 through 9 of this document.
 11 | 
 12 |       "Licensor" shall mean the copyright owner or entity authorized by
 13 |       the copyright owner that is granting the License.
 14 | 
 15 |       "Legal Entity" shall mean the union of the acting entity and all
 16 |       other entities that control, are controlled by, or are under common
 17 |       control with that entity. For the purposes of this definition,
 18 |       "control" means (i) the power, direct or indirect, to cause the
 19 |       direction or management of such entity, whether by contract or
 20 |       otherwise, or (ii) ownership of fifty percent (50%) or more of the
 21 |       outstanding shares, or (iii) beneficial ownership of such entity.
 22 | 
 23 |       "You" (or "Your") shall mean an individual or Legal Entity
 24 |       exercising permissions granted by this License.
 25 | 
 26 |       "Source" form shall mean the preferred form for making modifications,
 27 |       including but not limited to software source code, documentation
 28 |       source, and configuration files.
 29 | 
 30 |       "Object" form shall mean any form resulting from mechanical
 31 |       transformation or translation of a Source form, including but
 32 |       not limited to compiled object code, generated documentation,
 33 |       and conversions to other media types.
 34 | 
 35 |       "Work" shall mean the work of authorship, whether in Source or
 36 |       Object form, made available under the License, as indicated by a
 37 |       copyright notice that is included in or attached to the work
 38 |       (an example is provided in the Appendix below).
 39 | 
 40 |       "Derivative Works" shall mean any work, whether in Source or Object
 41 |       form, that is based on (or derived from) the Work and for which the
 42 |       editorial revisions, annotations, elaborations, or other modifications
 43 |       represent, as a whole, an original work of authorship. For the purposes
 44 |       of this License, Derivative Works shall not include works that remain
 45 |       separable from, or merely link (or bind by name) to the interfaces of,
 46 |       the Work and Derivative Works thereof.
 47 | 
 48 |       "Contribution" shall mean any work of authorship, including
 49 |       the original version of the Work and any modifications or additions
 50 |       to that Work or Derivative Works thereof, that is intentionally
 51 |       submitted to Licensor for inclusion in the Work by the copyright owner
 52 |       or by an individual or Legal Entity authorized to submit on behalf of
 53 |       the copyright owner. For the purposes of this definition, "submitted"
 54 |       means any form of electronic, verbal, or written communication sent
 55 |       to the Licensor or its representatives, including but not limited to
 56 |       communication on electronic mailing lists, source code control systems,
 57 |       and issue tracking systems that are managed by, or on behalf of, the
 58 |       Licensor for the purpose of discussing and improving the Work, but
 59 |       excluding communication that is conspicuously marked or otherwise
 60 |       designated in writing by the copyright owner as "Not a Contribution."
 61 | 
 62 |       "Contributor" shall mean Licensor and any individual or Legal Entity
 63 |       on behalf of whom a Contribution has been received by Licensor and
 64 |       subsequently incorporated within the Work.
 65 | 
 66 |    2. Grant of Copyright License. Subject to the terms and conditions of
 67 |       this License, each Contributor hereby grants to You a perpetual,
 68 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 69 |       copyright license to reproduce, prepare Derivative Works of,
 70 |       publicly display, publicly perform, sublicense, and distribute the
 71 |       Work and such Derivative Works in Source or Object form.
 72 | 
 73 |    3. Grant of Patent License. Subject to the terms and conditions of
 74 |       this License, each Contributor hereby grants to You a perpetual,
 75 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 76 |       (except as stated in this section) patent license to make, have made,
 77 |       use, offer to sell, sell, import, and otherwise transfer the Work,
 78 |       where such license applies only to those patent claims licensable
 79 |       by such Contributor that are necessarily infringed by their
 80 |       Contribution(s) alone or by combination of their Contribution(s)
 81 |       with the Work to which such Contribution(s) was submitted. If You
 82 |       institute patent litigation against any entity (including a
 83 |       cross-claim or counterclaim in a lawsuit) alleging that the Work
 84 |       or a Contribution incorporated within the Work constitutes direct
 85 |       or contributory patent infringement, then any patent licenses
 86 |       granted to You under this License for that Work shall terminate
 87 |       as of the date such litigation is filed.
 88 | 
 89 |    4. Redistribution. You may reproduce and distribute copies of the
 90 |       Work or Derivative Works thereof in any medium, with or without
 91 |       modifications, and in Source or Object form, provided that You
 92 |       meet the following conditions:
 93 | 
 94 |       (a) You must give any other recipients of the Work or
 95 |           Derivative Works a copy of this License; and
 96 | 
 97 |       (b) You must cause any modified files to carry prominent notices
 98 |           stating that You changed the files; and
 99 | 
100 |       (c) You must retain, in the Source form of any Derivative Works
101 |           that You distribute, all copyright, patent, trademark, and
102 |           attribution notices from the Source form of the Work,
103 |           excluding those notices that do not pertain to any part of
104 |           the Derivative Works; and
105 | 
106 |       (d) If the Work includes a "NOTICE" text file as part of its
107 |           distribution, then any Derivative Works that You distribute must
108 |           include a readable copy of the attribution notices contained
109 |           within such NOTICE file, excluding those notices that do not
110 |           pertain to any part of the Derivative Works, in at least one
111 |           of the following places: within a NOTICE text file distributed
112 |           as part of the Derivative Works; within the Source form or
113 |           documentation, if provided along with the Derivative Works; or,
114 |           within a display generated by the Derivative Works, if and
115 |           wherever such third-party notices normally appear. The contents
116 |           of the NOTICE file are for informational purposes only and
117 |           do not modify the License. You may add Your own attribution
118 |           notices within Derivative Works that You distribute, alongside
119 |           or as an addendum to the NOTICE text from the Work, provided
120 |           that such additional attribution notices cannot be construed
121 |           as modifying the License.
122 | 
123 |       You may add Your own copyright statement to Your modifications and
124 |       may provide additional or different license terms and conditions
125 |       for use, reproduction, or distribution of Your modifications, or
126 |       for any such Derivative Works as a whole, provided Your use,
127 |       reproduction, and distribution of the Work otherwise complies with
128 |       the conditions stated in this License.
129 | 
130 |    5. Submission of Contributions. Unless You explicitly state otherwise,
131 |       any Contribution intentionally submitted for inclusion in the Work
132 |       by You to the Licensor shall be under the terms and conditions of
133 |       this License, without any additional terms or conditions.
134 |       Notwithstanding the above, nothing herein shall supersede or modify
135 |       the terms of any separate license agreement you may have executed
136 |       with Licensor regarding such Contributions.
137 | 
138 |    6. Trademarks. This License does not grant permission to use the trade
139 |       names, trademarks, service marks, or product names of the Licensor,
140 |       except as required for reasonable and customary use in describing the
141 |       origin of the Work and reproducing the content of the NOTICE file.
142 | 
143 |    7. Disclaimer of Warranty. Unless required by applicable law or
144 |       agreed to in writing, Licensor provides the Work (and each
145 |       Contributor provides its Contributions) on an "AS IS" BASIS,
146 |       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147 |       implied, including, without limitation, any warranties or conditions
148 |       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149 |       PARTICULAR PURPOSE. You are solely responsible for determining the
150 |       appropriateness of using or redistributing the Work and assume any
151 |       risks associated with Your exercise of permissions under this License.
152 | 
153 |    8. Limitation of Liability. In no event and under no legal theory,
154 |       whether in tort (including negligence), contract, or otherwise,
155 |       unless required by applicable law (such as deliberate and grossly
156 |       negligent acts) or agreed to in writing, shall any Contributor be
157 |       liable to You for damages, including any direct, indirect, special,
158 |       incidental, or consequential damages of any character arising as a
159 |       result of this License or out of the use or inability to use the
160 |       Work (including but not limited to damages for loss of goodwill,
161 |       work stoppage, computer failure or malfunction, or any and all
162 |       other commercial damages or losses), even if such Contributor
163 |       has been advised of the possibility of such damages.
164 | 
165 |    9. Accepting Warranty or Additional Liability. While redistributing
166 |       the Work or Derivative Works thereof, You may choose to offer,
167 |       and charge a fee for, acceptance of support, warranty, indemnity,
168 |       or other liability obligations and/or rights consistent with this
169 |       License. However, in accepting such obligations, You may act only
170 |       on Your own behalf and on Your sole responsibility, not on behalf
171 |       of any other Contributor, and only if You agree to indemnify,
172 |       defend, and hold each Contributor harmless for any liability
173 |       incurred by, or claims asserted against, such Contributor by reason
174 |       of your accepting any such warranty or additional liability.
175 | 
176 |    END OF TERMS AND CONDITIONS
177 | 
178 |    APPENDIX: How to apply the Apache License to your work.
179 | 
180 |       To apply the Apache License to your work, attach the following
181 |       boilerplate notice, with the fields enclosed by brackets "[]"
182 |       replaced with your own identifying information. (Don't include
183 |       the brackets!)  The text should be enclosed in the appropriate
184 |       comment syntax for the file format. We also recommend that a
185 |       file or class name and description of purpose be included on the
186 |       same "printed page" as the copyright notice for easier
187 |       identification within third-party archives.
188 | 
189 |    Copyright [yyyy] [name of copyright owner]
190 | 
191 |    Licensed under the Apache License, Version 2.0 (the "License");
192 |    you may not use this file except in compliance with the License.
193 |    You may obtain a copy of the License at
194 | 
195 |        http://www.apache.org/licenses/LICENSE-2.0
196 | 
197 |    Unless required by applicable law or agreed to in writing, software
198 |    distributed under the License is distributed on an "AS IS" BASIS,
199 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
200 |    See the License for the specific language governing permissions and
201 |    limitations under the License.
202 | 


--------------------------------------------------------------------------------
/src/format_spec.rs:
--------------------------------------------------------------------------------
  1 | use crate::error::Error;
  2 | use std::fmt::{Debug, Display};
  3 | 
  4 | macro_rules! parse {
  5 |     ($($arg:tt)*) => {
  6 |         return Err($crate::error::Error::new_parse(format!($($arg)*)))
  7 |     };
  8 | }
  9 | 
 10 | macro_rules! ufs {
 11 |     ($($arg:tt)*) => {
 12 |         return Err($crate::error::Error::new_ufs(format!($($arg)*)))
 13 |     };
 14 | }
 15 | 
 16 | #[derive(Debug, Default, Clone)]
 17 | pub struct FormatSpec {
 18 |     align: Option<(Option<String>, String)>,
 19 |     sign: Option<String>,
 20 |     hashtag: bool,
 21 |     zero: bool,
 22 |     width: Option<usize>,
 23 |     precision: Option<usize>,
 24 |     types: Option<String>,
 25 | }
 26 | 
 27 | impl FormatSpec {
 28 |     pub(crate) fn new(placeholder: &str) -> Result<Self, Error> {
 29 |         if placeholder.rfind(':').is_some() {
 30 |             let spec = placeholder.split(':').last().unwrap().to_owned();
 31 |             Self::validate(spec.clone(), placeholder)?;
 32 |             return Ok(Self::parse(spec));
 33 |         }
 34 | 
 35 |         Ok(Self::default())
 36 |     }
 37 | 
 38 |     fn validate(mut spec: String, placeholder: &str) -> Result<(), Error> {
 39 |         let mut align_index = match (spec.find('<'), spec.find('^'), spec.find('>')) {
 40 |             (None, None, None) => None,
 41 |             (Some(left), None, None) => Some(left),
 42 |             (None, Some(center), None) => Some(center),
 43 |             (None, None, Some(right)) => Some(right),
 44 |             _ => parse!("multiple align specifiers used in {{{}}}", placeholder),
 45 |         };
 46 | 
 47 |         if let Some(x) = align_index {
 48 |             if x == 1 {
 49 |                 spec.replace_range((x - 1)..x, "");
 50 |                 align_index = Some(0);
 51 |             }
 52 |         }
 53 | 
 54 |         let sign_index = match (spec.find('+'), spec.find('-')) {
 55 |             (None, None) => None,
 56 |             (Some(positive), None) => Some(positive),
 57 |             (None, Some(negative)) => Some(negative),
 58 |             _ => parse!("multiple signs used in {{{}}}", placeholder),
 59 |         };
 60 | 
 61 |         let hashtag_index = spec.find('#');
 62 |         let mut zero_index = spec.find('0');
 63 |         let precision_index = spec.find('.');
 64 | 
 65 |         if let Some(x) = zero_index {
 66 |             if let Some(y) = precision_index {
 67 |                 if x > y {
 68 |                     zero_index = None;
 69 |                 }
 70 |             }
 71 |         }
 72 | 
 73 |         let question_index = spec.find('?');
 74 | 
 75 |         if let Some(x) = align_index {
 76 |             for (spec_name, spec_index) in [
 77 |                 ("sign", sign_index),
 78 |                 ("#", hashtag_index),
 79 |                 ("0 padding and width", zero_index),
 80 |                 ("precision", precision_index),
 81 |                 ("?", question_index),
 82 |             ]
 83 |             .iter()
 84 |             {
 85 |                 if let Some(spec_index) = spec_index {
 86 |                     if x > *spec_index {
 87 |                         parse!(
 88 |                             "align should be used before {} in {{{}}}",
 89 |                             spec_name,
 90 |                             placeholder
 91 |                         );
 92 |                     }
 93 |                 }
 94 |             }
 95 |         }
 96 | 
 97 |         if let Some(x) = sign_index {
 98 |             for (spec_name, spec_index) in [
 99 |                 ("#", hashtag_index),
100 |                 ("0 padding and width", zero_index),
101 |                 ("precision", precision_index),
102 |                 ("?", question_index),
103 |             ]
104 |             .iter()
105 |             {
106 |                 if let Some(spec_index) = spec_index {
107 |                     if x > *spec_index {
108 |                         parse!(
109 |                             "sign should be used before {} in {{{}}}",
110 |                             spec_name,
111 |                             placeholder
112 |                         );
113 |                     }
114 |                 }
115 |             }
116 |         }
117 | 
118 |         if let Some(x) = hashtag_index {
119 |             for (spec_name, spec_index) in [
120 |                 ("0 padding and width", zero_index),
121 |                 ("precision", precision_index),
122 |                 ("?", question_index),
123 |             ]
124 |             .iter()
125 |             {
126 |                 if let Some(spec_index) = spec_index {
127 |                     if x > *spec_index {
128 |                         parse!(
129 |                             "# should be used before {} in {{{}}}",
130 |                             spec_name,
131 |                             placeholder
132 |                         );
133 |                     }
134 |                 }
135 |             }
136 |         }
137 | 
138 |         if let Some(x) = zero_index {
139 |             for (spec_name, spec_index) in
140 |                 [("precision", precision_index), ("?", question_index)].iter()
141 |             {
142 |                 if let Some(spec_index) = spec_index {
143 |                     if x > *spec_index {
144 |                         parse!(
145 |                             "0 should be used before {} in {{{}}}",
146 |                             spec_name,
147 |                             placeholder
148 |                         );
149 |                     }
150 |                 }
151 |             }
152 |         }
153 | 
154 |         if let Some(x) = precision_index {
155 |             for (spec_name, spec_index) in [("?", question_index)].iter() {
156 |                 if let Some(spec_index) = spec_index {
157 |                     if x > *spec_index {
158 |                         parse!(
159 |                             "precision should be used before {} in {{{}}}",
160 |                             spec_name,
161 |                             placeholder
162 |                         );
163 |                     }
164 |                 }
165 |             }
166 | 
167 |             if let Some(y) = spec.get((x + 1)..(x + 2)) {
168 |                 if y.parse::<usize>().is_err() {
169 |                     parse!(
170 |                         "precision value is not a valid usize in {{{}}}",
171 |                         placeholder
172 |                     );
173 |                 }
174 |             } else {
175 |                 parse!("precision value not supplied in {{{}}}", placeholder);
176 |             }
177 |         }
178 | 
179 |         // UNSUPPORTED FORMAT SPECS
180 | 
181 |         if spec.contains('$') {
182 |             ufs!(
183 |                 "parameter setting through $ sign argument is not supported but used in {{{}}}",
184 |                 placeholder
185 |             );
186 |         }
187 | 
188 |         if spec.contains(".*") {
189 |             ufs!(
190 |                 "asterisk .* formatting is not supported but used in {{{}}}",
191 |                 placeholder
192 |             );
193 |         }
194 | 
195 |         if spec.contains('o') {
196 |             ufs!(
197 |                 "o formatting is not supported but used in {{{}}}",
198 |                 placeholder
199 |             );
200 |         }
201 | 
202 |         if spec.contains('x') {
203 |             ufs!(
204 |                 "x formatting is not supported but used in {{{}}}",
205 |                 placeholder
206 |             );
207 |         }
208 | 
209 |         if spec.contains('X') {
210 |             ufs!(
211 |                 "X formatting is not supported but used in {{{}}}",
212 |                 placeholder
213 |             );
214 |         }
215 | 
216 |         if spec.contains('p') {
217 |             ufs!(
218 |                 "p formatting is not supported but used in {{{}}}",
219 |                 placeholder
220 |             );
221 |         }
222 | 
223 |         if spec.contains('b') {
224 |             ufs!(
225 |                 "b formatting is not supported but used in {{{}}}",
226 |                 placeholder
227 |             );
228 |         }
229 | 
230 |         if spec.contains('e') {
231 |             ufs!(
232 |                 "e formatting is not supported but used in {{{}}}",
233 |                 placeholder
234 |             );
235 |         }
236 | 
237 |         if spec.contains('E') {
238 |             ufs!(
239 |                 "E formatting is not supported but used in {{{}}}",
240 |                 placeholder
241 |             );
242 |         }
243 | 
244 |         Ok(())
245 |     }
246 | 
247 |     fn parse(mut spec: String) -> Self {
248 |         let spec_copy = spec.clone();
249 |         let align = if let Some(align) = spec_copy.get(0..1) {
250 |             if align == "<" || align == "^" || align == ">" {
251 |                 spec.replace_range(0..1, "");
252 |                 Some((None, align.to_owned()))
253 |             } else if let Some(align) = spec_copy.get(1..2) {
254 |                 if align == "<" || align == "^" || align == ">" {
255 |                     spec.replace_range(0..2, "");
256 |                     Some((
257 |                         Some(spec_copy.get(0..1).unwrap().to_owned()),
258 |                         align.to_owned(),
259 |                     ))
260 |                 } else {
261 |                     None
262 |                 }
263 |             } else {
264 |                 None
265 |             }
266 |         } else {
267 |             None
268 |         };
269 | 
270 |         let spec_copy = spec.clone();
271 |         let sign = if let Some(sign) = spec_copy.get(0..1) {
272 |             if sign == "+" || sign == "-" {
273 |                 spec.replace_range(0..1, "");
274 |                 Some(sign.to_owned())
275 |             } else {
276 |                 None
277 |             }
278 |         } else {
279 |             None
280 |         };
281 | 
282 |         let hashtag = if let Some(hastag) = spec.get(0..1) {
283 |             if hastag == "#" {
284 |                 spec.replace_range(0..1, "");
285 |                 true
286 |             } else {
287 |                 false
288 |             }
289 |         } else {
290 |             false
291 |         };
292 | 
293 |         let zero = if let Some(zero) = spec.get(0..1) {
294 |             if zero == "0" {
295 |                 spec.replace_range(0..1, "");
296 |                 true
297 |             } else {
298 |                 false
299 |             }
300 |         } else {
301 |             false
302 |         };
303 | 
304 |         let width = crate::utils::usize_token(&spec, 0);
305 | 
306 |         if let Some(x) = width {
307 |             spec = spec.trim_start_matches(&x.to_string()).to_owned();
308 |         }
309 | 
310 |         let precision = if let Some(point) = spec.get(0..1) {
311 |             if point == "." {
312 |                 crate::utils::usize_token(&spec, 1)
313 |             } else {
314 |                 None
315 |             }
316 |         } else {
317 |             None
318 |         };
319 | 
320 |         if let Some(x) = precision {
321 |             spec = spec.trim_start_matches(&format!(".{}", x)).to_owned();
322 |         }
323 | 
324 |         let types = if spec.is_empty() {
325 |             None
326 |         } else {
327 |             Some(spec.split(' ').next().unwrap().to_owned())
328 |         };
329 | 
330 |         Self {
331 |             align,
332 |             sign,
333 |             hashtag,
334 |             zero,
335 |             width,
336 |             precision,
337 |             types,
338 |         }
339 |     }
340 | 
341 |     pub fn format<T: Display + Debug>(&self, value: T) -> String {
342 |         let mut fmtval = format!("{}", value);
343 | 
344 |         if let Some(precision) = self.precision {
345 |             if self.zero && self.hashtag {
346 |                 fmtval = format!("{:#0.1$}", value, precision);
347 |             } else if self.hashtag {
348 |                 fmtval = format!("{:#.1$}", value, precision);
349 |             } else {
350 |                 fmtval = format!("{:.1$}", value, precision);
351 |             }
352 |         }
353 | 
354 |         if let Some(types) = &self.types {
355 |             if self.hashtag {
356 |                 if types == "?" {
357 |                     return format!("{:#?}", value);
358 |                 } else if types == "x?" {
359 |                     return format!("{:#x?}", value);
360 |                 } else if types == "X?" {
361 |                     return format!("{:#X?}", value);
362 |                 }
363 |             } else if types == "?" {
364 |                 return format!("{:?}", value);
365 |             } else if types == "x?" {
366 |                 return format!("{:x?}", value);
367 |             } else if types == "X?" {
368 |                 return format!("{:X?}", value);
369 |             }
370 |         }
371 | 
372 |         if let Some(sign) = &self.sign {
373 |             if sign == "+" && !self.zero && crate::utils::is_number_and_positive(&fmtval) {
374 |                 fmtval = "+".to_owned() + &fmtval;
375 |             }
376 |         }
377 | 
378 |         match &self.align {
379 |             Some((Some(fill), align)) => {
380 |                 fmtval = fmtval.trim().to_owned();
381 |                 let chars_count = fmtval.chars().count();
382 |                 let width = self.width.unwrap_or(0);
383 | 
384 |                 if width > chars_count {
385 |                     if align == "<" {
386 |                         fmtval = fmtval + &fill.repeat(width - chars_count);
387 |                     } else if align == "^" {
388 |                         let factor = usize::from(chars_count % 2 != 0);
389 |                         let start = fill.repeat((width - chars_count - factor) / 2);
390 |                         let end = fill.repeat((width - chars_count + factor) / 2);
391 |                         fmtval = start + &fmtval + &end;
392 |                     } else if align == ">" {
393 |                         fmtval = fill.repeat(width - chars_count) + &fmtval;
394 |                     }
395 |                 }
396 |             }
397 |             Some((None, align)) => {
398 |                 if align == "<" {
399 |                     fmtval = format!("{:<1$}", fmtval, self.width.unwrap_or(0));
400 |                 } else if align == "^" {
401 |                     fmtval = format!("{:^1$}", fmtval, self.width.unwrap_or(0));
402 |                 } else if align == ">" {
403 |                     fmtval = format!("{:>1$}", fmtval, self.width.unwrap_or(0));
404 |                 }
405 |             }
406 |             None => (),
407 |         }
408 | 
409 |         if let Some(width) = self.width {
410 |             if crate::utils::is_number(&fmtval) {
411 |                 let chars_count = fmtval.chars().count();
412 | 
413 |                 if self.zero && width > chars_count {
414 |                     if let Some(sign) = &self.sign {
415 |                         if sign == "+" {
416 |                             if crate::utils::is_number_and_positive(&fmtval) {
417 |                                 fmtval =
418 |                                     "+".to_owned() + &"0".repeat(width - chars_count - 1) + &fmtval;
419 |                             } else {
420 |                                 fmtval = "-".to_owned()
421 |                                     + &"0".repeat(width - chars_count)
422 |                                     + &fmtval[1..];
423 |                             }
424 |                         } else if sign == "-" {
425 |                             fmtval =
426 |                                 "-".to_owned() + &"0".repeat(width - chars_count) + &fmtval[1..];
427 |                         }
428 |                     } else if fmtval.starts_with('-') {
429 |                         fmtval = "-".to_owned() + &"0".repeat(width - chars_count) + &fmtval[1..];
430 |                     } else {
431 |                         fmtval = "0".repeat(width - chars_count) + &fmtval;
432 |                     }
433 |                 } else if width > chars_count {
434 |                     fmtval = " ".repeat(width - chars_count) + &fmtval;
435 |                 }
436 |             } else if self.zero && self.hashtag {
437 |                 fmtval = format!("{:#01$}", fmtval, width);
438 |             } else if self.zero {
439 |                 fmtval = format!("{:01$}", fmtval, width);
440 |             } else if self.hashtag {
441 |                 fmtval = format!("{:#1$}", fmtval, width);
442 |             } else {
443 |                 fmtval = format!("{:1$}", fmtval, width);
444 |             }
445 |         }
446 | 
447 |         fmtval
448 |     }
449 | }
450 | 


--------------------------------------------------------------------------------