cddl 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d81421c45b8589d98a0bee597ebf58684b6dc47d
-  data.tar.gz: 2c43ce26e9ec1061a91ffc078eb797293e6e861c
+  metadata.gz: 0f6311c506c4a4e5cbf7e7ae7311301a9d4b6c8d
+  data.tar.gz: e6fdfe83c6aec225ce434ae492a709fd06d0c890
 SHA512:
-  metadata.gz: a59f236c132f7d3c4c20b20275270a304873abe3a0a527cd923a84d683ab953d59a65fa006f7de0c81de45c0d175bb86dcbb7abc680aa5f83e7753464d0dc8d6
-  data.tar.gz: 2724e39b65ff8d6b2de65845ae67a713276fd99743625f2745bc4d6a6c0433ae43f736d47e1741f5e4df936c5102f112e675e541cffa3991a98abb54e93c9b67
+  metadata.gz: c2926569f00e5e7e509b3e6d05271da2c0d79a79eb46e38e97701218fe339113d08a8057369ff3c4b5f02bdd3f5fbb80ebc34875c6767b619ea327f722bf7ce3
+  data.tar.gz: 3df458899c4ed7890ef68a40b3c64484599b2805084eb9c8eee15789c94c269452c6352ce34d77dd078e612957c29ded13b650520c179dc6fe886f853e2a60e6

data/cddl.gemspec

@@ -1,6 +1,6 @@
 spec = Gem::Specification.new do |s|
   s.name = 'cddl'
-  s.version = '0.4.1'
+  s.version = '0.4.2'
   s.summary = "CDDL generator and validator."
   s.description = %{A parser, generator, and validator for CDDL}
   s.add_dependency('cbor-diag')

data/data/cddl.abnf

@@ -30,7 +30,7 @@ annotator = "." id
 group = "(" S *grpent S ")"
       / *grpent
 
-grpent = [occur S] [memberkey S] type1 optcom
+grpent = [occur S] [memberkey S] type optcom
        / [occur S] groupname [genericarg] optcom ; always preempted by previous...
 
 memberkey = type1 S "=>"

data/lib/cddl.rb

@@ -115,6 +115,14 @@ module CDDL
       result
     end
 
+    def lookup_recurse_grpent(name)
+      rule = @stage1[name]
+      [rule[0], *rule[1..-1].map {|x| 
+         fail rule.inspect if x.size != 1
+         x[0]
+       }]
+    end
+
     # Memoize a bit here
 
     REGEXP_FOR_STRING = Hash.new {|h, k|
@@ -132,6 +140,18 @@ module CDDL
         generate1(where[rand(where.size-1)+1])
       when :map
         Hash[where[1..-1].flat_map {|m| generate1(m, true)}]
+      when :recurse_grpent
+        rule = lookup_recurse_grpent(where[1])
+        if @recursion < MAX_RECURSE
+          @recursion += 1
+#p ["recurse_grpent", *rule]
+#r = generate1(rule)
+          r = rule[1..-1].flat_map {|m| generate1(m, inmap)}
+          @recursion -= 1
+          r
+        else
+          fail "Deep recursion into #{name}: #{@stage1[name]}, not yet implemented"
+        end
       when :array, :grpent
         r = where[1..-1].flat_map {|m| generate1(m).map{|e| e[1]}}
             .flat_map {|e| Array === e && e[0] == :grpent ? e[1..-1] : [e]}
@@ -233,6 +253,7 @@ module CDDL
         rule = @stage1[name]
         if @recursion < MAX_RECURSE
           @recursion += 1
+#p ["recurse", *rule]
           r = generate1(rule)
           @recursion -= 1
           r
@@ -240,7 +261,7 @@ module CDDL
           fail "Deep recursion into #{name}: #{@stage1[name]}, not yet implemented"
         end
       else
-        fail "Don't know how to generate from #{where[0]}"
+        fail "Don't know how to generate from #{where[0]} in #{where.inspect}"
       end
     end
 
@@ -289,15 +310,22 @@ module CDDL
       i = 0
       where[1..-1].each { |r|
         t, s, e, _k, v = r # XXX
-        fail unless t == :member
-        occ = 0
-        while ((occ < e) && i != d.size && (n = validate_linear(d, start+i, v)))
+        if t == :recurse_grpent
+          rule = lookup_recurse_grpent(s)
+          n = validate_linear(d, start+i, rule)
+          return false unless n
           i += n
-          occ += 1
-        end
-        if occ < s
-          @last_message = "occur not reached in array #{d} for #{where}"
-          return false
+        else
+          fail r.inspect unless t == :member
+          occ = 0
+          while ((occ < e) && i != d.size && (n = validate_linear(d, start+i, v)))
+            i += n
+            occ += 1
+          end
+          if occ < s
+            @last_message = "occur not reached in array #{d} for #{where}"
+            return false
+          end
         end
       }
       i
@@ -483,13 +511,26 @@ module CDDL
       end
     end
 
+    RECURSE_TYPE = {grpent: :recurse_grpent, type1: :recurse}
+    RECURSE_TYPE.default_proc = proc do |a|
+      fail a.inspect
+    end
+
     def r_process(n, r, bindings = {})
       t = r[0]
       # puts "Processing rule #{n} = #{t}"
       @stage1[n] ||= begin
-                       @stage1[n] = [:type1, [:recurse, n]]
+                       @stage1[n] = [t, [RECURSE_TYPE[t], n]]
                        @bindings.push(bindings)
-                       r = [t, *r[1..-1].map {|e| send(t, e)}]
+                       r = [t, *r[1..-1].map {|e|
+                              case t
+                              when :grpent
+                                grpent(e)
+                              when :type1
+                                type1(e, r.size == 2) # a single type1 could be a group
+                              else
+                                fail t
+                              end}]
                        @bindings.pop
                        r
                      end
@@ -509,11 +550,16 @@ module CDDL
     end
 
     def grpent(n)               # returns array of entries
+      nt = n.type || n.bareword.s.type                # check for grpchoice later
+      unless nt
+        warn @abnf.ast?
+        fail ["ntype", n, n.children].inspect
+      end
       occ = occur(n.occur)
       if mk = n.memberkey       # work around unclear bug in ast generation below
-        fail n.inspect unless n.type1
-        if (t1 = mk.type1) || ((t1 = mk.s) && (t1 = t1.type) && (t1 = t1.type1)) # workaround
-          [[:member, *occ, type1(t1), type1(n.type1)]]
+        if (t1 = mk.type1 || t1 = mk.value || 
+                          ((t1 = mk.s) && (t1 = t1.type) && (t1 = t1.type1))) # workaround
+          [[:member, *occ, type1(t1), type(nt)]]
         else
           bw = mk.bareword
           unless bw
@@ -521,31 +567,36 @@ module CDDL
             fail [n, n.children, mk, mk.children].inspect
           end
           name = bw.to_s
-          [[:member, *occ, [:string, name], type1(n.type1)]]
+          [[:member, *occ, [:string, name], type(nt)]]
         end
       else
-        t = if n.bareword # work around unclear bug, part 2
-              t1 = n.bareword.type1 || n.bareword.s.type.type1 # workaround
+        t = if nbw = nt.bareword
+              t1 = nbw.type1 # || n.bareword.s.type.type1 # workaround
               type1(t1, true)
             else
-              type1(n.type1, true)              # type1 can be a group here!
+              type(nt, true)              # type can actually be a group here!
             end
+        # pp ["t is", t]
         if t[0] == :grpent && (@insides.last != :array || occ == [1, 1])
           # go through the members here and multiply the occs
           t1 = t[1..-1].flatten(1)
-          t1.flat_map {|t2|
-            if t2[0] == :member
-              [t2]
-            else
-              fail unless t2[0] == :grpent # XXX Where is the nested multiplication here?
-              t2[1..-1]
-            end
-          }.map {|mem|
-            mem[1] *= occ[0]
-            mem[2] *= occ[1]    # Does all the infinity magic
-            # p mem
-            mem
-          }
+          if t1[0] == :recurse_grpent
+            [t1]
+          else
+            t1.flat_map {|t2|
+              if t2[0] == :member
+                [t2]
+              else
+                fail t1.inspect unless t2[0] == :grpent # XXX Where is the nested multiplication here?
+                t2[1..-1]
+              end
+            }.map {|mem|
+              mem[1] *= occ[0]
+              mem[2] *= occ[1]    # Does all the infinity magic
+              # p mem
+              mem
+            }
+          end
         else
           if t[0] == :grpent
             t = [t[0], *t[1..-1].flatten(1)]
@@ -688,8 +739,9 @@ module CDDL
       end
     end
 
-    def type(n)
-      s = n.children(:type1).map {|ch| type1(ch)}
+    def type(n, canbegroup = false)
+      # pp ["nch", n.children]
+      s = n.children(:type1).map {|ch| type1(ch, canbegroup)}
       if s.size == 1
         s.first
       else

data/test-data/cdni-ct.cddl

@@ -0,0 +1,72 @@
+; draft-ietf-cdni-control-triggers-06.txt
+
+CIT-object = CIT-command / Trigger-Status-Resource / Trigger-Collection
+
+CIT-command ; use media type application/cdni.ci.TriggerCommand+json
+ = {
+  ? trigger: Triggerspec
+  ? cancel: [* URI]
+  cdn-path: [* Cdn-PID]
+}
+
+Trigger-Status-Resource ; application/cdni.ci.TriggerStatus+json.
+ = {
+  trigger: Triggerspec
+  ctime: Absolute-Time
+  mtime: Absolute-Time
+  ? etime: Absolute-Time
+  status: Trigger-Status
+  ? errors: [* Error-Description]
+}
+
+Trigger-Collection ; application/cdni.ci.TriggerCollection+json
+ = {
+  triggers: [* URI]
+  ? staleresourcetime: int ; time in seconds
+  ? coll-all: URI
+  ? coll-pending: URI
+  ? coll-active: URI
+  ? coll-complete: URI
+  ? coll-failed: URI
+  ? cdn-id: Cdn-PID
+}
+
+Triggerspec = { ; 5.2.1
+  type: Trigger-Type
+  ? metadata.urls: [* URI]
+  ? content.urls: [* URI]
+  ? content.ccid: [* Ccid]
+  ? metadata.patterns: [* Pattern-Match]
+  ? content.patterns: [* Pattern-Match]
+}
+
+Trigger-Type = "preposition" / "invalidate" / "purge" ; 5.2.2
+
+Trigger-Status = "pending" / "active" / "complete" / "processed"
+   / "failed" / "cancelling" / "cancelled" ; 5.2.3
+
+Pattern-Match = { ; 5.2.4
+  pattern: tstr
+  ? case-sensitive: bool
+  ? match-query-string: bool
+}
+
+Absolute-Time = number ; seconds since UNIX epoch, 5.2.5
+
+Error-Description = { ; 5.2.6
+  error: Error-Code
+  ? metadata.urls: [* URI]
+  ? content.urls: [* URI]
+  ? metadata.patterns: [* Pattern-Match]
+  ? content.patterns: [* Pattern-Match]
+  ? description: tstr
+}
+
+Error-Code = "emeta" / "econtent" / "eperm" / "ereject" 
+   / "ecdn" / "ecancelled"  ; 5.2.7
+
+Ccid = tstr ; see I-D.ietf-cdni-metadata
+
+Cdn-PID = tstr .regexp "AS[0-9]+:[0-9]+"
+
+URI = tstr

data/test/test-cddl.rb

@@ -374,6 +374,82 @@ HERE
   end
 
 
+  def test_simple_alternative
+    parser = CDDL::Parser.new <<HERE
+test = {
+  foo: 1
+  bar: 1 / 2
+  baz: 3
+  bee: 4
+}
+HERE
+    # pp parser.rules
+    expected1 = {'foo' => 1, 'bar' => 1, 'baz' => 3, 'bee' => 4}
+    expected2 = {'foo' => 1, 'bar' => 2, 'baz' => 3, 'bee' => 4}
+    10.times {
+      g = parser.generate
+      # pp g
+      assert expected1 == g || expected2 == g
+      assert parser.validate(g)
+    }
+  end
+
+  def test_another_simple_alternative
+    parser = CDDL::Parser.new <<HERE
+test = {
+  bar: int / true
+}
+HERE
+    # pp parser.rules
+    10.times {
+      g = parser.generate
+      # pp ["tasa", g]
+      bar = g['bar']
+      assert bar == true || Integer(bar)
+      assert parser.validate(g)
+    }
+  end
+
+  def test_simple_alternative_in_array
+    parser = CDDL::Parser.new <<HERE
+test = [
+  1 / 2
+  3 / 4
+]
+HERE
+    # pp parser.rules
+    10.times {
+      g = parser.generate
+      #pp ["saia", g]
+      assert_equal g.size, 2
+      assert [1, 2].include? g[0]
+      assert [3, 4].include? g[1]
+      assert parser.validate(g)
+    }
+  end
+
+  def test_simple_alternative_in_array2
+    parser = CDDL::Parser.new <<HERE
+test = [
+  1 / 2
+  bar
+  foob: 3 / 4
+]
+bar = 5 / 6
+HERE
+    # pp parser.rules
+    10.times {
+      g = parser.generate
+      # pp ["saia", g]
+      assert_equal g.size, 3
+      assert [1, 2].include? g[0]
+      assert [5, 6].include? g[1]
+      assert [3, 4].include? g[2]
+      assert parser.validate(g)
+    }
+  end
+
+
   def test_validate_number_key
     parser = CDDL::Parser.new <<HERE
 test = [test1, test2, test3]
@@ -825,9 +901,83 @@ a = [a] / 1
 HERE
     10.times {
       g = parser.generate
-      pp ["recurse-test", g]
+      pp ["recurse-test1", g]
+      assert parser.validate(g)
+    }
+  end
+
+  def test_endless_group_recursion
+    parser = CDDL::Parser.new <<HERE
+b = {a}
+a = (
+  foo: int
+  a
+)
+HERE
+    assert_raise { parser.validate(1) }
+    assert_raise { parser.generate }
+  end
+
+  def test_non_group_recursion
+    parser = CDDL::Parser.new <<HERE
+a = {
+  foo: int
+  bar: ([a] / 1)
+}
+HERE
+    10.times {
+      g = parser.generate
+      # pp ["non-recurse-test", g]
+      assert parser.validate(g)
+    }
+  end
+
+  def test_group_recursion
+    parser = CDDL::Parser.new <<HERE
+b = {a}
+a = (
+  foo: int
+  bar: ([a] / 1)
+)
+HERE
+    p parser.rules
+    10.times {
+      g = parser.generate
+      # pp ["recurse-group-test", g]
       assert parser.validate(g)
     }
   end
 
+  def test_group_recursion_fail1
+    parser = CDDL::Parser.new <<HERE
+b = {a}
+a = (
+  foo: int
+  bar: ([a: a] / 1)
+)
+HERE
+    assert_raise { p parser.rules }
+  end
+
+  def test_empty_group
+    parser = CDDL::Parser.new <<HERE
+a = {b}
+b = ()
+HERE
+    assert_equal({}, parser.generate)
+    assert parser.validate({})
+  end
+
+
+  def test_empty_group_indirect
+    parser = CDDL::Parser.new <<HERE
+a = {b}
+b = (c)
+c = ()
+HERE
+# XXX
+#    assert_equal({}, parser.generate)
+#    assert parser.validate({})
+  end
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cddl
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.2
 platform: ruby
 authors:
 - Carsten Bormann
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-24 00:00:00.000000000 Z
+date: 2015-04-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cbor-diag
@@ -101,6 +101,7 @@ files:
 - test-data/7071-concise.cddl
 - test-data/7071-verbose.cddl
 - test-data/basic_syntax_example.cddl
+- test-data/cdni-ct.cddl
 - test-data/dcaf1.cddl
 - test-data/jcr-ex.cddl
 - test-data/minimal.cddl