Add support for parsing subdirectories out of git URLs

src/v2/context.in.rs

@@ -32,6 +32,21 @@ impl Context {
             Context::Dir(Path::new(&s_ref).to_owned())
         }
     }
+
+    /// Determines if two Contexts are equivalent. This is only true
+    /// if they are the same directory path, or if they are same git
+    /// repository and branch. Subdirectories of a repository may differ
+    pub fn is_equivalent_to(&self, other: &Context) -> bool {
+        match (self, other) {
+            (&Context::Dir(_), &Context::GitUrl(_)) => false,
+            (&Context::GitUrl(_), &Context::Dir(_)) => false,
+            (&Context::Dir(ref dir_1), &Context::Dir(ref dir_2)) => dir_1 == dir_2,
+            (&Context::GitUrl(ref git_url_1), &Context::GitUrl(ref git_url_2)) => {
+                git_url_1.repository() == git_url_2.repository() &&
+                    git_url_1.branch() == git_url_2.branch()
+            },
+        }
+    }
 }
 
 impl_interpolatable_value!(Context);
@@ -80,3 +95,32 @@ fn context_may_contain_dir_paths() {
         assert_eq!(context.to_string(), path);
     }
 }
+
+#[test]
+fn is_equivalent_if_they_are_the_same_dir_or_the_same_repo_and_branch() {
+    let dir_1: Context = FromStr::from_str("./foo").unwrap();
+    let dir_2: Context = FromStr::from_str("./bar").unwrap();
+
+    let plain_repo: Context = FromStr::from_str("[email protected]:docker/docker.git").unwrap();
+    let repo_with_branch: Context = FromStr::from_str("[email protected]:docker/docker.git#somebranch").unwrap();
+    let repo_with_subdir: Context = FromStr::from_str("[email protected]:docker/docker.git#:somedir").unwrap();
+    let repo_with_branch_and_subdir: Context = FromStr::from_str("[email protected]:docker/docker.git#somebranch:somedir").unwrap();
+
+    let different_repo: Context = FromStr::from_str("[email protected]:docker/compose.git").unwrap();
+
+    assert!(dir_1.is_equivalent_to(&dir_1));
+    assert!(!dir_1.is_equivalent_to(&dir_2));
+    assert!(!dir_1.is_equivalent_to(&plain_repo));
+
+    assert!(plain_repo.is_equivalent_to(&plain_repo));
+    assert!(plain_repo.is_equivalent_to(&repo_with_subdir));
+
+    assert!(!plain_repo.is_equivalent_to(&dir_1));
+    assert!(!plain_repo.is_equivalent_to(&different_repo));
+    assert!(!plain_repo.is_equivalent_to(&repo_with_branch));
+    assert!(!plain_repo.is_equivalent_to(&repo_with_branch_and_subdir));
+
+    assert!(repo_with_branch.is_equivalent_to(&repo_with_branch));
+    assert!(repo_with_branch.is_equivalent_to(&repo_with_branch_and_subdir));
+    assert!(!repo_with_branch.is_equivalent_to(&plain_repo));
+}

src/v2/git_url.rs

@@ -71,6 +71,34 @@ impl GitUrl {
             }
         }
     }
+
+    /// Extract the repository part of the URL
+    pub fn repository(&self) -> String {
+        lazy_static! {
+            static ref REPO_PARSE: Regex = Regex::new(r#"([^#]*)"#).unwrap();
+        }
+        REPO_PARSE.captures(&self.url).unwrap().at(1).unwrap().to_string()
+    }
+
+    /// Extract the optional branch part of the git URL
+    pub fn branch(&self) -> Option<String> {
+        lazy_static! {
+            static ref BRANCH_PARSE: Regex = Regex::new(r#".*#([^:]+)"#).unwrap();
+        }
+        BRANCH_PARSE.captures(&self.url).map(
+            |captures| captures.at(1).unwrap().to_string()
+        )
+    }
+
+    /// Extract the optional subdirectory part of the git URL
+    pub fn subdirectory(&self) -> Option<String> {
+        lazy_static! {
+            static ref SUBDIR_PARSE: Regex = Regex::new(r#".*#.*:(.+)"#).unwrap();
+        }
+        SUBDIR_PARSE.captures(&self.url).map(
+            |captures| captures.at(1).unwrap().to_string()
+        )
+    }
 }
 
 impl fmt::Display for GitUrl {
@@ -134,3 +162,39 @@ fn to_url_converts_git_urls_to_real_ones() {
         assert!(GitUrl::new(url).is_err());
     }
 }
+
+#[test]
+fn it_can_extract_its_repo_branch_and_subdir_parts() {
+    let urls = &[
+        "git://github.com/docker/docker",
+        "https://github.com/docker/docker.git",
+        "http://github.com/docker/docker.git",
+        "[email protected]:docker/docker.git",
+        "[email protected]:atlassianlabs/atlassian-docker.git",
+        "github.com/docker/docker.git",
+    ];
+
+    // Refs/folders specified as per:
+    // https://docs.docker.com/engine/reference/commandline/build/#git-repositories
+    for &url in urls {
+        let plain = GitUrl::new(format!("{}{}", url, "")).unwrap();
+        assert_eq!(plain.repository(), url);
+        assert_eq!(plain.branch(), None);
+        assert_eq!(plain.subdirectory(), None);
+
+        let with_ref = GitUrl::new(format!("{}{}", url, "#mybranch")).unwrap();
+        assert_eq!(with_ref.repository(), url);
+        assert_eq!(with_ref.branch(), Some("mybranch".to_string()));
+        assert_eq!(with_ref.subdirectory(), None);
+
+        let with_subdir = GitUrl::new(format!("{}{}", url, "#:myfolder")).unwrap();
+        assert_eq!(with_subdir.repository(), url);
+        assert_eq!(with_subdir.branch(), None);
+        assert_eq!(with_subdir.subdirectory(), Some("myfolder".to_string()));
+
+        let with_ref_and_subdir = GitUrl::new(format!("{}{}", url, "#mybranch:myfolder")).unwrap();
+        assert_eq!(with_ref_and_subdir.repository(), url);
+        assert_eq!(with_ref_and_subdir.branch(), Some("mybranch".to_string()));
+        assert_eq!(with_ref_and_subdir.subdirectory(), Some("myfolder".to_string()));
+    }
+}