Use PathParams

proptest/src/arbitrary/_std/path.rs

@@ -9,40 +9,91 @@
 
 //! Arbitrary implementations for `std::path`.
 
-use std::{ffi::OsString, path::*};
+use std::path::*;
 
 use crate::{
     arbitrary::{SMapped, StrategyFor},
+    path::PathParams,
     prelude::{any, any_with, Arbitrary, Strategy},
-    std_facade::{string::ToString, Arc, Box, Rc, Vec},
+    std_facade::{string::ToString, Arc, Box, Rc, String, Vec},
     strategy::{statics::static_map, MapInto},
 };
 
 arbitrary!(StripPrefixError; Path::new("").strip_prefix("a").unwrap_err());
 
-/// This implementation takes two parameters: a range for the number of components, and a regex to
-/// determine the string. It generates either a relative or an absolute path with equal probability.
+/// A private type (not actually pub) representing the output of [`PathParams`] that can't be
+/// referred to by API users.
+///
+/// The goal of this type is to encapsulate the output of `PathParams`. If this layer weren't
+/// present, the type of `<PathBuf as Arbitrary>::Strategy` would be `SMapped<(bool, Vec<String>),
+/// Self>`. This is a problem because it exposes the internal representation of `PathParams` as an
+/// API. For example, if an additional parameter of randomness (e.g. another bool) were added, the
+/// type of `Strategy` would change.
+///
+/// With `PathParamsOutput`, the type of `Strategy` is `SMapped<PathParamsOutput, Self>`, which is a
+/// type that can't be named directly---only via `<PathBuf as Arbitrary>::Strategy`. The internal
+/// representation of `PathParams` can be changed without affecting the API.
+#[derive(Debug)]
+pub struct PathParamsOutput {
+    is_absolute: bool,
+    components: Vec<String>,
+}
+
+impl Arbitrary for PathParamsOutput {
+    type Parameters = PathParams;
+    type Strategy = SMapped<(bool, Vec<String>), Self>;
+
+    fn arbitrary_with(args: Self::Parameters) -> Self::Strategy {
+        static_map(
+            (
+                any::<bool>(),
+                any_with::<Vec<String>>((
+                    args.components(),
+                    args.component_regex(),
+                )),
+            ),
+            |(is_absolute, components)| Self {
+                is_absolute,
+                components,
+            },
+        )
+    }
+}
+
+/// This implementation accepts as its argument a [`PathParams`] struct. It generates either a
+/// relative or an absolute path with equal probability.
 ///
 /// Currently, this implementation does not generate:
 ///
 /// * Paths that are not valid UTF-8 (this is unlikely to change)
 /// * Paths with a [`PrefixComponent`](std::path::PrefixComponent) on Windows, e.g. `C:\` (this may
 ///   change in the future)
 impl Arbitrary for PathBuf {
-    type Parameters = <Vec<OsString> as Arbitrary>::Parameters;
-    type Strategy = SMapped<(bool, Vec<OsString>), Self>;
+    type Parameters = PathParams;
+    type Strategy = SMapped<PathParamsOutput, Self>;
 
     fn arbitrary_with(args: Self::Parameters) -> Self::Strategy {
         static_map(
-            (any::<bool>(), any_with::<Vec<OsString>>(args)),
-            |(is_absolute, parts)| {
+            any_with::<PathParamsOutput>(args),
+            |PathParamsOutput {
+                 is_absolute,
+                 components,
+             }| {
                 let mut out = PathBuf::new();
                 if is_absolute {
                     out.push(&MAIN_SEPARATOR.to_string());
                 }
-                for part in parts {
-                    out.push(&part);
+
+                for component in components {
+                    // If a component has an embedded / (or \ on Windows), remove it from the
+                    // string.
+                    let component = component
+                        .chars()
+                        .filter(|&c| !std::path::is_separator(c))
+                        .collect::<String>();
+                    out.push(&component);
                 }
+
                 out
             },
         )
@@ -55,7 +106,7 @@ macro_rules! dst_wrapped {
             /// This implementation is identical to [the `Arbitrary` implementation for
             /// `PathBuf`](trait.Arbitrary.html#impl-Arbitrary-for-PathBuf).
             impl Arbitrary for $w<Path> {
-                type Parameters = <Vec<OsString> as Arbitrary>::Parameters;
+                type Parameters = PathParams;
                 type Strategy = MapInto<StrategyFor<PathBuf>, Self>;
 
                 fn arbitrary_with(args: Self::Parameters) -> Self::Strategy {

proptest/src/lib.rs

@@ -86,6 +86,9 @@ pub mod test_runner;
 pub mod tuple;
 
 pub mod option;
+#[cfg(feature = "std")]
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
+pub mod path;
 pub mod result;
 pub mod sample;
 #[cfg(feature = "std")]

proptest/src/path.rs

@@ -0,0 +1,55 @@
+//! Strategies for generating [`PathBuf`] and related path types.
+//!
+//! [`PathParams`] in this module is used as the argument to the
+//! [`Arbitrary`](crate::arbitrary::Arbitrary) implementation for [`PathBuf`].
+
+use crate::{collection::SizeRange, string::StringParam};
+
+/// Parameters for the [`Arbitrary`] implementation for [`PathBuf`].
+///
+/// By default, this generates paths with 0 to 8 components uniformly at random, each of which is a
+/// default [`StringParam`].
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct PathParams {
+    /// The number of components in the path.
+    components: SizeRange,
+    /// The regular expression to generate individual components.
+    component_regex: StringParam,
+}
+
+impl PathParams {
+    /// Gets the number of components in the path.
+    pub fn components(&self) -> SizeRange {
+        self.components.clone()
+    }
+
+    /// Sets the number of components in the path.
+    pub fn with_components(mut self, components: impl Into<SizeRange>) -> Self {
+        self.components = components.into();
+        self
+    }
+
+    /// Gets the regular expression to generate individual components.
+    pub fn component_regex(&self) -> StringParam {
+        self.component_regex
+    }
+
+    /// Sets the regular expression to generate individual components.
+    pub fn with_component_regex(
+        mut self,
+        component_regex: impl Into<StringParam>,
+    ) -> Self {
+        self.component_regex = component_regex.into();
+        self
+    }
+}
+
+impl Default for PathParams {
+    fn default() -> Self {
+        Self {
+            components: (0..8).into(),
+            // This is the default regex for `any::<String>()`.
+            component_regex: StringParam::default(),
+        }
+    }
+}

proptest/src/string.rs

@@ -27,7 +27,7 @@ use crate::test_runner::*;
 
 /// Wraps the regex that forms the `Strategy` for `String` so that a sensible
 /// `Default` can be given. The default is a string of non-control characters.
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct StringParam(&'static str);
 
 impl From<StringParam> for &'static str {