make elements printable

sebastian-toepfer · Nov 16, 2023 · 32a195e · 32a195e
1 parent d43eb10
commit 32a195e
Show file tree

Hide file tree

Showing 30 changed files with 569 additions and 78 deletions.
diff --git a/vocabulary-format-assertion/pom.xml b/vocabulary-format-assertion/pom.xml
@@ -14,12 +14,26 @@
     <artifactId>json-schema-vocabulary-format-assertion</artifactId>
     <name>Json Schema :: vocabulary :: format assertion</name>
 
+    <properties>
+        <ddd.verison>0.4.0</ddd.verison>
+    </properties>
+
     <dependencies>
         <dependency>
             <groupId>${project.groupId}</groupId>
             <artifactId>json-schema-vocabulary-spi</artifactId>
             <version>${project.version}</version>
         </dependency>
+        <dependency>
+            <groupId>io.github.sebastian-toepfer.ddd</groupId>
+            <artifactId>common</artifactId>
+            <version>${ddd.verison}</version>
+        </dependency>
+        <dependency>
+            <groupId>io.github.sebastian-toepfer.ddd</groupId>
+            <artifactId>media-core</artifactId>
+            <version>${ddd.verison}</version>
+        </dependency>
 
         <dependency>
             <groupId>org.junit.jupiter</groupId>

diff --git a/...ava/io/github/sebastiantoepfer/jsonschema/vocabulary/format/assertion/abnf/CoreRules.java b/...ava/io/github/sebastiantoepfer/jsonschema/vocabulary/format/assertion/abnf/CoreRules.java
@@ -23,134 +23,155 @@
  */
 package io.github.sebastiantoepfer.jsonschema.vocabulary.format.assertion.abnf;
 
+import io.github.sebastiantoepfer.ddd.common.Media;
 import io.github.sebastiantoepfer.jsonschema.vocabulary.format.assertion.abnf.element.Alternative;
+import io.github.sebastiantoepfer.jsonschema.vocabulary.format.assertion.abnf.element.Concatenation;
 import io.github.sebastiantoepfer.jsonschema.vocabulary.format.assertion.abnf.element.Element;
 import io.github.sebastiantoepfer.jsonschema.vocabulary.format.assertion.abnf.element.NumericCharacter;
 import io.github.sebastiantoepfer.jsonschema.vocabulary.format.assertion.abnf.element.RuleName;
+import io.github.sebastiantoepfer.jsonschema.vocabulary.format.assertion.abnf.element.RuleReference;
+import io.github.sebastiantoepfer.jsonschema.vocabulary.format.assertion.abnf.element.SequenceGroup;
 import io.github.sebastiantoepfer.jsonschema.vocabulary.format.assertion.abnf.element.StringElement;
 import io.github.sebastiantoepfer.jsonschema.vocabulary.format.assertion.abnf.element.ValueRangeAlternatives;
+import io.github.sebastiantoepfer.jsonschema.vocabulary.format.assertion.abnf.element.VariableRepetition;
 
 public enum CoreRules implements Element {
     ALPHA() {
         @Override
-        public boolean isValidFor(final int codePoint) {
-            return Alternative
-                .of(
-                    ValueRangeAlternatives.of(
-                        NumericCharacter.of(NumericCharacter.BASE.HEXADECIMAL, 0x41),
-                        NumericCharacter.of(NumericCharacter.BASE.HEXADECIMAL, 0x5A)
-                    ),
-                    ValueRangeAlternatives.of(
-                        NumericCharacter.of(NumericCharacter.BASE.HEXADECIMAL, 0x61),
-                        NumericCharacter.of(NumericCharacter.BASE.HEXADECIMAL, 0x7A)
-                    )
+        Element definition() {
+            return Alternative.of(
+                ValueRangeAlternatives.of(
+                    NumericCharacter.of(NumericCharacter.BASE.HEXADECIMAL, 0x41),
+                    NumericCharacter.of(NumericCharacter.BASE.HEXADECIMAL, 0x5A)
+                ),
+                ValueRangeAlternatives.of(
+                    NumericCharacter.of(NumericCharacter.BASE.HEXADECIMAL, 0x61),
+                    NumericCharacter.of(NumericCharacter.BASE.HEXADECIMAL, 0x7A)
                 )
-                .isValidFor(codePoint);
+            );
         }
     },
     BIT() {
         @Override
-        public boolean isValidFor(final int codePoint) {
-            return Alternative.of(StringElement.of("0"), StringElement.of("1")).isValidFor(codePoint);
+        Element definition() {
+            return Alternative.of(StringElement.of("0"), StringElement.of("1"));
         }
     },
     CHAR() {
         @Override
-        public boolean isValidFor(final int codePoint) {
-            return ValueRangeAlternatives
-                .of(
-                    NumericCharacter.of(NumericCharacter.BASE.HEXADECIMAL, 0x01),
-                    NumericCharacter.of(NumericCharacter.BASE.HEXADECIMAL, 0x7F)
-                )
-                .isValidFor(codePoint);
+        Element definition() {
+            return ValueRangeAlternatives.of(
+                NumericCharacter.of(NumericCharacter.BASE.HEXADECIMAL, 0x01),
+                NumericCharacter.of(NumericCharacter.BASE.HEXADECIMAL, 0x7F)
+            );
         }
     },
     CR() {
         @Override
-        public boolean isValidFor(final int codePoint) {
-            return NumericCharacter.of(NumericCharacter.BASE.HEXADECIMAL, 0x0D).isValidFor(codePoint);
+        Element definition() {
+            return NumericCharacter.of(NumericCharacter.BASE.HEXADECIMAL, 0x0D);
+        }
+    },
+    CRLF() {
+        @Override
+        Element definition() {
+            return Concatenation.of(RuleReference.of(CR.asRuleName()), RuleReference.of(LF.asRuleName()));
+        }
+    },
+    CTL() {
+        @Override
+        Element definition() {
+            return Alternative.of(
+                ValueRangeAlternatives.of(
+                    NumericCharacter.of(NumericCharacter.BASE.HEXADECIMAL, 0x00),
+                    NumericCharacter.of(NumericCharacter.BASE.HEXADECIMAL, 0x1F)
+                ),
+                NumericCharacter.of(NumericCharacter.BASE.HEXADECIMAL, 0x7F)
+            );
         }
     },
-    CRLF, //CR LF
-    CTL, //%x00-1F / %x7F
     DIGIT() {
         @Override
-        public boolean isValidFor(final int codePoint) {
-            return ValueRangeAlternatives
-                .of(
-                    NumericCharacter.of(NumericCharacter.BASE.HEXADECIMAL, 0x30),
-                    NumericCharacter.of(NumericCharacter.BASE.HEXADECIMAL, 0x39)
-                )
-                .isValidFor(codePoint);
+        Element definition() {
+            return ValueRangeAlternatives.of(
+                NumericCharacter.of(NumericCharacter.BASE.HEXADECIMAL, 0x30),
+                NumericCharacter.of(NumericCharacter.BASE.HEXADECIMAL, 0x39)
+            );
         }
     },
     DQUOTE() {
         @Override
-        public boolean isValidFor(final int codePoint) {
-            return NumericCharacter.of(NumericCharacter.BASE.HEXADECIMAL, 0x22).isValidFor(codePoint);
+        Element definition() {
+            return NumericCharacter.of(NumericCharacter.BASE.HEXADECIMAL, 0x22);
         }
     },
     HEXDIG() {
         @Override
-        public boolean isValidFor(final int codePoint) {
-            return Alternative
-                .of(
-                    DIGIT,
-                    StringElement.of("A"),
-                    StringElement.of("B"),
-                    StringElement.of("C"),
-                    StringElement.of("D"),
-                    StringElement.of("E"),
-                    StringElement.of("F")
-                )
-                .isValidFor(codePoint);
+        Element definition() {
+            return Alternative.of(
+                DIGIT,
+                StringElement.of("A"),
+                StringElement.of("B"),
+                StringElement.of("C"),
+                StringElement.of("D"),
+                StringElement.of("E"),
+                StringElement.of("F")
+            );
         }
     },
     HTAB() {
         @Override
-        public boolean isValidFor(final int codePoint) {
-            return NumericCharacter.of(NumericCharacter.BASE.HEXADECIMAL, 0x09).isValidFor(codePoint);
+        Element definition() {
+            return NumericCharacter.of(NumericCharacter.BASE.HEXADECIMAL, 0x09);
         }
     },
     LF() {
         @Override
-        public boolean isValidFor(final int codePoint) {
-            return NumericCharacter.of(NumericCharacter.BASE.HEXADECIMAL, 0x0A).isValidFor(codePoint);
+        Element definition() {
+            return NumericCharacter.of(NumericCharacter.BASE.HEXADECIMAL, 0x0A);
         }
     },
-    LWSP, //*(WSP / CRLF WSP)
-    OCTET() {
+    LWSP() {
         @Override
-        public boolean isValidFor(final int codePoint) {
-            return ValueRangeAlternatives
-                .of(
-                    NumericCharacter.of(NumericCharacter.BASE.HEXADECIMAL, 0x00),
-                    NumericCharacter.of(NumericCharacter.BASE.HEXADECIMAL, 0xFF)
+        Element definition() {
+            return VariableRepetition.of(
+                SequenceGroup.of(
+                    Concatenation.of(
+                        Alternative.of(RuleReference.of(WSP.asRuleName()), RuleReference.of(CRLF.asRuleName())),
+                        RuleReference.of(WSP.asRuleName())
+                    )
                 )
-                .isValidFor(codePoint);
+            );
+        }
+    },
+    OCTET() {
+        @Override
+        Element definition() {
+            return ValueRangeAlternatives.of(
+                NumericCharacter.of(NumericCharacter.BASE.HEXADECIMAL, 0x00),
+                NumericCharacter.of(NumericCharacter.BASE.HEXADECIMAL, 0xFF)
+            );
         }
     },
     SP() {
         @Override
-        public boolean isValidFor(final int codePoint) {
-            return NumericCharacter.of(NumericCharacter.BASE.HEXADECIMAL, 0x20).isValidFor(codePoint);
+        Element definition() {
+            return NumericCharacter.of(NumericCharacter.BASE.HEXADECIMAL, 0x20);
         }
     },
     VCHAR() {
         @Override
-        public boolean isValidFor(final int codePoint) {
-            return ValueRangeAlternatives
-                .of(
-                    NumericCharacter.of(NumericCharacter.BASE.HEXADECIMAL, 0x21),
-                    NumericCharacter.of(NumericCharacter.BASE.HEXADECIMAL, 0x7E)
-                )
-                .isValidFor(codePoint);
+        Element definition() {
+            return ValueRangeAlternatives.of(
+                NumericCharacter.of(NumericCharacter.BASE.HEXADECIMAL, 0x21),
+                NumericCharacter.of(NumericCharacter.BASE.HEXADECIMAL, 0x7E)
+            );
         }
     },
     WSP {
         @Override
-        public boolean isValidFor(final int codePoint) {
-            return Alternative.of(SP, HTAB).isValidFor(codePoint);
+        Element definition() {
+            return Alternative.of(SP, HTAB);
         }
     };
 
@@ -159,7 +180,14 @@ public RuleName asRuleName() {
     }
 
     @Override
-    public boolean isValidFor(final int codePoint) {
-        throw new UnsupportedOperationException("Not supported yet.");
+    public final <T extends Media<T>> T printOn(final T media) {
+        return Rule.of(asRuleName(), definition()).printOn(media).withValue("type", "corerule");
     }
+
+    @Override
+    public final boolean isValidFor(final int codePoint) {
+        return definition().isValidFor(codePoint);
+    }
+
+    abstract Element definition();
 }
diff --git a/...ain/java/io/github/sebastiantoepfer/jsonschema/vocabulary/format/assertion/abnf/Rule.java b/...ain/java/io/github/sebastiantoepfer/jsonschema/vocabulary/format/assertion/abnf/Rule.java
@@ -23,11 +23,13 @@
  */
 package io.github.sebastiantoepfer.jsonschema.vocabulary.format.assertion.abnf;
 
+import io.github.sebastiantoepfer.ddd.common.Media;
+import io.github.sebastiantoepfer.ddd.common.Printable;
 import io.github.sebastiantoepfer.jsonschema.vocabulary.format.assertion.abnf.element.Element;
 import io.github.sebastiantoepfer.jsonschema.vocabulary.format.assertion.abnf.element.RuleName;
 import java.util.Objects;
 
-public final class Rule {
+public final class Rule implements Printable {
 
     public static Rule of(final RuleName name, final Element elements) {
         return new Rule(name, elements);
@@ -45,6 +47,11 @@ public boolean hasRuleName(final RuleName name) {
         return Objects.equals(this.name, name);
     }
 
+    @Override
+    public <T extends Media<T>> T printOn(final T media) {
+        return media.withValue("name", name).withValue("type", "rule").withValue("elements", elements);
+    }
+
     @Override
     public String toString() {
         return "Rule{" + "name=" + name + ", elements=" + elements + '}';

diff --git a/...java/io/github/sebastiantoepfer/jsonschema/vocabulary/format/assertion/abnf/RuleList.java b/...java/io/github/sebastiantoepfer/jsonschema/vocabulary/format/assertion/abnf/RuleList.java
@@ -25,11 +25,13 @@
 
 import static java.util.Arrays.asList;
 
+import io.github.sebastiantoepfer.ddd.common.Media;
+import io.github.sebastiantoepfer.ddd.common.Printable;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
 
-public final class RuleList {
+public final class RuleList implements Printable {
 
     public static RuleList of(final Rule rule, final Rule... rules) {
         final List<Rule> ruleList = new ArrayList<>();
@@ -48,6 +50,11 @@ private RuleList(final List<Rule> rules) {
         this.rules = List.copyOf(rules);
     }
 
+    @Override
+    public <T extends Media<T>> T printOn(final T media) {
+        return media.withValue("rules", List.copyOf(rules));
+    }
+
     @Override
     public String toString() {
         return "RuleList{" + "rules=" + rules + '}';

diff --git a/...hub/sebastiantoepfer/jsonschema/vocabulary/format/assertion/abnf/element/Alternative.java b/...hub/sebastiantoepfer/jsonschema/vocabulary/format/assertion/abnf/element/Alternative.java
@@ -23,6 +23,7 @@
  */
 package io.github.sebastiantoepfer.jsonschema.vocabulary.format.assertion.abnf.element;
 
+import io.github.sebastiantoepfer.ddd.common.Media;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
@@ -49,6 +50,11 @@ private Alternative(final Collection<? extends Element> alternatives) {
         this.alternatives = List.copyOf(alternatives);
     }
 
+    @Override
+    public <T extends Media<T>> T printOn(final T media) {
+        return media.withValue("type", "alternative").withValue("alternatives", List.copyOf(alternatives));
+    }
+
     @Override
     public boolean isValidFor(final int codePoint) {
         return alternatives.stream().anyMatch(e -> e.isValidFor(codePoint));

diff --git a/...b/sebastiantoepfer/jsonschema/vocabulary/format/assertion/abnf/element/Concatenation.java b/...b/sebastiantoepfer/jsonschema/vocabulary/format/assertion/abnf/element/Concatenation.java
@@ -23,6 +23,7 @@
  */
 package io.github.sebastiantoepfer.jsonschema.vocabulary.format.assertion.abnf.element;
 
+import io.github.sebastiantoepfer.ddd.common.Media;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
@@ -49,6 +50,11 @@ private Concatenation(final Collection<? extends Element> concatenations) {
         this.concatenations = List.copyOf(concatenations);
     }
 
+    @Override
+    public <T extends Media<T>> T printOn(final T media) {
+        return media.withValue("type", "concatenation").withValue("concatenations", List.copyOf(concatenations));
+    }
+
     @Override
     public boolean isValidFor(final int codePoint) {
         throw new UnsupportedOperationException("Not supported yet.");

diff --git a/.../github/sebastiantoepfer/jsonschema/vocabulary/format/assertion/abnf/element/Element.java b/.../github/sebastiantoepfer/jsonschema/vocabulary/format/assertion/abnf/element/Element.java
@@ -23,7 +23,9 @@
  */
 package io.github.sebastiantoepfer.jsonschema.vocabulary.format.assertion.abnf.element;
 
-public interface Element {
+import io.github.sebastiantoepfer.ddd.common.Printable;
+
+public interface Element extends Printable {
     //no no, but let get start simple
     boolean isValidFor(int codePoint);
 }
diff --git a/...ebastiantoepfer/jsonschema/vocabulary/format/assertion/abnf/element/NumericCharacter.java b/...ebastiantoepfer/jsonschema/vocabulary/format/assertion/abnf/element/NumericCharacter.java
@@ -23,6 +23,7 @@
  */
 package io.github.sebastiantoepfer.jsonschema.vocabulary.format.assertion.abnf.element;
 
+import io.github.sebastiantoepfer.ddd.common.Media;
 import java.util.Arrays;
 import java.util.Objects;
 
@@ -45,6 +46,11 @@ public boolean isValidFor(final int codePoint) {
         return value == codePoint;
     }
 
+    @Override
+    public <T extends Media<T>> T printOn(final T media) {
+        return media.withValue("type", "num-val").withValue("base", base.name()).withValue("value", value);
+    }
+
     boolean lessThanOrEquals(final int codePoint) {
         return value <= codePoint;
     }