DXA 1.7 Sprint 4

Author: rpannekoek

dxa-bom/pom.xml

@@ -45,8 +45,8 @@
     </developers>
 
     <properties>
-        <dd4t.version>2.1.2-DXA</dd4t.version>
-        <cd-cil.version>8.5.0-1005</cd-cil.version>
+        <dd4t.version>2.1.3-DXA17</dd4t.version>
+        <cd-cil.version>8.5.0-1007</cd-cil.version>
 
         <!-- DXA versions -->
         <dxa.version>${project.version}</dxa.version>

dxa-builder/build.gradle

@@ -54,12 +54,13 @@ artifacts {
 task signPom(type: Sign) {
     sign configurations.pom
 }
+signPom.enabled = isRelease
 
 task signJars(type: Sign, dependsOn: [jar, signPom, javadocJar, sourceJar]) {
     sign configurations.archives
 }
+signJars.enabled = isRelease
 task preparePublication(dependsOn: [signPom, signJars])
-preparePublication.enabled = isRelease
 
 task publishLocal(dependsOn: [build, publishToMavenLocal])
 task publishRemote(dependsOn: [build, preparePublication, publish])

dxa-builder/src/main/groovy/com/sdl/dxa/builder/configuration/parameters/Parameter.groovy

@@ -8,6 +8,8 @@ class Parameter {
     Validator validator
     String value
 
+    String versionAdded
+
     private boolean valid = false
 
     //region Builder methods
@@ -40,8 +42,23 @@ class Parameter {
         this.value = project && project.hasProperty(cliName) ? (project[cliName] as String).trim() : defaultValue
         this
     }
+
+    Parameter versionAdded(String version) {
+        this.versionAdded = version
+        this
+    }
     //endregion
 
+    boolean isSupportedInCurrentVersion(String currentVersion) {
+        if (!currentVersion || !versionAdded) {
+            return true
+        }
+        def normalize = { String version ->
+            Integer.parseInt(version.replaceAll(/[^\d]/, "").padRight(5, "0").substring(0, 5))
+        }
+        normalize(currentVersion) >= normalize(versionAdded)
+    }
+
     String process(boolean batch, Map<String, ?> configuration = [:]) {
         if (!this.value && this.dynamicDefault) {
             this.value = this.dynamicDefault(configuration)

dxa-builder/src/main/groovy/com/sdl/dxa/builder/configuration/parameters/Validator.groovy

@@ -74,10 +74,21 @@ class Validator {
         })
     }
 
-    static Validator domainName() {
-        new Validator(description: 'Should match a valid Domain Name', validate: { String it ->
+    static Validator domainName(boolean validWithPort = false) {
+        new Validator(description: "Should match a valid Domain Name ${validWithPort ? "with" : "without"} port", validate: { String it ->
+            def result = notEmpty().validate(it as String)
+
+            result &= !it.contains('://')
             it = removePath(it)
-            notEmpty().validate(it as String) && DomainValidator.getInstance(true).isValid(it as String)
+
+            if (validWithPort) {
+                if (it.contains(':')) {
+                    def arr = it.split(':')
+                    it = arr[0]
+                    result &= arr.length == 2 && intNumber().validate(arr[1])
+                }
+            }
+            result && DomainValidator.getInstance(true).isValid(it as String)
         })
     }
 

dxa-builder/src/test/groovy/com/sdl/dxa/builder/configuration/parameters/ValidatorTest.groovy

@@ -0,0 +1,58 @@
+package com.sdl.dxa.builder.configuration.parameters
+
+import org.junit.Assert
+import org.junit.Test
+
+class ValidatorTest {
+
+    @Test
+    void shouldValidateDomainNames() {
+        //given
+        def validator = Validator.domainName()
+
+        //when, then
+        Assert.assertTrue(validator.validate("sdl.com"))
+        Assert.assertTrue(validator.validate("sdl.com/path"))
+        Assert.assertTrue(validator.validate("toplevel.sdl.com"))
+        Assert.assertTrue(validator.validate("toplevel.sdl.com/path/test"))
+
+
+        Assert.assertFalse(validator.validate("http://sdl.com"))
+        Assert.assertFalse(validator.validate("http://sdl.com/path"))
+        Assert.assertFalse(validator.validate("sdl.com:8080"))
+        Assert.assertFalse(validator.validate("sdl.com:8080/[ath"))
+    }
+
+    @Test
+    void shouldValidateDomainNamesWithPort() {
+        //given
+        def validator = Validator.domainName(true)
+
+        //when, then
+        Assert.assertTrue(validator.validate("sdl.com"))
+        Assert.assertTrue(validator.validate("sdl.com/path"))
+        Assert.assertTrue(validator.validate("toplevel.sdl.com"))
+        Assert.assertTrue(validator.validate("toplevel.sdl.com/path/text"))
+        Assert.assertTrue(validator.validate("sdl.com:8080"))
+        Assert.assertTrue(validator.validate("sdl.com:8080/path"))
+
+
+        Assert.assertFalse(validator.validate("http://sdl.com"))
+        Assert.assertFalse(validator.validate("http://sdl.com/path"))
+        Assert.assertFalse(validator.validate("http://sdl.com:8080"))
+        Assert.assertFalse(validator.validate("http://sdl.com:8080/path"))
+        Assert.assertFalse(validator.validate("sdl.com:8080:80"))
+    }
+
+    @Test
+    void shouldValidateIPs() {
+        //given
+        def validator = Validator.ip()
+
+        //when, then
+        Assert.assertTrue(validator.validate("127.0.0.1"))
+
+        //then
+        Assert.assertFalse(validator.validate("http://sdl.com"))
+    }
+}

dxa-framework/dxa-common-api/src/main/java/com/sdl/webapp/common/api/mapping/semantic/config/EntitySemantics.java

@@ -13,12 +13,6 @@ public final class EntitySemantics {
 
     private final String entityName;
 
-    /**
-     * <p>Constructor for EntitySemantics.</p>
-     *
-     * @param vocabulary a {@link com.sdl.webapp.common.api.mapping.semantic.config.SemanticVocabulary} object.
-     * @param entityName a {@link java.lang.String} object.
-     */
     public EntitySemantics(SemanticVocabulary vocabulary, String entityName) {
         this.vocabulary = vocabulary;
         this.entityName = entityName;

dxa-framework/dxa-common-api/src/main/java/com/sdl/webapp/common/api/mapping/semantic/config/FieldPath.java

@@ -10,13 +10,9 @@
 public final class FieldPath {
 
     private final String head;
+
     private final FieldPath tail;
 
-    /**
-     * <p>Constructor for FieldPath.</p>
-     *
-     * @param path a {@link java.lang.String} object.
-     */
     public FieldPath(String path) {
         if (path.startsWith("/")) {
             path = path.substring(1);
@@ -35,4 +31,8 @@ public FieldPath(String path) {
     public boolean hasTail() {
         return tail != null;
     }
+
+    public boolean isMetadata() {
+        return "Metadata".equals(head);
+    }
 }

dxa-framework/dxa-common-api/src/main/java/com/sdl/webapp/common/api/mapping/semantic/config/FieldSemantics.java

@@ -17,13 +17,6 @@ public final class FieldSemantics {
 
     private final String propertyName;
 
-    /**
-     * <p>Constructor for FieldSemantics.</p>
-     *
-     * @param vocabulary   a {@link com.sdl.webapp.common.api.mapping.semantic.config.SemanticVocabulary} object.
-     * @param entityName   a {@link java.lang.String} object.
-     * @param propertyName a {@link java.lang.String} object.
-     */
     public FieldSemantics(SemanticVocabulary vocabulary, String entityName, String propertyName) {
         this.vocabulary = vocabulary;
         this.entityName = entityName;

dxa-framework/dxa-common-api/src/main/java/com/sdl/webapp/common/api/mapping/semantic/config/SemanticField.java

@@ -4,12 +4,18 @@
 import lombok.EqualsAndHashCode;
 import lombok.Getter;
 import lombok.ToString;
+import lombok.extern.slf4j.Slf4j;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 import java.util.Map;
 
+import static com.google.common.base.Strings.isNullOrEmpty;
+
 @Getter
 @ToString
 @EqualsAndHashCode
+@Slf4j
 public final class SemanticField {
 
     private final String name;
@@ -20,19 +26,45 @@ public final class SemanticField {
 
     private final Map<FieldSemantics, SemanticField> embeddedFields;
 
-    /**
-     * <p>Constructor for SemanticField.</p>
-     *
-     * @param name           a {@link java.lang.String} object.
-     * @param path           a {@link java.lang.String} object.
-     * @param multiValue     a boolean.
-     * @param embeddedFields a {@link java.util.Map} object.
-     */
     public SemanticField(String name, String path, boolean multiValue,
                          Map<FieldSemantics, SemanticField> embeddedFields) {
         this.name = name;
         this.path = new FieldPath(path);
         this.multiValue = multiValue;
         this.embeddedFields = ImmutableMap.copyOf(embeddedFields);
     }
+
+    /**
+     * Generates XPath for this semantic field respecting the context XPath and type of the field (metadata or content).
+     *
+     * @param contextXPath the current context XPath, optional, may be {@code null}
+     * @return generated XPath
+     */
+    @NotNull
+    public String getXPath(@Nullable String contextXPath) {
+        FieldPath pathCopy = path;
+
+        StringBuilder builder = new StringBuilder(pathCopy.isMetadata() ? "tcm:Metadata" : "tcm:Content");
+
+        while (true) {
+            builder.append("/custom:").append(pathCopy.getHead());
+            if (!pathCopy.hasTail()) {
+                break;
+            }
+            pathCopy = pathCopy.getTail();
+        }
+
+        String xPath = builder.toString();
+        String contextPathWithoutPredicate = null;
+        if (!isNullOrEmpty(contextXPath)) {
+            contextPathWithoutPredicate = contextXPath.split("\\[")[0];
+
+            if (!xPath.startsWith(contextPathWithoutPredicate)) {
+                // This should not happen, but if it happens, we just stick with the original XPath.
+                log.warn("Semantic field's XPath ('{}}') does not match context XPath '{}'.", xPath, contextXPath);
+            }
+        }
+
+        return contextPathWithoutPredicate == null ? xPath : xPath.replaceFirst(contextPathWithoutPredicate, contextXPath);
+    }
 }

dxa-framework/dxa-common-api/src/main/java/com/sdl/webapp/common/api/mapping/semantic/config/SemanticSchema.java

@@ -32,14 +32,6 @@ public final class SemanticSchema {
     @Setter
     private Localization localization;
 
-    /**
-     * <p>Constructor for SemanticSchema.</p>
-     *
-     * @param id              a long.
-     * @param rootElement     a {@link java.lang.String} object.
-     * @param entitySemantics a {@link java.util.Set} object.
-     * @param semanticFields  a {@link java.util.Map} object.
-     */
     public SemanticSchema(long id, String rootElement, Set<EntitySemantics> entitySemantics,
                           Map<FieldSemantics, SemanticField> semanticFields) {
         this.id = id;