A better simple duplication detection.

Fix snapshot publishing.

Author: Andreas Rossbacher

deeplinkdispatch-base/src/main/java/com/airbnb/deeplinkdispatch/DeepLinkEntry.kt

@@ -148,7 +148,84 @@ sealed class DeepLinkEntry(
         result
     }
 
-    fun templatesMatchesSameUrls(other: DeepLinkEntry) = uriTemplateWithoutPlaceholders == other.uriTemplateWithoutPlaceholders
+    /**
+     * Determines if two URI templates could potentially match the same URLs.
+     *
+     * This method checks:
+     * 1. For placeholders with allowed values (e.g., {type(a|b)}): expands all possible values
+     *    and checks if any could create a match with the other template
+     * 2. For regular placeholders (without allowed values): uses regex matching since
+     *    "..*" (the placeholder replacement) can match any non-empty string
+     *
+     * Note: Configurable path segments (<name>) are ignored as they have the same replacement
+     * value within the same app.
+     *
+     * @return true if the templates could potentially match the same URLs
+     */
+    fun templatesMatchesSameUrls(other: DeepLinkEntry): Boolean {
+        // Get all possible expanded values for both templates
+        // This expands placeholders with allowed values to all their possible concrete forms
+        // Regular placeholders (without allowed values) are replaced with "..*"
+        val thisExpanded = uriTemplate.allPossibleValues()
+        val otherExpanded = other.uriTemplate.allPossibleValues()
+
+        // Check if any pair of expanded values could match
+        for (thisValue in thisExpanded) {
+            for (otherValue in otherExpanded) {
+                if (expandedTemplatesCouldMatch(thisValue, otherValue)) {
+                    return true
+                }
+            }
+        }
+
+        return false
+    }
+
+    /**
+     * Checks if two expanded template values could match the same URL.
+     *
+     * After expansion by allPossibleValues():
+     * - Placeholders with allowed values have been replaced with each allowed value
+     * - Regular placeholders have been replaced with "..*" (matches one or more chars)
+     *
+     * We use "..*" as a regex pattern - it already means "any char followed by zero or more chars"
+     * which effectively matches one or more characters.
+     */
+    private fun expandedTemplatesCouldMatch(template1: String, template2: String): Boolean {
+        // If identical (including both having same wildcards), they match
+        if (template1 == template2) {
+            return true
+        }
+
+        // Convert template1 to regex (escape special chars, keep ..*) and check if template2 matches
+        if (templateMatchesAsRegex(template1, template2)) {
+            return true
+        }
+
+        // Also check reverse - template2 as regex against template1
+        if (templateMatchesAsRegex(template2, template1)) {
+            return true
+        }
+
+        return false
+    }
+
+    /**
+     * Converts a template with "..*" wildcards to a regex and checks if the other template matches.
+     */
+    private fun templateMatchesAsRegex(templateWithWildcards: String, templateToMatch: String): Boolean {
+        // If no wildcards, simple equality (already checked in caller)
+        if (!templateWithWildcards.contains(SIMPLE_GLOB_PATTERN_MIN_ONE_CHAR)) {
+            return templateWithWildcards == templateToMatch
+        }
+
+        // Build regex: escape everything except "..*" which becomes ".+" (one or more chars)
+        val regexPattern = templateWithWildcards
+            .split(SIMPLE_GLOB_PATTERN_MIN_ONE_CHAR)
+            .joinToString(".+") { Regex.escape(it) }
+
+        return Regex("^$regexPattern$").matches(templateToMatch)
+    }
 
     /**
      * Compares two DeepLinkEntry instances by their concreteness (specificity).

deeplinkdispatch/src/test/java/com/airbnb/deeplinkdispatch/DeepLinkEntryTest.kt

@@ -492,6 +492,128 @@ class DeepLinkEntryTest {
         assertThat(placeholderFirstEntry.compareTo(configurableFirstEntry)).isGreaterThan(0)
     }
 
+    // ============== templatesMatchesSameUrls tests ==============
+
+    @Test
+    fun `templatesMatchesSameUrls returns true for identical templates`() {
+        val entry1 = activityDeepLinkEntry("airbnb://host/path")
+        val entry2 = activityDeepLinkEntry("airbnb://host/path")
+        assertThat(entry1.templatesMatchesSameUrls(entry2)).isTrue
+    }
+
+    @Test
+    fun `templatesMatchesSameUrls returns false for completely different templates`() {
+        val entry1 = activityDeepLinkEntry("airbnb://host/path1")
+        val entry2 = activityDeepLinkEntry("airbnb://host/path2")
+        assertThat(entry1.templatesMatchesSameUrls(entry2)).isFalse
+    }
+
+    @Test
+    fun `templatesMatchesSameUrls returns true for templates with same placeholders`() {
+        val entry1 = activityDeepLinkEntry("airbnb://host/{id}")
+        val entry2 = activityDeepLinkEntry("airbnb://host/{param}")
+        assertThat(entry1.templatesMatchesSameUrls(entry2)).isTrue
+    }
+
+    @Test
+    fun `templatesMatchesSameUrls returns true when placeholder matches concrete value`() {
+        // A placeholder can match any value, so it could match "path"
+        val entryWithPlaceholder = activityDeepLinkEntry("airbnb://host/{id}")
+        val entryWithConcrete = activityDeepLinkEntry("airbnb://host/path")
+        assertThat(entryWithPlaceholder.templatesMatchesSameUrls(entryWithConcrete)).isTrue
+        assertThat(entryWithConcrete.templatesMatchesSameUrls(entryWithPlaceholder)).isTrue
+    }
+
+    @Test
+    fun `templatesMatchesSameUrls returns true when allowed value matches concrete value`() {
+        // Placeholder with allowed values (a|b) - "a" matches concrete "a"
+        val entryWithAllowedValues = activityDeepLinkEntry("airbnb://host/{type(a|b)}")
+        val entryWithConcrete = activityDeepLinkEntry("airbnb://host/a")
+        assertThat(entryWithAllowedValues.templatesMatchesSameUrls(entryWithConcrete)).isTrue
+        assertThat(entryWithConcrete.templatesMatchesSameUrls(entryWithAllowedValues)).isTrue
+    }
+
+    @Test
+    fun `templatesMatchesSameUrls returns false when no allowed value matches concrete value`() {
+        // Placeholder with allowed values (a|b) - neither matches concrete "c"
+        val entryWithAllowedValues = activityDeepLinkEntry("airbnb://host/{type(a|b)}")
+        val entryWithConcrete = activityDeepLinkEntry("airbnb://host/c")
+        assertThat(entryWithAllowedValues.templatesMatchesSameUrls(entryWithConcrete)).isFalse
+        assertThat(entryWithConcrete.templatesMatchesSameUrls(entryWithAllowedValues)).isFalse
+    }
+
+    @Test
+    fun `templatesMatchesSameUrls returns true when allowed values overlap`() {
+        // Both have allowed values with "b" in common
+        val entry1 = activityDeepLinkEntry("airbnb://host/{type1(a|b)}")
+        val entry2 = activityDeepLinkEntry("airbnb://host/{type2(b|c)}")
+        assertThat(entry1.templatesMatchesSameUrls(entry2)).isTrue
+    }
+
+    @Test
+    fun `templatesMatchesSameUrls returns false when allowed values dont overlap`() {
+        // No common allowed values
+        val entry1 = activityDeepLinkEntry("airbnb://host/{type1(a|b)}")
+        val entry2 = activityDeepLinkEntry("airbnb://host/{type2(c|d)}")
+        assertThat(entry1.templatesMatchesSameUrls(entry2)).isFalse
+    }
+
+    @Test
+    fun `templatesMatchesSameUrls returns true when placeholder could match allowed value`() {
+        // Regular placeholder can match any value including "a" or "b"
+        val entryWithPlaceholder = activityDeepLinkEntry("airbnb://host/{id}")
+        val entryWithAllowedValues = activityDeepLinkEntry("airbnb://host/{type(a|b)}")
+        assertThat(entryWithPlaceholder.templatesMatchesSameUrls(entryWithAllowedValues)).isTrue
+        assertThat(entryWithAllowedValues.templatesMatchesSameUrls(entryWithPlaceholder)).isTrue
+    }
+
+    @Test
+    fun `templatesMatchesSameUrls handles partial placeholders with same prefix`() {
+        // Both have "pre" prefix, placeholder can match
+        val entry1 = activityDeepLinkEntry("airbnb://host/pre{id}post")
+        val entry2 = activityDeepLinkEntry("airbnb://host/pre{name}post")
+        assertThat(entry1.templatesMatchesSameUrls(entry2)).isTrue
+    }
+
+    @Test
+    fun `templatesMatchesSameUrls returns false for partial placeholders with different prefix`() {
+        val entry1 = activityDeepLinkEntry("airbnb://host/pre{id}post")
+        val entry2 = activityDeepLinkEntry("airbnb://host/other{name}post")
+        assertThat(entry1.templatesMatchesSameUrls(entry2)).isFalse
+    }
+
+    @Test
+    fun `templatesMatchesSameUrls returns false for different number of path segments`() {
+        val entry1 = activityDeepLinkEntry("airbnb://host/path1/path2")
+        val entry2 = activityDeepLinkEntry("airbnb://host/path1")
+        assertThat(entry1.templatesMatchesSameUrls(entry2)).isFalse
+    }
+
+    @Test
+    fun `templatesMatchesSameUrls handles complex scheme placeholders`() {
+        // http{s} scheme placeholder - "http" matches "http", "https" matches "https"
+        val entry1 = activityDeepLinkEntry("http{scheme(|s)}://host/path")
+        val entry2 = activityDeepLinkEntry("http://host/path")
+        assertThat(entry1.templatesMatchesSameUrls(entry2)).isTrue
+
+        val entry3 = activityDeepLinkEntry("https://host/path")
+        assertThat(entry1.templatesMatchesSameUrls(entry3)).isTrue
+    }
+
+    @Test
+    fun `templatesMatchesSameUrls handles host placeholders with allowed values`() {
+        // Host with allowed prefixes
+        val entry1 = activityDeepLinkEntry("http://{prefix(|www.)}airbnb.com/path")
+        val entry2 = activityDeepLinkEntry("http://airbnb.com/path")
+        assertThat(entry1.templatesMatchesSameUrls(entry2)).isTrue
+
+        val entry3 = activityDeepLinkEntry("http://www.airbnb.com/path")
+        assertThat(entry1.templatesMatchesSameUrls(entry3)).isTrue
+
+        val entry4 = activityDeepLinkEntry("http://m.airbnb.com/path")
+        assertThat(entry1.templatesMatchesSameUrls(entry4)).isFalse
+    }
+
     companion object {
         private fun activityDeepLinkEntry(
             uriTemplate: String,

publishing.gradle

@@ -9,8 +9,11 @@ publishing {
         maven {
             // The "name" value creates a task like `publishAllPublicationsTo[Name]Repository
             // In this case, publishAllPublicationsToAirbnbArtifactoryRepository
+            def versionName = findProperty("VERSION_NAME") ?: version.toString()
             name = 'airbnbArtifactory'
-            url = version.toString().endsWith("SNAPSHOT") ? findProperty("ARTIFACTORY_SNAPSHOT_URL") : findProperty("ARTIFACTORY_RELEASE_URL")
+            // Use VERSION_NAME directly since 'version' may not be set at configuration time
+            // with newer versions of gradle-maven-publish-plugin
+            url = versionName.endsWith("SNAPSHOT") ? findProperty("ARTIFACTORY_SNAPSHOT_URL") : findProperty("ARTIFACTORY_RELEASE_URL")
             credentials {
                 username = findProperty("ARTIFACTORY_USERNAME")
                 password = findProperty("ARTIFACTORY_PASSWORD")