Move logic for manipulating TargetPattern down to the type

Summary: Much better to have the logic for string splitting on the type, then we can easily have doctests for the various manipulations.

Reviewed By: pcerl017

Differential Revision: D53164474

fbshipit-source-id: 68c5f65e2301a13811b2a9895f3fa79ddef0680a

btd/src/buck/target_map.rs

@@ -50,23 +50,17 @@ impl<T> TargetMap<T> {
     pub fn insert_pattern(&mut self, key: &TargetPattern, value: T) {
         if let Some(label) = key.as_target_label() {
             self.insert(&label, value);
-        } else if let Some(prefix) = key.as_str().strip_suffix(':') {
+        } else if let Some(prefix) = key.as_package_pattern() {
             self.non_recursive_pattern
-                .entry(Package::new(prefix))
+                .entry(prefix)
                 .or_default()
                 .push(value);
-        } else if let Some(prefix) = key.as_str().strip_suffix("...") {
-            // if it is foo// we need to keep the slash, if foo//bar/ we need to remove it
-            let prefix = match prefix.strip_suffix('/') {
-                Some(x) if !x.ends_with('/') => x,
-                _ => prefix,
-            };
-            self.recursive_pattern
-                .update(&Package::new(prefix), move |old| {
-                    let mut res = old.unwrap_or_default();
-                    res.push(value);
-                    res
-                });
+        } else if let Some(prefix) = key.as_recursive_pattern() {
+            self.recursive_pattern.update(&prefix, move |old| {
+                let mut res = old.unwrap_or_default();
+                res.push(value);
+                res
+            });
         } else {
             warn!("Ignored invalid target pattern, `{}`", key)
         }

btd/src/buck/types.rs

@@ -102,6 +102,61 @@ impl TargetPattern {
         }
     }
 
+    /// Convert a pattern representing a single package into that `Package`.
+    /// These are the patterns that end in the `:` suffix.
+    ///
+    /// ```
+    /// use btd::buck::types::Package;
+    /// use btd::buck::types::TargetPattern;
+    /// assert_eq!(
+    ///     TargetPattern::new("foo//:").as_package_pattern(),
+    ///     Some(Package::new("foo//"))
+    /// );
+    /// assert_eq!(
+    ///     TargetPattern::new("foo//bar:").as_package_pattern(),
+    ///     Some(Package::new("foo//bar"))
+    /// );
+    /// assert_eq!(
+    ///     TargetPattern::new("foo//bar/baz:").as_package_pattern(),
+    ///     Some(Package::new("foo//bar/baz"))
+    /// );
+    /// assert_eq!(TargetPattern::new("foo//...").as_package_pattern(), None);
+    /// assert_eq!(TargetPattern::new("foo//bar").as_package_pattern(), None);
+    /// ```
+    pub fn as_package_pattern(&self) -> Option<Package> {
+        self.as_str().strip_suffix(':').map(Package::new)
+    }
+
+    /// Convert a pattern representing a recursive package into that `Package`.
+    /// These are the patterns that end in the `...` suffix.
+    ///
+    /// ```
+    /// use btd::buck::types::Package;
+    /// use btd::buck::types::TargetPattern;
+    /// assert_eq!(
+    ///     TargetPattern::new("foo//...").as_recursive_pattern(),
+    ///     Some(Package::new("foo//"))
+    /// );
+    /// assert_eq!(
+    ///     TargetPattern::new("foo//bar/...").as_recursive_pattern(),
+    ///     Some(Package::new("foo//bar"))
+    /// );
+    /// assert_eq!(
+    ///     TargetPattern::new("foo//bar/baz/...").as_recursive_pattern(),
+    ///     Some(Package::new("foo//bar/baz"))
+    /// );
+    /// assert_eq!(TargetPattern::new("foo//bar:").as_recursive_pattern(), None);
+    /// assert_eq!(TargetPattern::new("foo//bar").as_recursive_pattern(), None);
+    /// ```
+    pub fn as_recursive_pattern(&self) -> Option<Package> {
+        let prefix = self.as_str().strip_suffix("...")?;
+        // if it is foo// we need to keep the slash, if foo//bar/ we need to remove it
+        Some(Package::new(match prefix.strip_suffix('/') {
+            Some(x) if !x.ends_with('/') => x,
+            _ => prefix,
+        }))
+    }
+
     /// ```
     /// use btd::buck::types::TargetLabel;
     /// use btd::buck::types::TargetPattern;