From d7520565d9861751218ea96d8d13fe013b13c760 Mon Sep 17 00:00:00 2001 From: Ed Page Date: Wed, 11 Apr 2018 12:58:41 -0600 Subject: [PATCH] feat: Re-organize API Previously, the API was focused on convenience for importing in a specific way. This change splits out functionality from convenience. The convenience is now done via a prelude module. Fixes #17 --- src/{predicate => }/boolean.rs | 0 src/{predicate => }/boxed.rs | 0 src/{predicate => }/constant.rs | 8 ++-- src/{predicate/mod.rs => core.rs} | 58 ++++++++------------------- src/{predicate => }/float/close.rs | 16 ++++---- src/{predicate => }/float/mod.rs | 0 src/{predicate => }/function.rs | 2 +- src/lib.rs | 25 ++++++++++-- src/{predicate => }/ord.rs | 24 +++++------ src/{predicate => }/path/existence.rs | 8 ++-- src/{predicate => }/path/ft.rs | 12 +++--- src/{predicate => }/path/mod.rs | 0 src/prelude.rs | 47 ++++++++++++++++++++++ src/{predicate => }/set.rs | 12 +++--- src/{predicate => }/str/difference.rs | 18 ++++----- src/{predicate => }/str/mod.rs | 0 src/{predicate => }/str/regex.rs | 4 +- 17 files changed, 137 insertions(+), 97 deletions(-) rename src/{predicate => }/boolean.rs (100%) rename src/{predicate => }/boxed.rs (100%) rename src/{predicate => }/constant.rs (92%) rename src/{predicate/mod.rs => core.rs} (67%) rename src/{predicate => }/float/close.rs (86%) rename src/{predicate => }/float/mod.rs (100%) rename src/{predicate => }/function.rs (97%) rename src/{predicate => }/ord.rs (91%) rename src/{predicate => }/path/existence.rs (89%) rename src/{predicate => }/path/ft.rs (92%) rename src/{predicate => }/path/mod.rs (100%) create mode 100644 src/prelude.rs rename src/{predicate => }/set.rs (95%) rename src/{predicate => }/str/difference.rs (87%) rename src/{predicate => }/str/mod.rs (100%) rename src/{predicate => }/str/regex.rs (92%) diff --git a/src/predicate/boolean.rs b/src/boolean.rs similarity index 100% rename from src/predicate/boolean.rs rename to src/boolean.rs diff --git a/src/predicate/boxed.rs b/src/boxed.rs similarity index 100% rename from src/predicate/boxed.rs rename to src/boxed.rs diff --git a/src/predicate/constant.rs b/src/constant.rs similarity index 92% rename from src/predicate/constant.rs rename to src/constant.rs index 6c3caeb..6099245 100644 --- a/src/predicate/constant.rs +++ b/src/constant.rs @@ -34,9 +34,9 @@ impl Predicate for BooleanPredicate { /// # Examples /// /// ``` -/// use predicates::predicate::*; +/// use predicates::prelude::*; /// -/// let predicate_fn = always(); +/// let predicate_fn = predicate::always(); /// assert_eq!(true, predicate_fn.eval(&5)); /// assert_eq!(true, predicate_fn.eval(&10)); /// assert_eq!(true, predicate_fn.eval(&15)); @@ -55,9 +55,9 @@ pub fn always() -> BooleanPredicate { /// # Examples /// /// ``` -/// use predicates::predicate::*; +/// use predicates::prelude::*; /// -/// let predicate_fn = never(); +/// let predicate_fn = predicate::never(); /// assert_eq!(false, predicate_fn.eval(&5)); /// assert_eq!(false, predicate_fn.eval(&10)); /// assert_eq!(false, predicate_fn.eval(&15)); diff --git a/src/predicate/mod.rs b/src/core.rs similarity index 67% rename from src/predicate/mod.rs rename to src/core.rs index 0aa8cc8..85152ea 100644 --- a/src/predicate/mod.rs +++ b/src/core.rs @@ -1,37 +1,13 @@ -// Copyright (c) 2017, Nick Stevens +// Copyright (c) 2018 The predicates-rs Project Developers. // // Licensed under the Apache License, Version 2.0 or the MIT license +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // , at your // option. This file may not be copied, modified, or distributed // except according to those terms. -//! Predicate -//! -//! This module contains the `Predicate` trait and a number of combinators for -//! the trait. See the crate docs, and the docs for `Predicate`, for full detail. - -// primitive `Predicate` types -mod constant; -mod function; -mod ord; -mod set; -pub use self::constant::{always, never, BooleanPredicate}; -pub use self::function::{function, FnPredicate}; -pub use self::ord::{eq, ge, gt, le, lt, ne, EqPredicate, OrdPredicate}; -pub use self::set::{contains, contains_hashable, contains_ord, ContainsPredicate, - HashableContainsPredicate, OrdContainsPredicate}; - -// specialized primitive `Predicate` types -pub mod str; -pub mod path; -pub mod float; - -// combinators -mod boolean; -mod boxed; -pub use self::boolean::{AndPredicate, NotPredicate, OrPredicate}; -pub use self::boxed::BoxPredicate; +use boolean::{AndPredicate, NotPredicate, OrPredicate}; +use boxed::BoxPredicate; /// Trait for generically evaluating a type against a dynamically created /// predicate function. @@ -53,10 +29,10 @@ pub trait Predicate { /// # Examples /// /// ``` - /// use predicates::predicate::*; + /// use predicates::prelude::*; /// - /// let predicate_fn1 = always().and(always()); - /// let predicate_fn2 = always().and(never()); + /// let predicate_fn1 = predicate::always().and(predicate::always()); + /// let predicate_fn2 = predicate::always().and(predicate::never()); /// assert_eq!(true, predicate_fn1.eval(&4)); /// assert_eq!(false, predicate_fn2.eval(&4)); fn and(self, other: B) -> AndPredicate @@ -72,11 +48,11 @@ pub trait Predicate { /// # Examples /// /// ``` - /// use predicates::predicate::*; + /// use predicates::prelude::*; /// - /// let predicate_fn1 = always().or(always()); - /// let predicate_fn2 = always().or(never()); - /// let predicate_fn3 = never().or(never()); + /// let predicate_fn1 = predicate::always().or(predicate::always()); + /// let predicate_fn2 = predicate::always().or(predicate::never()); + /// let predicate_fn3 = predicate::never().or(predicate::never()); /// assert_eq!(true, predicate_fn1.eval(&4)); /// assert_eq!(true, predicate_fn2.eval(&4)); /// assert_eq!(false, predicate_fn3.eval(&4)); @@ -93,10 +69,10 @@ pub trait Predicate { /// # Examples /// /// ``` - /// use predicates::predicate::*; + /// use predicates::prelude::*; /// - /// let predicate_fn1 = always().not(); - /// let predicate_fn2 = never().not(); + /// let predicate_fn1 = predicate::always().not(); + /// let predicate_fn2 = predicate::never().not(); /// assert_eq!(false, predicate_fn1.eval(&4)); /// assert_eq!(true, predicate_fn2.eval(&4)); fn not(self) -> NotPredicate @@ -121,11 +97,11 @@ pub trait Predicate { /// # Examples /// /// ``` - /// use predicates::predicate::*; + /// use predicates::prelude::*; /// /// let predicates = vec![ - /// always().boxed(), - /// never().boxed(), + /// predicate::always().boxed(), + /// predicate::never().boxed(), /// ]; /// assert_eq!(true, predicates[0].eval(&4)); /// assert_eq!(false, predicates[1].eval(&4)); diff --git a/src/predicate/float/close.rs b/src/float/close.rs similarity index 86% rename from src/predicate/float/close.rs rename to src/float/close.rs index e1c4d30..3b5040f 100644 --- a/src/predicate/float/close.rs +++ b/src/float/close.rs @@ -31,10 +31,10 @@ impl IsClosePredicate { /// # Examples /// /// ``` - /// use predicates::predicate::*; + /// use predicates::prelude::*; /// /// let a = 0.15_f64 + 0.15_f64 + 0.15_f64; - /// let predicate_fn = float::is_close(a).distance(5); + /// let predicate_fn = predicate::float::is_close(a).distance(5); /// ``` pub fn distance(mut self, distance: ::U) -> Self { self.epsilon = (distance as f64) * ::std::f64::EPSILON; @@ -50,10 +50,10 @@ impl IsClosePredicate { /// # Examples /// /// ``` - /// use predicates::predicate::*; + /// use predicates::prelude::*; /// /// let a = 0.15_f64 + 0.15_f64 + 0.15_f64; - /// let predicate_fn = float::is_close(a).epsilon(5.0 * ::std::f64::EPSILON); + /// let predicate_fn = predicate::float::is_close(a).epsilon(5.0 * ::std::f64::EPSILON); /// ``` pub fn epsilon(mut self, epsilon: f64) -> Self { self.epsilon = epsilon; @@ -67,10 +67,10 @@ impl IsClosePredicate { /// # Examples /// /// ``` - /// use predicates::predicate::*; + /// use predicates::prelude::*; /// /// let a = 0.15_f64 + 0.15_f64 + 0.15_f64; - /// let predicate_fn = float::is_close(a).ulps(5); + /// let predicate_fn = predicate::float::is_close(a).ulps(5); /// ``` pub fn ulps(mut self, ulps: ::U) -> Self { self.ulps = ulps; @@ -92,11 +92,11 @@ impl Predicate for IsClosePredicate { /// # Examples /// /// ``` -/// use predicates::predicate::*; +/// use predicates::prelude::*; /// /// let a = 0.15_f64 + 0.15_f64 + 0.15_f64; /// let b = 0.1_f64 + 0.1_f64 + 0.25_f64; -/// let predicate_fn = float::is_close(a); +/// let predicate_fn = predicate::float::is_close(a); /// assert_eq!(true, predicate_fn.eval(&b)); /// assert_eq!(false, predicate_fn.distance(0).eval(&b)); /// ``` diff --git a/src/predicate/float/mod.rs b/src/float/mod.rs similarity index 100% rename from src/predicate/float/mod.rs rename to src/float/mod.rs diff --git a/src/predicate/function.rs b/src/function.rs similarity index 97% rename from src/predicate/function.rs rename to src/function.rs index ec7ab48..bd21745 100644 --- a/src/predicate/function.rs +++ b/src/function.rs @@ -41,7 +41,7 @@ where /// # Examples /// /// ``` -/// use predicates::predicate::{self, Predicate}; +/// use predicates::prelude::*; /// /// struct Example { /// string: String, diff --git a/src/lib.rs b/src/lib.rs index 31a6a46..e8d153f 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -32,7 +32,7 @@ //! A few different examples of how predicates might be used: //! //! ``` -//! use predicates::{predicate, Predicate}; +//! use predicates::prelude::*; //! //! // The simplest predicates are `always()` and `never()`, which always returns //! // `true` and always returns `false`, respectively. The values are simply @@ -92,6 +92,23 @@ extern crate float_cmp; #[cfg(feature = "regex")] extern crate regex; -// core `Predicate` trait -pub mod predicate; -pub use self::predicate::{BoxPredicate, Predicate}; +pub mod prelude; + +mod core; +pub use core::Predicate; +mod boxed; +pub use boxed::BoxPredicate; + +// core predicates +pub mod constant; +pub mod function; +pub mod ord; +pub mod set; + +// combinators +pub mod boolean; + +// specialized primitive `Predicate` types +pub mod str; +pub mod path; +pub mod float; diff --git a/src/predicate/ord.rs b/src/ord.rs similarity index 91% rename from src/predicate/ord.rs rename to src/ord.rs index 20a7543..686c5dc 100644 --- a/src/predicate/ord.rs +++ b/src/ord.rs @@ -46,9 +46,9 @@ where /// # Examples /// /// ``` -/// use predicates::predicate::*; +/// use predicates::prelude::*; /// -/// let predicate_fn = eq(5); +/// let predicate_fn = predicate::eq(5); /// assert_eq!(true, predicate_fn.eval(&5)); /// assert_eq!(false, predicate_fn.eval(&10)); /// ``` @@ -68,9 +68,9 @@ where /// # Examples /// /// ``` -/// use predicates::predicate::*; +/// use predicates::prelude::*; /// -/// let predicate_fn = ne(5); +/// let predicate_fn = predicate::ne(5); /// assert_eq!(false, predicate_fn.eval(&5)); /// assert_eq!(true, predicate_fn.eval(&10)); /// ``` @@ -124,9 +124,9 @@ where /// # Examples /// /// ``` -/// use predicates::predicate::*; +/// use predicates::prelude::*; /// -/// let predicate_fn = lt(5); +/// let predicate_fn = predicate::lt(5); /// assert_eq!(true, predicate_fn.eval(&4)); /// assert_eq!(false, predicate_fn.eval(&6)); /// ``` @@ -146,9 +146,9 @@ where /// # Examples /// /// ``` -/// use predicates::predicate::*; +/// use predicates::prelude::*; /// -/// let predicate_fn = le(5); +/// let predicate_fn = predicate::le(5); /// assert_eq!(true, predicate_fn.eval(&4)); /// assert_eq!(true, predicate_fn.eval(&5)); /// assert_eq!(false, predicate_fn.eval(&6)); @@ -169,9 +169,9 @@ where /// # Examples /// /// ``` -/// use predicates::predicate::*; +/// use predicates::prelude::*; /// -/// let predicate = ge(5); +/// let predicate = predicate::ge(5); /// assert_eq!(false, predicate.eval(&4)); /// assert_eq!(true, predicate.eval(&5)); /// assert_eq!(true, predicate.eval(&6)); @@ -192,9 +192,9 @@ where /// # Examples /// /// ``` -/// use predicates::predicate::*; +/// use predicates::prelude::*; /// -/// let predicate_fn = gt(5); +/// let predicate_fn = predicate::gt(5); /// assert_eq!(false, predicate_fn.eval(&4)); /// assert_eq!(false, predicate_fn.eval(&5)); /// assert_eq!(true, predicate_fn.eval(&6)); diff --git a/src/predicate/path/existence.rs b/src/path/existence.rs similarity index 89% rename from src/predicate/path/existence.rs rename to src/path/existence.rs index d4b80b0..7a4bc43 100644 --- a/src/predicate/path/existence.rs +++ b/src/path/existence.rs @@ -32,9 +32,9 @@ impl Predicate for ExistencePredicate { /// /// ``` /// use std::path::Path; -/// use predicates::predicate::*; +/// use predicates::prelude::*; /// -/// let predicate_fn = path::exists(); +/// let predicate_fn = predicate::path::exists(); /// assert_eq!(true, predicate_fn.eval(Path::new("Cargo.toml"))); /// ``` pub fn exists() -> ExistencePredicate { @@ -47,9 +47,9 @@ pub fn exists() -> ExistencePredicate { /// /// ``` /// use std::path::Path; -/// use predicates::predicate::*; +/// use predicates::prelude::*; /// -/// let predicate_fn = path::missing(); +/// let predicate_fn = predicate::path::missing(); /// assert_eq!(true, predicate_fn.eval(Path::new("non-existent-file.foo"))); /// ``` pub fn missing() -> ExistencePredicate { diff --git a/src/predicate/path/ft.rs b/src/path/ft.rs similarity index 92% rename from src/predicate/path/ft.rs rename to src/path/ft.rs index e863726..c101b66 100644 --- a/src/predicate/path/ft.rs +++ b/src/path/ft.rs @@ -70,9 +70,9 @@ impl Predicate for FileTypePredicate { /// /// ``` /// use std::path::Path; -/// use predicates::predicate::*; +/// use predicates::prelude::*; /// -/// let predicate_fn = path::is_file(); +/// let predicate_fn = predicate::path::is_file(); /// assert_eq!(true, predicate_fn.eval(Path::new("Cargo.toml"))); /// assert_eq!(false, predicate_fn.eval(Path::new("src"))); /// assert_eq!(false, predicate_fn.eval(Path::new("non-existent-file.foo"))); @@ -90,9 +90,9 @@ pub fn is_file() -> FileTypePredicate { /// /// ``` /// use std::path::Path; -/// use predicates::predicate::*; +/// use predicates::prelude::*; /// -/// let predicate_fn = path::is_dir(); +/// let predicate_fn = predicate::path::is_dir(); /// assert_eq!(false, predicate_fn.eval(Path::new("Cargo.toml"))); /// assert_eq!(true, predicate_fn.eval(Path::new("src"))); /// assert_eq!(false, predicate_fn.eval(Path::new("non-existent-file.foo"))); @@ -110,9 +110,9 @@ pub fn is_dir() -> FileTypePredicate { /// /// ``` /// use std::path::Path; -/// use predicates::predicate::*; +/// use predicates::prelude::*; /// -/// let predicate_fn = path::is_symlink(); +/// let predicate_fn = predicate::path::is_symlink(); /// assert_eq!(false, predicate_fn.eval(Path::new("Cargo.toml"))); /// assert_eq!(false, predicate_fn.eval(Path::new("src"))); /// assert_eq!(false, predicate_fn.eval(Path::new("non-existent-file.foo"))); diff --git a/src/predicate/path/mod.rs b/src/path/mod.rs similarity index 100% rename from src/predicate/path/mod.rs rename to src/path/mod.rs diff --git a/src/prelude.rs b/src/prelude.rs new file mode 100644 index 0000000..cb6f6d9 --- /dev/null +++ b/src/prelude.rs @@ -0,0 +1,47 @@ +// Copyright (c) 2018 The predicates-rs Project Developers. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +//! Module that contains the essentials for working with predicates. + +pub use core::Predicate; + +/// Predicate factories +pub mod predicate { + // primitive `Predicate` types + pub use constant::{always, never}; + pub use function::function; + pub use ord::{eq, ge, gt, le, lt, ne}; + pub use set::{contains, contains_hashable, contains_ord}; + + /// `str` Predicate factories + /// + /// This module contains predicates specific to string handling. + pub mod str { + #[cfg(feature = "difference")] + pub use str::{diff, similar}; + + #[cfg(feature = "regex")] + pub use str::is_match; + } + + /// `Path` Predicate factories + /// + /// This module contains predicates specific to path handling. + pub mod path { + pub use path::{exists, missing}; + pub use path::{is_dir, is_file, is_symlink}; + } + + /// `f64` Predicate factories + /// + /// This module contains predicates specific to float handling. + pub mod float { + #[cfg(feature = "float-cmp")] + pub use float::is_close; + } +} diff --git a/src/predicate/set.rs b/src/set.rs similarity index 95% rename from src/predicate/set.rs rename to src/set.rs index 2250134..4e67d46 100644 --- a/src/predicate/set.rs +++ b/src/set.rs @@ -55,9 +55,9 @@ where /// # Examples /// /// ``` -/// use predicates::predicate::*; +/// use predicates::prelude::*; /// -/// let predicate_fn = contains(vec![1, 3, 5]); +/// let predicate_fn = predicate::contains(vec![1, 3, 5]); /// assert_eq!(true, predicate_fn.eval(&1)); /// assert_eq!(false, predicate_fn.eval(&2)); /// assert_eq!(true, predicate_fn.eval(&3)); @@ -113,9 +113,9 @@ where /// # Examples /// /// ``` -/// use predicates::predicate::*; +/// use predicates::prelude::*; /// -/// let predicate_fn = contains_ord(vec![1, 3, 5]); +/// let predicate_fn = predicate::contains_ord(vec![1, 3, 5]); /// assert_eq!(true, predicate_fn.eval(&1)); /// assert_eq!(false, predicate_fn.eval(&2)); /// assert_eq!(true, predicate_fn.eval(&3)); @@ -171,9 +171,9 @@ where /// # Examples /// /// ``` -/// use predicates::predicate::*; +/// use predicates::prelude::*; /// -/// let predicate_fn = contains_hashable(vec![1, 3, 5]); +/// let predicate_fn = predicate::contains_hashable(vec![1, 3, 5]); /// assert_eq!(true, predicate_fn.eval(&1)); /// assert_eq!(false, predicate_fn.eval(&2)); /// assert_eq!(true, predicate_fn.eval(&3)); diff --git a/src/predicate/str/difference.rs b/src/str/difference.rs similarity index 87% rename from src/predicate/str/difference.rs rename to src/str/difference.rs index 6370ae5..48c0950 100644 --- a/src/predicate/str/difference.rs +++ b/src/str/difference.rs @@ -44,16 +44,16 @@ impl DifferencePredicate { /// Common splits include: /// - `""` for char-level. /// - `" "` for word-level. - /// - `"\n" for line-level. + /// - `"\n"` for line-level. /// /// Default: `"\n"` /// /// # Examples /// /// ``` - /// use predicates::predicate::*; + /// use predicates::prelude::*; /// - /// let predicate_fn = str::similar("Hello World").split(" "); + /// let predicate_fn = predicate::str::similar("Hello World").split(" "); /// assert_eq!(true, predicate_fn.eval("Hello World")); /// ``` pub fn split(mut self, split: S) -> Self @@ -71,9 +71,9 @@ impl DifferencePredicate { /// # Examples /// /// ``` - /// use predicates::predicate::*; + /// use predicates::prelude::*; /// - /// let predicate_fn = str::similar("Hello World!").split("").distance(1); + /// let predicate_fn = predicate::str::similar("Hello World!").split("").distance(1); /// assert_eq!(true, predicate_fn.eval("Hello World!")); /// assert_eq!(true, predicate_fn.eval("Hello World")); /// assert_eq!(false, predicate_fn.eval("Hello World?")); @@ -98,9 +98,9 @@ impl Predicate for DifferencePredicate { /// # Examples /// /// ``` -/// use predicates::predicate::*; +/// use predicates::prelude::*; /// -/// let predicate_fn = str::diff("Hello World"); +/// let predicate_fn = predicate::str::diff("Hello World"); /// assert_eq!(false, predicate_fn.eval("Hello World")); /// assert_eq!(true, predicate_fn.eval("Goodbye World")); /// ``` @@ -121,9 +121,9 @@ where /// # Examples /// /// ``` -/// use predicates::predicate::*; +/// use predicates::prelude::*; /// -/// let predicate_fn = str::similar("Hello World"); +/// let predicate_fn = predicate::str::similar("Hello World"); /// assert_eq!(true, predicate_fn.eval("Hello World")); /// assert_eq!(false, predicate_fn.eval("Goodbye World")); /// ``` diff --git a/src/predicate/str/mod.rs b/src/str/mod.rs similarity index 100% rename from src/predicate/str/mod.rs rename to src/str/mod.rs diff --git a/src/predicate/str/regex.rs b/src/str/regex.rs similarity index 92% rename from src/predicate/str/regex.rs rename to src/str/regex.rs index 2849e69..4d84403 100644 --- a/src/predicate/str/regex.rs +++ b/src/str/regex.rs @@ -34,9 +34,9 @@ impl Predicate for RegexPredicate { /// # Examples /// /// ``` -/// use predicates::predicate::*; +/// use predicates::prelude::*; /// -/// let predicate_fn = str::is_match("^Hel.o.*$").unwrap(); +/// let predicate_fn = predicate::str::is_match("^Hel.o.*$").unwrap(); /// assert_eq!(true, predicate_fn.eval("Hello World")); /// assert_eq!(false, predicate_fn.eval("Food World")); /// ```