pleshevskiy/estring
Archived
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Compare commits

base: pleshevskiy:main
Branches Tags
pleshevskiy:main
pleshevskiy:product_agg
pleshevskiy:sum_agg
pleshevskiy:to_estring
pleshevskiy:parse-trait
pleshevskiy:restructure
pleshevskiy:low-level-trim
pleshevskiy:v0.3.0
pleshevskiy:v0.2.0
pleshevskiy:v0.1.2
..
compare: pleshevskiy:restructure
Branches Tags
pleshevskiy:main
pleshevskiy:product_agg
pleshevskiy:sum_agg
pleshevskiy:to_estring
pleshevskiy:parse-trait
pleshevskiy:restructure
pleshevskiy:low-level-trim
pleshevskiy:v0.3.0
pleshevskiy:v0.2.0
pleshevskiy:v0.1.2

2 commits
main ... restructur

Author SHA1 Message Date
Dmitriy Pleshevskiy
a8c8b5b3db
chore: reimport mods 2022-07-25 22:54:57 +03:00
Dmitriy Pleshevskiy
0124b34486
refac: restructure modules 
Closes #20
 2022-07-25 22:49:58 +03:00
20 changed files with 150 additions and 1009 deletions
Show stats Expand all files Collapse all files

5
Cargo.lock generated
View file

@ -1,7 +1,6 @@
# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
version = 3
[[package]]
name = "estring"
version = "0.3.0"
version = "0.1.2"

4
Cargo.toml
View file

@ -1,7 +1,7 @@
[package]
name = "estring"
description = "A simple way to parse a string using type annotations"
version = "0.3.0"
version = "0.1.2"
edition = "2021"
authors = ["Dmitriy Pleshevskiy <dmitriy@ideascup.me>"]
readme = "README.md"
@ -28,7 +28,7 @@ maintenance = { status = "actively-developed" }
[[example]]
name = "calc"
required-features = ["structs", "aggs"]
required-features = ["structs"]
[[example]]
name = "dotenv"

76
README.md
View file

@ -1,45 +1,19 @@
# EString
[![Crates.io](https://img.shields.io/crates/v/estring?style=flat-square)](https://crates.io/crates/estring)
[![docs.rs](https://img.shields.io/docsrs/estring?style=flat-square)](https://docs.rs/estring)
[![GitHub Workflow Status](https://img.shields.io/github/workflow/status/pleshevskiy/estring/CI?label=tests&logo=github&style=flat-square)](https://github.com/pleshevskiy/estring/actions/workflows/ci.yml)
![The MSRV](https://img.shields.io/badge/MSRV-1.59.0-red.svg)
```toml
[dependencies]
estring = "0.3"
```
[![docs.rs](https://img.shields.io/docsrs/estring?style=flat-square)](https://docs.rs/estring)
[![Crates.io](https://img.shields.io/crates/v/estring?style=flat-square)](https://crates.io/crates/estring)
[![Crates.io](https://img.shields.io/crates/l/estring?style=flat-square)](https://github.com/pleshevskiy/estring/LICENSE)
[![unsafe forbidden](https://img.shields.io/badge/unsafe-forbidden-success.svg?style=flat-square)](https://github.com/rust-secure-code/safety-dance/)
[![Matrix](https://img.shields.io/matrix/enve_team:matrix.org?label=matrix&style=flat-square)](https://matrix.to/#/!yZalHbWfGRWOMaetSn:matrix.org?via=matrix.org)
A simple way to parse a string using type annotations.
This package was originally designed for [enve].
This package was originally designed for [enve]
[enve]: https://github.com/pleshevskiy/enve
## [Documentation](https://docs.rs/estring)
For more details, see [examples].
[examples]: https://github.com/pleshevskiy/estring/tree/main/examples
## Usage
Basic
```rust
use estring::EString;
fn main() -> estring::Result<()> {
let res: i32 = EString::from("10").parse()?;
assert_eq!(res, 10);
Ok(())
}
```
You can use predefined structs like `SepVec` if you enable the `structs`
feature.
Note: You can use custom types as annotations! Just implement `ParseFragment`!
## Getting started
```rust
use estring::{SepVec, EString};
@ -47,7 +21,7 @@ use estring::{SepVec, EString};
type PlusVec<T> = SepVec<T, '+'>;
type MulVec<T> = SepVec<T, '*'>;
fn main() -> estring::Result<()> {
fn main() -> Result<(), estring::ParseError> {
let res = EString::from("10+5*2+3")
.parse::<PlusVec<MulVec<f32>>>()?
.iter()
@ -59,30 +33,28 @@ fn main() -> estring::Result<()> {
}
```
You can also use predefined aggregators if you enable the `aggs` feature.
You can use custom types as annotations! Just implement `TryFrom<EString>`!
```rust
use estring::{Aggregate, EString, Product, SepVec, Sum};
## Installation
type PlusVec<T> = SepVec<T, '+'>;
type MulVec<T> = SepVec<T, '*'>;
**The MSRV is 1.59.0**
fn main() -> estring::Result<()> {
let res = EString::from("10+5*2+3")
.parse::<Sum<PlusVec<Product<MulVec<f32>>>>>()?
.agg();
Add `estring = { version = "0.1", features = ["vec", "number"] }` as a
dependency in `Cargo.toml`.
assert_eq!(res, 23.0);
Ok(())
}
`Cargo.toml` example:
```toml
[package]
name = "my-crate"
version = "0.1.0"
edition = "2021"
authors = ["Me <user@rust-lang.org>"]
[dependencies]
estring = { version = "0.1", features = ["vec", "number"] }
```
## Contact Us
Join us in:
[![Matrix](https://img.shields.io/badge/matrix-%23enve_team:matrix.org-blueviolet.svg?style=flat-square)](https://matrix.to/#/#enve_team:matrix.org)
## License
**MIT**. See [LICENSE](https://github.com/pleshevskiy/estring/LICENSE) to see

10
examples/calc.rs
View file

@ -1,12 +1,14 @@
use estring::{Aggregate, EString, Product, SepVec, Sum};
use estring::{EString, SepVec};
type PlusVec<T> = SepVec<T, '+'>;
type MulVec<T> = SepVec<T, '*'>;
fn main() -> estring::Result<()> {
fn main() -> Result<(), estring::ParseError> {
let res = EString::from("10+5*2+3")
.parse::<Sum<PlusVec<Product<MulVec<f32>>>>>()?
.agg();
.parse::<PlusVec<MulVec<f32>>>()?
.iter()
.map(|m| m.iter().product::<f32>())
.sum::<f32>();
assert_eq!(res, 23.0);
Ok(())

2
examples/dotenv.rs
View file

@ -5,7 +5,7 @@ DATABASE_URL=postgres://user:password@localhost:5432/recipes
APP_HOST=http://localhost:3000
";
fn main() -> estring::Result<()> {
fn main() -> Result<(), estring::ParseError> {
EString::from(DOTENV_CONTENT)
.parse::<Trim<SepVec<Pair<&str, '=', &str>, '\n'>>>()?
.iter()

6
src/agg.rs
View file

@ -1,8 +1,2 @@
//! This module will contain aggregate functions (Sum, Product, etc)
//!
mod product;
mod sum;
pub use product::*;
pub use sum::*;

92
src/agg/product.rs
View file

@ -1,92 +0,0 @@
use crate::{Aggregatable, Aggregate, EString, ParseFragment};
/// Aggregate struct, that can multiply inner aggregatable [items](Aggregatable::items) if
/// [``Aggregatable::Item``] implements [``std::iter::Product``](std::iter::Product)
///
/// # Examples
///
/// ```rust
/// use estring::{Aggregate, EString, SepVec, Product};
/// let res = EString::from("1*2*3*4")
/// .parse::<Product<SepVec<i32, '*'>>>()
/// .unwrap()
/// .agg();
/// assert_eq!(res, 24);
/// ```
#[derive(Debug, PartialEq, Eq)]
pub struct Product<T>(pub T);
impl<T> ParseFragment for Product<T>
where
T: ParseFragment,
{
fn parse_frag(es: EString) -> crate::Result<Self> {
T::parse_frag(es).map(Self)
}
}
impl<R, T> Aggregate for Product<T>
where
R: std::iter::Product,
T: Aggregatable<Item = R>,
{
type Target = R;
fn agg(self) -> Self::Target {
self.0.items().into_iter().product()
}
}
impl<R, T> Aggregatable for Product<T>
where
R: std::iter::Product,
T: Aggregatable<Item = R>,
{
type Item = R;
fn items(self) -> Vec<Self::Item> {
vec![self.agg()]
}
}
#[cfg(test)]
mod tests {
use crate::SepVec;
use super::*;
type CommaVec<T> = SepVec<T, ','>;
type MulVec<T> = SepVec<T, '*'>;
#[test]
fn should_parse_vec() {
let es = EString::from("1,2,3");
match es.parse::<Product<CommaVec<i32>>>() {
Ok(res) => assert_eq!(res, Product(CommaVec::from(vec![1, 2, 3]))),
_ => unreachable!(),
}
}
#[test]
fn should_aggregate_vector() {
let es = EString::from("1,2,3");
let expr = es.parse::<Product<CommaVec<i32>>>().unwrap();
assert_eq!(expr.agg(), 6);
}
#[test]
fn should_aggregate_vector_with_inner_vector() {
let es = EString::from("1*2,2,3");
let expr = es.parse::<Product<CommaVec<MulVec<i32>>>>().unwrap();
assert_eq!(expr.agg(), 12);
}
#[test]
fn should_aggregate_vector_with_inner_aggregation() {
let es = EString::from("1*2,2,3");
let expr = es
.parse::<Product<CommaVec<Product<MulVec<i32>>>>>()
.unwrap();
assert_eq!(expr.agg(), 12);
}
}

90
src/agg/sum.rs
View file

@ -1,90 +0,0 @@
use crate::{Aggregatable, Aggregate, EString, ParseFragment};
/// Aggregate struct, that can sum inner aggregatable [items](Aggregatable::items) if
/// [``Aggregatable::Item``] implements [``std::iter::Sum``](std::iter::Sum)
///
/// # Examples
///
/// ```rust
/// use estring::{Aggregate, EString, SepVec, Sum};
/// let res = EString::from("1+2+3+4")
/// .parse::<Sum<SepVec<i32, '+'>>>()
/// .unwrap()
/// .agg();
/// assert_eq!(res, 10);
/// ```
#[derive(Debug, PartialEq, Eq)]
pub struct Sum<T>(pub T);
impl<T> ParseFragment for Sum<T>
where
T: ParseFragment,
{
fn parse_frag(es: EString) -> crate::Result<Self> {
T::parse_frag(es).map(Self)
}
}
impl<R, T> Aggregate for Sum<T>
where
R: std::iter::Sum,
T: Aggregatable<Item = R>,
{
type Target = R;
fn agg(self) -> Self::Target {
self.0.items().into_iter().sum()
}
}
impl<R, T> Aggregatable for Sum<T>
where
R: std::iter::Sum,
T: Aggregatable<Item = R>,
{
type Item = R;
fn items(self) -> Vec<Self::Item> {
vec![self.agg()]
}
}
#[cfg(test)]
mod tests {
use crate::SepVec;
use super::*;
type CommaVec<T> = SepVec<T, ','>;
type PlusVec<T> = SepVec<T, '+'>;
#[test]
fn should_parse_vec() {
let es = EString::from("1,2,3");
match es.parse::<Sum<CommaVec<i32>>>() {
Ok(res) => assert_eq!(res, Sum(CommaVec::from(vec![1, 2, 3]))),
_ => unreachable!(),
}
}
#[test]
fn should_aggregate_vector() {
let es = EString::from("1,2,3");
let expr = es.parse::<Sum<CommaVec<i32>>>().unwrap();
assert_eq!(expr.agg(), 6);
}
#[test]
fn should_aggregate_vector_with_inner_vector() {
let es = EString::from("1+2,2,3");
let expr = es.parse::<Sum<CommaVec<PlusVec<i32>>>>().unwrap();
assert_eq!(expr.agg(), 8);
}
#[test]
fn should_aggregate_vector_with_inner_aggregation() {
let es = EString::from("1+2,2,3");
let expr = es.parse::<Sum<CommaVec<Sum<PlusVec<i32>>>>>().unwrap();
assert_eq!(expr.agg(), 8);
}
}

276
src/core.rs
View file

@ -2,225 +2,34 @@
//! string types
//!
/// Format this type and wrap into ``EString``.
///
/// ``ToEString``’s `to_estring` method is often used implicitly, through ``EString``’s from.
///
/// # Examples
///
/// Basic implementation of ``ToEString`` on an example ``Point``.
///
/// ```rust
/// use std::fmt::Write;
/// use estring::{EString, ToEString};
///
/// #[derive(Debug, PartialEq)]
/// struct Point {
/// x: i32,
/// y: i32,
/// }
///
/// impl ToEString for Point {
/// fn to_estring(&self) -> EString {
/// let mut res = String::new();
/// write!(res, "({},{})", self.x, self.y)
/// .ok()
/// .expect("Cannot format Point into EString");
/// EString(res)
/// }
/// }
///
/// let point = Point { x: 1, y: 2 };
/// assert_eq!(point.to_estring(), EString::from("(1,2)"));
/// ```
///
pub trait ToEString {
/// Format this type and returns ``EString``.
///
/// # Examples
///
/// ```rust
/// use estring::{EString, ToEString};
///
/// let i = 5;
/// let five = EString::from(5);
/// assert_eq!(five, i.to_estring());
/// ```
fn to_estring(&self) -> EString;
}
use crate::ParseError;
use std::convert::Infallible;
/// Parse a value fragment from a ``EString``.
///
/// ``ParseFragment``’s `parse_frag` method is often used implicitly, through ``EString``’s parse.
/// See [parse](EString::parse)’s documentation for examples.
///
/// # Examples
///
/// Basic implementation of ``ParseFragment`` on an example ``Point``.
///
/// ```rust
/// use estring::{EString, ParseFragment, Reason};
///
/// #[derive(Debug, PartialEq)]
/// struct Point {
/// x: i32,
/// y: i32,
/// }
///
/// impl ParseFragment for Point {
/// fn parse_frag(es: EString) -> estring::Result<Self> {
/// let orig = es.clone();
/// let (x, y) = es
/// .trim_matches(|p| p == '(' || p == ')')
/// .split_once(',')
/// .ok_or(estring::Error(orig, Reason::Split))?;
///
/// let (x, y) = (EString::from(x), EString::from(y));
/// let x = x.clone().parse::<i32>()
/// .map_err(|_| estring::Error(x, Reason::Parse))?;
/// let y = y.clone().parse::<i32>()
/// .map_err(|_| estring::Error(y, Reason::Parse))?;
///
/// Ok(Point { x, y })
/// }
/// }
///
/// let fragment = EString::from("(1,2)");
/// let res = Point::parse_frag(fragment).unwrap();
/// assert_eq!(res, Point { x: 1, y: 2 })
/// ```
///
pub trait ParseFragment: Sized {
/// Parses a ``EString`` fragment `es` to return a value of this type.
///
/// # Errors
///
/// If parsing is not succeeds, returns ``Error`` inside ``Err`` with original fragment `es`
/// and reason ``Reason``.
///
/// # Examples
///
/// ```rust
/// use estring::{EString, ParseFragment};
///
/// let fragment = EString::from("5");
/// let res = i32::parse_frag(fragment).unwrap();
/// assert_eq!(res, 5);
/// ```
fn parse_frag(es: EString) -> crate::Result<Self>;
}
// TODO: add example
/// Trait to represent structures that can act as aggregators.
///
/// The `agg` method works with data that has already been parsed. For this reason, **this trait
/// should never fail**.
pub trait Aggregate {
/// The resulting type after aggregation.
type Target: ?Sized;
/// Aggregates the value.
fn agg(self) -> Self::Target;
}
// TODO: add example
/// Trait to represent structures that can iterate values for the aggregator.
pub trait Aggregatable {
/// The type of the elements being iterated over.
type Item;
/// Returns Vec of aggregatable values
fn items(self) -> Vec<Self::Item>;
}
/// Wrapper under ``String`` type.
///
/// # Examples
///
/// You can create a ``EString`` from a any type that implement ``ToEString`` with ``EString::from``
///
/// ```rust
/// # use estring::EString;
/// let hello = EString::from("Hello, world");
/// let num = EString::from("999");
/// ```
///
/// You can use ``ToEString::to_estring`` directly on the type.
///
/// ```rust
/// # use estring::ToEString;
/// let some_opt = Some(999).to_estring();
/// let none_opt = None::<i32>.to_estring();
/// ```
///
/// Wrapper under String type.
#[derive(Debug, Default, PartialEq, Eq, Clone)]
pub struct EString(pub String);
impl std::fmt::Display for EString {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{}", self.0)
}
}
impl EString {
/// Creates a new empty ``EString``.
///
/// This will not allocate any inital buffer.
///
/// # Examples
///
/// Basic usage:
///
/// ```rust
/// # use estring::EString;
/// let s = EString::new();
/// ```
#[must_use]
#[inline]
pub fn new() -> Self {
Self(String::new())
}
/// Parses this inner string into another type.
///
/// `parse` can parse into any type that implements the ``ParseFragment`` trait.
/// Parses inner string by type annotations and returns result.
///
/// # Errors
///
/// Will return `Err` if estring cannot parse inner fragment into the desired type.
/// Will return `Err` if estring cannot parse inner fragment
///
/// # Examples
///
/// Basic usage
///
/// ```rust
/// # use estring::{EString, ParseFragment};
/// let fragment = EString::from("5");
/// let res = i32::parse_frag(fragment);
/// assert_eq!(res, Ok(5));
/// ```
///
/// Failing to parse:
///
/// ```rust
/// # use estring::{EString, ParseFragment, Error, Reason};
/// let fragment = EString::from("j");
/// let res = i32::parse_frag(fragment.clone());
/// assert_eq!(res, Err(Error(fragment, Reason::Parse)));
/// ```
#[inline]
pub fn parse<T: ParseFragment>(self) -> crate::Result<T> {
T::parse_frag(self)
pub fn parse<T: TryFrom<EString>>(self) -> Result<T, ParseError> {
let orig = self.0.clone();
<T as TryFrom<EString>>::try_from(self).map_err(|_| ParseError(orig))
}
}
impl<T> From<T> for EString
where
T: ToEString,
T: std::fmt::Display,
{
#[inline]
fn from(val: T) -> Self {
val.to_estring()
Self(val.to_string())
}
}
@ -233,68 +42,21 @@ impl std::ops::Deref for EString {
}
}
impl ParseFragment for EString {
impl TryFrom<EString> for String {
type Error = Infallible;
#[inline]
fn parse_frag(es: EString) -> crate::Result<Self> {
Ok(es)
fn try_from(s: EString) -> Result<Self, Self::Error> {
Ok(s.0)
}
}
#[cfg(feature = "aggs")]
impl Aggregatable for EString {
type Item = Self;
impl TryFrom<EString> for &'static str {
type Error = Infallible;
#[inline]
fn items(self) -> Vec<Self::Item> {
vec![self]
}
}
impl ParseFragment for String {
#[inline]
fn parse_frag(es: EString) -> crate::Result<Self> {
Ok(es.0)
}
}
impl ToEString for String {
#[inline]
fn to_estring(&self) -> EString {
EString(self.clone())
}
}
#[cfg(feature = "aggs")]
impl Aggregatable for String {
type Item = Self;
#[inline]
fn items(self) -> Vec<Self::Item> {
vec![self]
}
}
impl ParseFragment for &'static str {
#[inline]
fn parse_frag(es: EString) -> crate::Result<Self> {
Ok(Box::leak(es.0.into_boxed_str()))
}
}
impl<'a> ToEString for &'a str {
#[inline]
fn to_estring(&self) -> EString {
EString((*self).to_string())
}
}
#[cfg(feature = "aggs")]
impl<'a> Aggregatable for &'a str {
type Item = Self;
#[inline]
fn items(self) -> Vec<Self::Item> {
vec![self]
fn try_from(s: EString) -> Result<Self, Self::Error> {
Ok(Box::leak(s.0.into_boxed_str()))
}
}

29
src/error.rs
View file

@ -1,31 +1,16 @@
use crate::core::EString;
/// Failed to parse the specified string.
#[derive(Debug)]
pub struct ParseError(pub String);
/// The error type for operations interacting with ``EString``’s fragments.
#[derive(Debug, PartialEq, Eq)]
pub struct Error(pub EString, pub Reason);
/// The reason for the failure to parse.
#[derive(Debug, PartialEq, Eq)]
pub enum Reason {
/// Cannot split fragment
Split,
/// Cannot parse fragment
Parse,
}
impl std::fmt::Display for Error {
impl std::fmt::Display for ParseError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(
f,
r#"Failed to parse "{:?}" with reason {:?}"#,
self.0, self.1
)
write!(f, r#"Failed to parse: "{}""#, self.0)
}
}
impl std::error::Error for Error {}
impl std::error::Error for ParseError {}
impl std::ops::Deref for Error {
impl std::ops::Deref for ParseError {
type Target = String;
fn deref(&self) -> &Self::Target {

82
src/lib.rs
View file

@ -7,23 +7,7 @@
//!
//! [enve]: https://github.com/pleshevskiy/enve
//!
//! ## Usage
//!
//! Basic
//!
//! ```rust
//! use estring::EString;
//!
//! fn main() -> estring::Result<()> {
//! let res: i32 = EString::from("10").parse()?;
//! assert_eq!(res, 10);
//! Ok(())
//! }
//! ```
//!
//! You can use predefined structs like ``SepVec`` if you enable `structs` feature.
//!
//! Note: You can use custom types as annotations! Just implement ``ParseFragment``!
//! ## Getting started
//!
//! ```rust
//! use estring::{SepVec, EString};
@ -31,7 +15,7 @@
//! type PlusVec<T> = SepVec<T, '+'>;
//! type MulVec<T> = SepVec<T, '*'>;
//!
//! fn main() -> estring::Result<()> {
//! fn main() -> Result<(), estring::ParseError> {
//! let res = EString::from("10+5*2+3")
//! .parse::<PlusVec<MulVec<f32>>>()?
//! .iter()
@ -43,72 +27,11 @@
//! }
//! ```
//!
//! You can also use predefined aggregators if you enable `aggs` feature.
//!
//! ```rust
//! use estring::{Aggregate, EString, Product, SepVec, Sum};
//!
//! type PlusVec<T> = SepVec<T, '+'>;
//! type MulVec<T> = SepVec<T, '*'>;
//!
//! fn main() -> estring::Result<()> {
//! let res = EString::from("10+5*2+3")
//! .parse::<Sum<PlusVec<Product<MulVec<f32>>>>>()?
//! .agg();
//!
//! assert_eq!(res, 23.0);
//! Ok(())
//! }
//! ```
//!
//! ---
//!
//! For more details, see [examples].
//!
//! [examples]: https://github.com/pleshevskiy/estring/tree/main/examples
//!
#![deny(clippy::pedantic)]
#![allow(clippy::module_name_repetitions)]
#![warn(missing_docs)]
mod error;
pub use error::{Error, Reason};
/// The type returned by parser methods.
///
/// # Examples
///
/// ```rust
/// use estring::{EString, ParseFragment, Reason};
///
/// #[derive(Debug, PartialEq)]
/// struct Point {
/// x: i32,
/// y: i32,
/// }
///
/// impl ParseFragment for Point {
/// fn parse_frag(es: EString) -> estring::Result<Self> {
/// let orig = es.clone();
/// let (x, y) = es
/// .trim_matches(|p| p == '(' || p == ')')
/// .split_once(',')
/// .ok_or(estring::Error(orig, Reason::Split))?;
///
/// let (x, y) = (EString::from(x), EString::from(y));
/// let x = x.clone().parse::<i32>()
/// .map_err(|_| estring::Error(x, Reason::Parse))?;
/// let y = y.clone().parse::<i32>()
/// .map_err(|_| estring::Error(y, Reason::Parse))?;
///
/// Ok(Point { x, y })
/// }
/// }
///
/// let fragment = EString::from("(1,2)");
/// let res = Point::parse_frag(fragment).unwrap();
/// assert_eq!(res, Point { x: 1, y: 2 })
/// ```
pub type Result<T> = ::std::result::Result<T, Error>;
pub mod core;
pub mod std;
@ -128,3 +51,4 @@ pub mod structs;
pub use structs::*;
pub use crate::core::*;
pub use crate::error::ParseError;

24
src/low/trim.rs
View file

@ -1,4 +1,4 @@
use crate::core::{EString, ParseFragment, ToEString};
use crate::core::EString;
/// Wrapper that allow to trim substring before continue
///
@ -9,7 +9,7 @@ use crate::core::{EString, ParseFragment, ToEString};
/// ```rust
/// use estring::{EString, Trim};
///
/// fn main() -> estring::Result<()> {
/// fn main() -> Result<(), estring::ParseError> {
/// let res = EString::from(" 99 ").parse::<Trim<i32>>()?;
/// assert_eq!(res, Trim(99));
/// Ok(())
@ -33,21 +33,16 @@ impl<T: std::fmt::Display> std::fmt::Display for Trim<T> {
}
}
impl<T> ParseFragment for Trim<T>
impl<T> TryFrom<EString> for Trim<T>
where
T: ParseFragment,
T: TryFrom<EString>,
{
fn parse_frag(value: EString) -> crate::Result<Self> {
T::parse_frag(EString::from(value.trim())).map(Trim)
}
}
type Error = ();
impl<T> ToEString for Trim<T>
where
T: ToEString,
{
fn to_estring(&self) -> EString {
self.0.to_estring()
fn try_from(value: EString) -> Result<Self, Self::Error> {
T::try_from(EString::from(value.trim()))
.map(Trim)
.map_err(|_| ())
}
}
@ -65,6 +60,7 @@ mod tests {
}
}
#[cfg(feature = "number")]
#[test]
fn should_trim_and_convert_to_number() {
let estr = EString::from(" 999 ");

4
src/std.rs
View file

@ -3,4 +3,6 @@
mod bool;
mod number;
mod option;
pub use self::bool::*;
pub use number::*;

40
src/std/bool.rs
View file

@ -1,37 +1,22 @@
use crate::core::{EString, ParseFragment, ToEString};
use crate::error::{Error, Reason};
use crate::core::EString;
impl TryFrom<EString> for bool {
type Error = ();
impl ParseFragment for bool {
#[inline]
fn parse_frag(s: EString) -> crate::Result<Self> {
fn try_from(s: EString) -> Result<Self, Self::Error> {
match s.to_lowercase().as_str() {
"true" | "t" | "yes" | "y" | "on" | "1" => Ok(true),
"false" | "f" | "no" | "n" | "off" | "0" | "" => Ok(false),
_ => Err(Error(s, Reason::Parse)),
_ => Err(()),
}
}
}
impl ToEString for bool {
#[inline]
fn to_estring(&self) -> EString {
EString(self.to_string())
}
}
#[cfg(feature = "aggs")]
impl crate::core::Aggregatable for bool {
type Item = Self;
#[inline]
fn items(self) -> Vec<Self::Item> {
vec![self]
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::ParseError;
#[test]
fn should_parse_bool_variable() {
@ -62,17 +47,10 @@ mod tests {
fn should_throw_parse_error() {
let estr = EString::from("something");
match estr.parse::<bool>() {
Err(crate::Error(orig, reason)) => {
assert_eq!(orig, EString::from("something"));
assert_eq!(reason, crate::Reason::Parse);
Err(ParseError(orig)) => {
assert_eq!(orig, String::from("something"));
}
_ => unreachable!(),
};
}
#[test]
fn should_format_bool() {
assert_eq!(true.to_estring(), EString(String::from("true")));
assert_eq!(false.to_estring(), EString(String::from("false")));
}
}

39
src/std/number.rs
View file

@ -1,31 +1,15 @@
use crate::core::{EString, ParseFragment, ToEString};
use crate::error::{Error, Reason};
use crate::core::EString;
#[doc(hidden)]
macro_rules! from_env_string_numbers_impl {
($($ty:ty),+$(,)?) => {
$(
impl ParseFragment for $ty {
#[inline]
fn parse_frag(s: EString) -> crate::Result<Self> {
s.0.parse::<Self>().map_err(|_| Error(s, Reason::Parse))
}
}
impl ToEString for $ty {
#[inline]
fn to_estring(&self) -> EString {
EString(self.to_string())
}
}
#[cfg(feature = "aggs")]
impl crate::core::Aggregatable for $ty {
type Item = Self;
impl TryFrom<EString> for $ty {
type Error = <$ty as std::str::FromStr>::Err;
#[inline]
fn items(self) -> Vec<Self::Item> {
vec![self]
fn try_from(s: EString) -> Result<Self, Self::Error> {
s.0.parse::<Self>()
}
}
)+
@ -42,6 +26,7 @@ from_env_string_numbers_impl![
#[cfg(test)]
mod tests {
use super::*;
use crate::ParseError;
#[test]
fn should_parse_number() {
@ -66,18 +51,10 @@ mod tests {
fn should_throw_parse_error() {
let estr = EString::from("-10");
match estr.parse::<u32>() {
Err(Error(orig, reason)) => {
assert_eq!(orig, EString::from("-10"));
assert_eq!(reason, Reason::Parse);
Err(ParseError(orig)) => {
assert_eq!(orig, String::from("-10"));
}
_ => unreachable!(),
};
}
#[test]
fn should_format_number() {
assert_eq!((-1).to_estring(), EString(String::from("-1")));
assert_eq!(10.to_estring(), EString(String::from("10")));
assert_eq!(1.1.to_estring(), EString(String::from("1.1")));
}
}

77
src/std/option.rs
View file

@ -1,77 +0,0 @@
use crate::core::{EString, ParseFragment, ToEString};
impl<T> ToEString for Option<T>
where
T: ToEString,
{
fn to_estring(&self) -> EString {
match self {
Some(inner) => inner.to_estring(),
None => EString::new(),
}
}
}
impl<T> ParseFragment for Option<T>
where
T: ParseFragment,
{
fn parse_frag(es: EString) -> crate::Result<Self> {
if es.is_empty() {
Ok(None)
} else {
es.parse().map(Some)
}
}
}
#[cfg(feature = "aggs")]
impl<T> crate::core::Aggregatable for Option<T>
where
T: crate::core::Aggregatable,
{
type Item = T::Item;
fn items(self) -> Vec<Self::Item> {
self.map(T::items).unwrap_or_default()
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::structs::Pair;
#[test]
fn should_parse_empty_string_as_none() {
let estr = EString::new();
match estr.parse::<Option<i32>>() {
Ok(res) => assert_eq!(res, None),
_ => unreachable!(),
}
}
#[test]
fn should_parse_number_as_some() {
let estr = EString::from("99");
match estr.parse::<Option<i32>>() {
Ok(res) => assert_eq!(res, Some(99)),
_ => unreachable!(),
}
}
#[test]
fn should_parse_pair() {
let estr = EString::from("1+2");
match estr.parse::<Option<Pair<i32, '+', i32>>>() {
Ok(res) => assert_eq!(res, Some(Pair(1, 2))),
_ => unreachable!(),
}
}
#[test]
fn should_format_option() {
assert_eq!(None::<i32>.to_estring(), EString::new());
assert_eq!(Some(99).to_estring(), EString(String::from("99")));
}
}

2
src/structs.rs
View file

@ -5,8 +5,6 @@
mod pair;
mod sep_vec;
mod trio;
pub use pair::*;
pub use sep_vec::*;
pub use trio::*;

78
src/structs/pair.rs
View file

@ -1,13 +1,34 @@
//! Contains the implementations to pair tuple type
//!
use crate::core::{EString, ParseFragment, ToEString};
use crate::{Error, Reason};
use crate::core::EString;
use std::fmt::Write;
/// The error type for operations interacting with parsing tuples. Possibly returned from
/// ``EString::parse``
#[derive(Debug)]
pub enum Error {
/// The specified input string is not split.
Split,
/// The specified substring of the split input string is not parsed
Parse(u8),
}
impl std::fmt::Display for Error {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Error::Split => f.write_str("Cannot split input string"),
Error::Parse(n) => write!(f, "Cannot parse {} substring", n),
}
}
}
impl std::error::Error for Error {}
/// Wrapper for pair (A, B) tuple to split string by a separator (`S1`).
///
/// **NOTE**: Required the enabling of the `structs` feature.
/// **NOTE**: Required the enabling of the `tuple` feature.
///
/// # Examples
///
@ -16,7 +37,7 @@ use std::fmt::Write;
///
/// type EqPair<A, B> = Pair<A, '=', B>;
///
/// fn main() -> estring::Result<()> {
/// fn main() -> Result<(), estring::ParseError> {
/// let res = EString::from("one=two=free").parse::<EqPair<&str, &str>>()?;
/// assert_eq!(res, Pair("one", "two=free"));
/// Ok(())
@ -39,40 +60,25 @@ where
B: std::fmt::Display,
{
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{}{}{}", self.0, S1, self.1)
f.write_str(&self.0.to_string())?;
f.write_char(S1)?;
f.write_str(&self.1.to_string())
}
}
impl<A, B, const S1: char> ToEString for Pair<A, S1, B>
impl<A, const S1: char, B> TryFrom<EString> for Pair<A, S1, B>
where
A: ToEString,
B: ToEString,
A: TryFrom<EString>,
B: TryFrom<EString>,
{
fn to_estring(&self) -> EString {
let mut res = String::new();
write!(res, "{}{}{}", self.0.to_estring(), S1, self.1.to_estring())
.ok()
.expect("Cannot parse Pair to EString");
EString(res)
}
}
type Error = Error;
impl<A, B, const S1: char> ParseFragment for Pair<A, S1, B>
where
A: ParseFragment,
B: ParseFragment,
{
fn parse_frag(value: EString) -> crate::Result<Self> {
value
.clone()
.split_once(S1)
.ok_or(Error(value, Reason::Split))
.and_then(|(a, b)| {
let (a, b) = (EString::from(a), EString::from(b));
let a = A::parse_frag(a.clone()).map_err(|_| Error(a, Reason::Parse))?;
let b = B::parse_frag(b.clone()).map_err(|_| Error(b, Reason::Parse))?;
Ok(Self(a, b))
})
fn try_from(value: EString) -> Result<Self, Self::Error> {
value.split_once(S1).ok_or(Error::Split).and_then(|(a, b)| {
let a = A::try_from(EString::from(a)).map_err(|_| Error::Parse(0))?;
let b = B::try_from(EString::from(b)).map_err(|_| Error::Parse(1))?;
Ok(Self(a, b))
})
}
}
@ -114,12 +120,4 @@ hello=bar",
_ => unreachable!(),
};
}
#[test]
fn should_format_pair() {
let pair = Pair::<_, '+', _>(1, 2);
assert_eq!(pair.to_estring(), EString(String::from("1+2")));
let pair_in_pair = Pair::<_, '=', _>(3, pair);
assert_eq!(pair_in_pair.to_estring(), EString(String::from("3=1+2")));
}
}

91
src/structs/sep_vec.rs
View file

@ -1,12 +1,12 @@
//! Contains the implementations to vec type
//!
use crate::core::{EString, ParseFragment, ToEString};
use crate::core::EString;
use std::fmt::Write;
/// Wrapper for ``Vec`` to split string by a separator (`SEP`).
///
/// **NOTE**: Required the enabling of the `structs` feature.
/// **NOTE**: Required the enabling of the `vec` feature.
///
/// # Examples
///
@ -15,7 +15,7 @@ use std::fmt::Write;
///
/// type CommaVec<T> = SepVec<T, ','>;
///
/// fn main() -> estring::Result<()> {
/// fn main() -> Result<(), estring::ParseError> {
/// let res = EString::from("1,2,3").parse::<CommaVec<u8>>()?;
/// assert_eq!(*res, vec![1, 2, 3]);
/// Ok(())
@ -51,68 +51,38 @@ where
f.write_char(SEP)?;
}
write!(f, "{}", part)
f.write_str(&part.to_string())
})
}
}
impl<T, const SEP: char> ToEString for SepVec<T, SEP>
impl<T, const SEP: char> TryFrom<EString> for SepVec<T, SEP>
where
T: ToEString,
T: TryFrom<EString> + std::fmt::Display,
{
fn to_estring(&self) -> EString {
self.0
.iter()
.enumerate()
.try_fold(String::new(), |mut res, (i, part)| {
if i != 0 {
res.write_char(SEP).ok()?;
}
type Error = T::Error;
write!(res, "{}", part.to_estring()).ok()?;
Some(res)
})
.map(EString)
.expect("Cannot format SepVec ${self.0} to EString")
}
}
impl<T, const SEP: char> ParseFragment for SepVec<T, SEP>
where
T: ParseFragment,
{
fn parse_frag(value: EString) -> crate::Result<Self> {
fn try_from(value: EString) -> Result<Self, Self::Error> {
let inner = value
.split(SEP)
.map(str::trim)
.map(EString::from)
.map(T::parse_frag)
.collect::<crate::Result<Vec<_>>>()?;
.map(T::try_from)
.collect::<Result<Vec<_>, _>>()?;
Ok(Self(inner))
}
}
#[cfg(feature = "aggs")]
impl<T, const SEP: char> crate::core::Aggregatable for SepVec<T, SEP>
where
T: crate::core::Aggregatable,
{
type Item = T::Item;
fn items(self) -> Vec<Self::Item> {
self.0.into_iter().flat_map(T::items).collect()
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::Aggregatable;
use crate::Pair;
use crate::{Error, Reason};
use crate::ParseError;
type CommaVec<T> = SepVec<T, ','>;
type SemiVec<T> = SepVec<T, ';'>;
const COMMA: char = ',';
const SEMI: char = ';';
type CommaVec<T> = SepVec<T, COMMA>;
type SemiVec<T> = SepVec<T, SEMI>;
#[test]
fn should_parse_into_vec() {
@ -164,35 +134,10 @@ d,e";
fn should_throw_parse_vec_error() {
let estr = EString::from("1,2,3,4,5");
match estr.parse::<SemiVec<i32>>() {
Err(Error(orig, reason)) => {
assert_eq!(orig, EString::from("1,2,3,4,5"));
assert_eq!(reason, Reason::Parse);
Err(ParseError(orig)) => {
assert_eq!(orig, String::from("1,2,3,4,5"));
}
_ => unreachable!(),
};
}
#[test]
fn should_format_vec() {
type PlusPair<T> = Pair<T, '+', T>;
let vec = SepVec::<_, ','>::from(vec![1, 2, 3]);
assert_eq!(vec.to_estring(), EString(String::from("1,2,3")));
let vec = SepVec::<_, ','>::from(vec![PlusPair::from((1, 2)), PlusPair::from((3, 4))]);
assert_eq!(vec.to_estring(), EString(String::from("1+2,3+4")));
}
#[test]
fn should_returns_aggregatable_items() {
let estr = EString::from("1,2,3,4,5");
let res = estr.parse::<CommaVec<i32>>().unwrap();
assert_eq!(res.items(), vec![1, 2, 3, 4, 5]);
}
#[test]
fn should_returns_flatten_aggregatable_items() {
let estr = EString::from("1,2; 3,4,5; 6,7");
let res = estr.parse::<SemiVec<CommaVec<i32>>>().unwrap();
assert_eq!(res.items(), vec![1, 2, 3, 4, 5, 6, 7]);
}
}

132
src/structs/trio.rs
View file

@ -1,132 +0,0 @@
//! Contains the implementations to parse triple-tuple type
//!
use super::Pair;
use crate::core::{EString, ParseFragment, ToEString};
use std::fmt::Write;
/// Wrapper for trio (A, B, C) tuple to split string by separators (`S1` and `S2`).
///
/// **NOTE**: Required the enabling of the `structs` feature.
///
/// # Examples
///
/// ```rust
/// use estring::{Trio, EString};
///
/// fn main() -> estring::Result<()> {
/// let res = EString::from("one+two=free").parse::<Trio<&str, '+', &str, '=', &str>>()?;
/// assert_eq!(res, Trio("one", "two", "free"));
/// Ok(())
/// }
/// ```
///
#[derive(Debug, PartialEq, Clone)]
pub struct Trio<A, const S1: char, B, const S2: char, C>(pub A, pub B, pub C);
impl<A, B, C, const S1: char, const S2: char> From<(A, B, C)> for Trio<A, S1, B, S2, C> {
#[inline]
fn from((a, b, c): (A, B, C)) -> Self {
Self(a, b, c)
}
}
impl<A, B, C, const S1: char, const S2: char> std::fmt::Display for Trio<A, S1, B, S2, C>
where
A: std::fmt::Display,
B: std::fmt::Display,
C: std::fmt::Display,
{
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(&self.0.to_string())?;
f.write_char(S1)?;
f.write_str(&self.1.to_string())?;
f.write_char(S2)?;
f.write_str(&self.2.to_string())
}
}
impl<A, B, C, const S1: char, const S2: char> ToEString for Trio<A, S1, B, S2, C>
where
A: ToEString,
B: ToEString,
C: ToEString,
{
fn to_estring(&self) -> EString {
let mut res = String::new();
write!(
res,
"{}{}{}{}{}",
self.0.to_estring(),
S1,
self.1.to_estring(),
S2,
self.2.to_estring()
)
.ok()
.expect("Cannot parse Pair to EString");
EString(res)
}
}
impl<A, const S1: char, B, const S2: char, C> ParseFragment for Trio<A, S1, B, S2, C>
where
A: ParseFragment,
B: ParseFragment,
C: ParseFragment,
{
fn parse_frag(value: EString) -> crate::Result<Self> {
Pair::<A, S1, EString>::parse_frag(value).and_then(|Pair(a, rest)| {
Pair::<B, S2, C>::parse_frag(rest).map(|Pair(b, c)| Self(a, b, c))
})
}
}
#[cfg(test)]
mod tests {
use super::*;
type EqTrio<A, B, C> = Trio<A, '=', B, '=', C>;
#[test]
fn should_parse_into_trio() {
let estr = EString::from("hello=world=hello");
match estr.parse::<EqTrio<&str, &str, &str>>() {
Ok(res) => assert_eq!((res.0, res.1, res.2), ("hello", "world", "hello")),
_ => unreachable!(),
};
}
#[test]
fn should_parse_into_trio_with_alternate_delims() {
let estr = EString::from("hello-world^hello");
match estr.parse::<Trio<&str, '-', &str, '^', &str>>() {
Ok(res) => assert_eq!((res.0, res.1, res.2), ("hello", "world", "hello")),
_ => unreachable!(),
};
}
#[test]
fn should_parse_rest_as_trio() {
let estr = EString::from("hello=world=hello=world=hello");
match estr.parse::<EqTrio<&str, &str, EqTrio<&str, &str, &str>>>() {
Ok(res) => assert_eq!(res, Trio("hello", "world", Trio("hello", "world", "hello"))),
_ => unreachable!(),
};
}
#[test]
fn should_format_trio() {
let trio = Trio::<_, '+', _, '-', _>::from(("foo", "baz", "bar"));
assert_eq!(
trio.clone().to_estring(),
EString(String::from("foo+baz-bar"))
);
let trio_in_trio = Trio::<_, '*', _, '=', _>::from(("foo", "baz", trio));
assert_eq!(
trio_in_trio.clone().to_estring(),
EString(String::from("foo*baz=foo+baz-bar"))
);
}
}