dyn
dynfmt
cargo install dynfmt
dyn

dynfmt

A Rust crate for formatting strings dynamically

by Jan Michael Auer

0.1.4 (see all)License:MIT
cargo install dynfmt
Readme

dynfmt - Dynamic Formatting in Rust

A crate for formatting strings dynamically.

dynfmt provides several implementations for formats that implement a subset of the std::fmt facilities. Parsing of the format string and arguments checks are performed at runtime. There is also the option to implement new formats.

The public API is exposed via the Format trait, which contains formatting helper functions and lower-level utilities to interface with format strings. See the Features section for a list of provided implementations.

Usage

use dynfmt::{Format, NoopFormat};

let formatted = NoopFormat.format("hello, world", &["unused"]);
assert_eq!("hello, world", formatted.expect("formatting failed"));

See the Format trait for more methods.

Features

This crate ships with a set of features that either activate formatting capabilities or new format implementations:

  • json (default): Implements the serialization of complex structures via JSON. Certain formats, such as Python, also have a representation format (%r) that makes use of this feature, if enabled. Without this feature, such values will cause an error.
  • python: Implements the printf-like format that python 2 used for formatting strings. See PythonFormat for more information.
  • curly: A simple format string syntax using curly braces for arguments. Similar to .NET and Rust, but much less capable. See SimpleCurlyFormat for mor information.

Extensibility

Implement the Format trait to create a new format. The only required method is iter_args, which must return an iterator over ArgumentSpec structs. Based on the capabilities of the format, the specs can be parameterized with formatting parameters.

use std::str::MatchIndices;
use dynfmt::{ArgumentSpec, Format, Error};

struct HashFormat;

impl<'f> Format<'f> for HashFormat {
    type Iter = HashIter<'f>;

    fn iter_args(&self, format: &'f str) -> Result<Self::Iter, Error<'f>> {
        Ok(HashIter(format.match_indices('#')))
    }
}

struct HashIter<'f>(MatchIndices<'f, char>);

impl<'f> Iterator for HashIter<'f> {
    type Item = Result<ArgumentSpec<'f>, Error<'f>>;

    fn next(&mut self) -> Option<Self::Item> {
        self.0.next().map(|(index, _)| Ok(ArgumentSpec::new(index, index + 1)))
    }
}

let formatted = HashFormat.format("hello, #", &["world"]);
assert_eq!("hello, world", formatted.expect("formatting failed"));

License: MIT

GitHub Stars

14

LAST COMMIT

1yr ago

MAINTAINERS

1

CONTRIBUTORS

4

OPEN ISSUES

2

OPEN PRs

1
VersionTagPublished
0.1.4
2yrs ago
0.1.3
2yrs ago
0.1.2
3yrs ago
0.1.1
3yrs ago
No alternatives found
No tutorials found
Add a tutorial