feat: Determine SCM and parse clone url in GitProvenance for more accurate path/origin/organiation/groups

rewrite-core/src/main/java/org/openrewrite/marker/GitProvenance.java

@@ -16,6 +16,7 @@
 package org.openrewrite.marker;
 
 
+import lombok.AllArgsConstructor;
 import lombok.Value;
 import lombok.With;
 import org.openrewrite.Incubating;
@@ -30,6 +31,7 @@
 import org.openrewrite.marker.ci.BuildEnvironment;
 import org.openrewrite.marker.ci.IncompleteGitConfigException;
 import org.openrewrite.marker.ci.JenkinsBuildEnvironment;
+import org.openrewrite.scm.*;
 
 import java.io.File;
 import java.io.IOException;
@@ -45,9 +47,21 @@
 
 @Value
 @With
+@AllArgsConstructor
 public class GitProvenance implements Marker {
+    private static final Set<Scm> KNOWN_SCMS = new LinkedHashSet<>(Arrays.asList(
+            new SimpleScm("github.com"),
+            new SimpleScm("bitbucket.org"),
+            new GroupPathScm("gitlab.com"),
+            new AzureDevOpsScm()
+    ));
+
     UUID id;
 
+    /**
+     * The URL of the origin remote, not to be confused with the SCM origin
+     * which can be found under scmUrlComponents.getOrigin() which contains the base url to the SCM server
+     */
     @Nullable
     String origin;
 
@@ -67,14 +81,34 @@ public class GitProvenance implements Marker {
     @Incubating(since = "8.9.0")
     List<Committer> committers;
 
+    @Incubating(since = "8.33.0")
+    @Nullable
+    ScmUrlComponents scmUrlComponents;
+
+    public GitProvenance(UUID id, @Nullable String origin, @Nullable String branch, @Nullable String change, @Nullable AutoCRLF autocrlf, @Nullable EOL eol, @Nullable List<Committer> committers) {
+        this.id = id;
+        this.origin = origin;
+        this.branch = branch;
+        this.change = change;
+        this.autocrlf = autocrlf;
+        this.eol = eol;
+        this.committers = committers;
+        scmUrlComponents = determineScmUrlComponents(origin);
+    }
+
     /**
      * Extract the organization name, including sub-organizations for git hosting services which support such a concept,
      * from the origin URL. Needs to be supplied with the
      *
      * @param baseUrl the portion of the URL which precedes the organization
      * @return the portion of the git origin URL which corresponds to the organization the git repository is organized under
+     * @deprecated use {@link #getScmUrlComponents().getOrganization()} instead }
      */
+    @Deprecated
     public @Nullable String getOrganizationName(String baseUrl) {
+        if (scmUrlComponents != null) {
+            return scmUrlComponents.getOrganization();
+        }
         if (origin == null) {
             return null;
         }
@@ -102,6 +136,9 @@ public class GitProvenance implements Marker {
      */
     @Deprecated
     public @Nullable String getOrganizationName() {
+        if (scmUrlComponents != null) {
+            return scmUrlComponents.getOrganization();
+        }
         if (origin == null) {
             return null;
         }
@@ -206,9 +243,10 @@ private static GitProvenance fromGitConfig(Repository repository, @Nullable Stri
         if (branch == null) {
             branch = resolveBranchFromGitConfig(repository);
         }
-        return new GitProvenance(randomId(), getOrigin(repository), branch, changeset,
+        String remoteOriginUrl = getRemoteOriginUrl(repository);
+        return new GitProvenance(randomId(), remoteOriginUrl, branch, changeset,
                 getAutocrlf(repository), getEOF(repository),
-                getCommitters(repository));
+                getCommitters(repository), determineScmUrlComponents(remoteOriginUrl));
     }
 
     static @Nullable String resolveBranchFromGitConfig(Repository repository) {
@@ -268,7 +306,7 @@ private static GitProvenance fromGitConfig(Repository repository, @Nullable Stri
         return branch;
     }
 
-    private static @Nullable String getOrigin(Repository repository) {
+    private static @Nullable String getRemoteOriginUrl(Repository repository) {
         Config storedConfig = repository.getConfig();
         String url = storedConfig.getString("remote", "origin", "url");
         if (url == null) {
@@ -354,6 +392,27 @@ private static String hideSensitiveInformation(String url) {
         return url;
     }
 
+    public static void registerScm(Scm scm) {
+        KNOWN_SCMS.add(scm);
+    }
+
+    @Nullable
+    public static ScmUrlComponents determineScmUrlComponents(@Nullable String cloneUrl) {
+        if (cloneUrl == null) {
+            return null;
+        }
+        Scm selected = null;
+        for (Scm scm : KNOWN_SCMS) {
+            if (scm.belongsToScm(cloneUrl)) {
+                selected = scm;
+            }
+        }
+        if (selected == null) {
+            selected = new UnknownScm(cloneUrl);
+        }
+        return selected.determineScmUrlComponents(cloneUrl);
+    }
+
     public enum AutoCRLF {
         False,
         True,
@@ -373,4 +432,5 @@ public static class Committer {
         String email;
         NavigableMap<LocalDate, Integer> commitsByDay;
     }
+
 }

rewrite-core/src/main/java/org/openrewrite/scm/AzureDevOpsScm.java

@@ -0,0 +1,38 @@
+package org.openrewrite.scm;
+
+import org.openrewrite.internal.lang.Nullable;
+
+public class AzureDevOpsScm implements Scm {
+
+    @Override
+    public String getOrigin() {
+        return "dev.azure.com";
+    }
+
+    @Override
+    public String cleanHostAndPath(String url) {
+        UrlComponents uri = UrlComponents.parse(url);
+        String host = uri.getHost();
+        String path = uri.getPath();
+        if (uri.isSsh() && host.startsWith("ssh.")) {
+            host = host.substring(4);
+            path = path.replaceFirst("v3/", "");
+        } else {
+            path = path.replaceFirst("_git/", "");
+        }
+        String hostAndPath = host + "/" + path
+                .replaceFirst("\\.git$", "");
+        return hostAndPath.replaceFirst("/$", "");
+    }
+
+    @Override
+    public String determineRepositoryName(String path) {
+        return path.substring(path.lastIndexOf("/") + 1);
+    }
+
+    @Nullable
+    @Override
+    public String determineProject(String path) {
+        return path.substring(path.indexOf("/") + 1, path.lastIndexOf("/"));
+    }
+}

rewrite-core/src/main/java/org/openrewrite/scm/BitbucketServerScm.java

@@ -0,0 +1,25 @@
+package org.openrewrite.scm;
+
+import lombok.Getter;
+
+@Getter
+public class BitbucketServerScm implements Scm {
+    private final String origin;
+
+    public BitbucketServerScm(String origin) {
+        if (origin.startsWith("ssh://") || origin.startsWith("http://") || origin.startsWith("https://")) {
+            origin = cleanHostAndPath(origin);
+        }
+        this.origin = origin;
+    }
+
+    @Override
+    public String cleanHostAndPath(String url) {
+        UrlComponents uri = UrlComponents.parse(url);
+        String hostAndPath = uri.getHost() + uri.maybePort() + "/" + uri.getPath()
+                .replaceFirst("^/", "")
+                .replaceFirst("scm/", "")
+                .replaceFirst("\\.git$", "");
+        return hostAndPath.replaceFirst("/$", "");
+    }
+}

rewrite-core/src/main/java/org/openrewrite/scm/GroupPathScm.java

@@ -0,0 +1,38 @@
+package org.openrewrite.scm;
+
+import lombok.Getter;
+import org.openrewrite.internal.lang.Nullable;
+
+/**
+ * Can be used for GitLab
+ */
+@Getter
+public class GroupPathScm implements Scm {
+    private final String origin;
+
+    public GroupPathScm(String origin) {
+        if (origin.startsWith("ssh://") || origin.startsWith("http://") || origin.startsWith("https://")) {
+            origin = cleanHostAndPath(origin);
+        }
+        this.origin = origin.replaceFirst("/$", "");
+    }
+
+    @Override
+    public @Nullable String determineGroupPath(String path) {
+        return path.substring(0, path.lastIndexOf("/"));
+    }
+
+    @Override
+    public String determineRepositoryName(String path) {
+        return path.substring(path.lastIndexOf("/") + 1);
+    }
+
+    @Override
+    public String cleanHostAndPath(String url) {
+        UrlComponents uri = UrlComponents.parse(url);
+        String hostAndPath = uri.getHost() + uri.maybePort() + "/" + uri.getPath()
+                .replaceFirst("^/", "")
+                .replaceFirst("\\.git$", "");
+        return hostAndPath.replaceFirst("/$", "");
+    }
+}

rewrite-core/src/main/java/org/openrewrite/scm/Scm.java

@@ -0,0 +1,43 @@
+package org.openrewrite.scm;
+
+import org.openrewrite.internal.lang.Nullable;
+
+public interface Scm extends Comparable<Scm> {
+    String getOrigin();
+
+    String cleanHostAndPath(String cloneUrl);
+
+    default boolean belongsToScm(String cloneUrl) {
+        return cleanHostAndPath(cloneUrl).startsWith(getOrigin());
+    }
+
+    @Nullable
+    default String determineOrganization(String path) {
+        return path.substring(0, path.indexOf("/"));
+    }
+
+    @Nullable
+    default String determineGroupPath(String path) {
+        return null;
+    }
+
+    @Nullable
+    default String determineProject(String path) {
+        return null;
+    }
+
+    default String determineRepositoryName(String path) {
+        return path.substring(path.indexOf("/") + 1);
+    }
+
+    default ScmUrlComponents determineScmUrlComponents(String cloneUrl) {
+        String path = cleanHostAndPath(cloneUrl).substring(getOrigin().length() + 1);
+        return new ScmUrlComponents(getOrigin(), determineOrganization(path), determineGroupPath(path), determineProject(path), determineRepositoryName(path));
+    }
+
+    @Override
+    default int compareTo(Scm o) {
+        return getOrigin().compareTo(o.getOrigin());
+    }
+
+}

rewrite-core/src/main/java/org/openrewrite/scm/ScmUrlComponents.java

@@ -0,0 +1,37 @@
+package org.openrewrite.scm;
+
+import lombok.Builder;
+import lombok.Value;
+import org.openrewrite.internal.lang.Nullable;
+
+@Value
+@Builder
+public class ScmUrlComponents {
+
+    @Nullable
+    String origin;
+
+    @Nullable
+    String organization;
+
+    @Nullable
+    String groupPath;
+
+    @Nullable
+    String project;
+
+    String repositoryName;
+
+    public String getPath() {
+        if (groupPath != null) {
+            return groupPath + "/" + repositoryName;
+        }
+        if (organization != null) {
+            if (project != null) {
+                return organization + "/" + project + "/" + repositoryName;
+            }
+            return organization + "/" + repositoryName;
+        }
+        return repositoryName;
+    }
+}

rewrite-core/src/main/java/org/openrewrite/scm/SimpleScm.java

@@ -0,0 +1,27 @@
+package org.openrewrite.scm;
+
+import lombok.Getter;
+
+/**
+ * Simple as in just split by origin/path, and where the path is organization/repositoryName, like GitHub
+ */
+@Getter
+public class SimpleScm implements Scm {
+    private final String origin;
+
+    public SimpleScm(String origin) {
+        if (origin.startsWith("ssh://") || origin.startsWith("http://") || origin.startsWith("https://")) {
+            origin = cleanHostAndPath(origin);
+        }
+        this.origin = origin.replaceFirst("/$", "");
+    }
+
+    @Override
+    public String cleanHostAndPath(String url) {
+        UrlComponents uri = UrlComponents.parse(url);
+        String hostAndPath = uri.getHost() + uri.maybePort() + "/" + uri.getPath()
+                .replaceFirst("^/", "")
+                .replaceFirst("\\.git$", "");
+        return hostAndPath.replaceFirst("/$", "");
+    }
+}

rewrite-core/src/main/java/org/openrewrite/scm/UnknownScm.java

@@ -0,0 +1,30 @@
+package org.openrewrite.scm;
+
+import lombok.Getter;
+
+import java.util.Arrays;
+
+/**
+ * Fallback that assumes the last 2 path segments of a cloneUrl contains the repository path, not the same as SimpleScm
+ * which splits on a known origin.
+ */
+@Getter
+public class UnknownScm extends SimpleScm {
+    public UnknownScm(String cloneUrl) {
+        super(cloneUrlToOrigin(cloneUrl));
+    }
+
+    private static String cloneUrlToOrigin(String cloneUrl) {
+        UrlComponents uri = UrlComponents.parse(cloneUrl);
+        String fullPath = uri.getPath()
+                .replaceFirst("^/", "")
+                .replaceFirst("\\.git$", "");
+
+        String[] segments = fullPath.split("/");
+        if (segments.length <= 2) {
+            return uri.getHost() + uri.maybePort();
+        }
+        String contextPath = String.join("/", Arrays.copyOfRange(segments, 0, segments.length - 2));
+        return uri.getHost() + uri.maybePort() + "/" + contextPath;
+    }
+}