cddl 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4b41bbfc4b845713489d878733a2c1e51277ce80
-  data.tar.gz: 00096ccc572f588b44cd35007ef8795453f57430
+  metadata.gz: 393b811831045b4c855ad1f27ba0fa410c6e5278
+  data.tar.gz: 8f28e4e50d8a408b1ef43c13b90c6c8c00c6d99c
 SHA512:
-  metadata.gz: 5481738cee35fb77e07500fe839b0f9a7c6473309938e098893f6af32cf3a00d5f720061e733211ac1df4f3dcd945cc0dbe3d855920a288e44cd432de01b723e
-  data.tar.gz: c3d84ab6506b6620996963e76040af1b097c4886b678317f70598a989fdd5d2a9e82d52119fb49e1e987e0abf9af7a2095addbafcf5592f9db287cd6f7dca3eb
+  metadata.gz: 73d8c3fb4b67680d74eeb9ea2b91dc84e9b23410a5ee4f8fb253dddfccbf3531114fece3c2d4008e36cd171c7f833567141690a856f3a41684dfb14f0d227cdf
+  data.tar.gz: 1402b3fd3b79bc6f1c69627125886ef9d59a1693d1c65c76883d79f982551f94af2332cc35eec9f8141100bb8e086a079542677551d2c209ff704b405dc9469a

data/cddl.gemspec

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

data/data/cddl.abnf

@@ -1,10 +1,12 @@
 cddl = S 1*rule
-rule = typename [genericparm] S "=" S type S
-     / groupname [genericparm] S "=" S grpent S
+rule = typename [genericparm] S assign S type S
+     / groupname [genericparm] S assign S grpent S
 
 typename = id
 groupname = id
 
+assign = "=" / "/=" / "//="
+
 genericparm = "<" S id S *("," S id S ) ">"
 genericarg = "<" S type1 S *("," S type1 S ) ">"
 
@@ -66,7 +68,7 @@ SESC = "\" %x20-7E
 
 id = EALPHA *(*("-" / ".") (EALPHA / DIGIT))
 ALPHA = %x41-5A / %x61-7A
-EALPHA = %x41-5A / %x61-7A / "@" / "_"
+EALPHA = %x41-5A / %x61-7A / "@" / "_" / "$"
 DIGIT = %x30-39
 DIGIT1 = %x31-39
 S = *WS

data/data/prelude.cddl

@@ -7,7 +7,9 @@ nint = #1
 int = uint / nint
 
 bstr = #2
+bytes = bstr
 tstr = #3
+text = tstr
 
 tdate = #6.0(tstr)
 time = #6.1(number)
@@ -40,6 +42,7 @@ false = #7.20
 true = #7.21
 bool = false / true
 nil = #7.22
+null = nil
 undefined = #7.23
 
-used_in_cddl_prelude = any / bstr / tdate / time / number / biguint / bignint / bigint / integer / decfrac / bigfloat / eb64url / eb64legacy / eb16 / encoded-cbor / uri / b64url / b64legacy / regexp / mime-message / cbor-any / float16 / float32 / float64 / float16-32 / float32-64 / float / false / true / bool / nil / undefined / uint / nint / int / tstr
+used_in_cddl_prelude = any / bytes / tdate / time / number / biguint / bignint / bigint / integer / decfrac / bigfloat / eb64url / eb64legacy / eb16 / encoded-cbor / uri / b64url / b64legacy / regexp / mime-message / cbor-any / float16 / float32 / float64 / float16-32 / float32-64 / float / false / true / bool / null / undefined / uint / nint / int / text

data/lib/cddl.rb

@@ -1,7 +1,7 @@
 require 'abnc'
 require 'pp'
 require 'pathname'
-require 'cbor-pure'
+require 'cbor-pure' unless defined?(CBOR::Tagged)
 require 'regexp-examples'
 require 'colorize'
 
@@ -19,6 +19,9 @@ module CDDL
   class ParseError < ArgumentError; end
 
   class Parser
+
+    class BackTrack < Exception; end
+
     def initialize(source_text)
       @abnf = Peggy::ABNF.new
       _cresult = @abnf.compile! ABNF_SPEC, ignore: :s
@@ -81,7 +84,11 @@ module CDDL
             fail "Huh?"
           end
         n = rulename.to_s
+        asg = rule.assign.to_s
         if g = rule.genericparm
+          if asg != "="
+            fail "Augment #{asg.inspect} not implemented for generics"
+          end
           ids = g.children(:id).map(&:to_s)
           # puts ["ids", ids].inspect
           if b = @generics[n]
@@ -89,16 +96,36 @@ module CDDL
           end
           @generics[n] = [rule_ast, ids]
         else
-          if @rules[n]
-            a = strip_nodes(rule_ast).inspect
-            b = strip_nodes(@rules[n]).inspect
-            if a == b
-              warn "*** Warning: Identical redefinition of #{n} as #{a}"
-            else
-              fail "Duplicate rule definition #{n} as #{b} (was #{a})"
+          case asg
+          when "="
+            if @rules[n]
+              a = strip_nodes(rule_ast).inspect
+              b = strip_nodes(@rules[n]).inspect
+              if a == b
+                warn "*** Warning: Identical redefinition of #{n} as #{a}"
+              else
+                fail "Duplicate rule definition #{n} as #{b} (was #{a})"
+              end
+            end
+            @rules[n] = rule_ast
+          when "/="
+            @rules[n] ||= [:type1]
+            fail "Can't add #{rule_ast} to #{n}" unless rule_ast[0] == :type1
+            # XXX need to check existing rule as well
+            @rules[n].concat rule_ast[1..-1]
+            # puts "#{@rules[n].inspect} /="
+          when "//="
+            @rules[n] ||= [:grpchoice]
+            fail "Can't add #{rule_ast} to #{n}" unless rule_ast[0] == :grpent
+            # XXX need to check existing rule as well
+            if @rules[n][0] == :grpent # widen
+              @rules[n] = [:grpchoice, @rules[n]]
             end
+            @rules[n] << rule_ast
+            # puts "#{@rules[n].inspect} //="
+          else
+            fail "Unknown assign #{asg.inspect}"
           end
-          @rules[n] = rule_ast
         end
       end
       # pp @generics
@@ -140,13 +167,43 @@ module CDDL
     def generate1(where, inmap = false)
       case where[0]
       when :type1
-        generate1(where[rand(where.size-1)+1])
+        fail BackTrack.new("Can't generate from empty type choice socket yet") unless where.size > 1
+        begin
+          chosen = where[rand(where.size-1)+1]
+          generate1(chosen)
+        rescue BackTrack
+          tries = where[1..-1].sample(where.size) - [chosen]
+          r = begin
+                if tries.empty?
+                  BackTrack.new("No suitable alternative in type choice")
+                else
+                  generate1(tries.pop)
+                end
+              rescue BackTrack
+                retry
+              end
+          fail r if BackTrack === r
+          r
+        end
       when :grpchoice
-        chosen = where[rand(where.size-1)+1]
-        # pp [:chosen, chosen]
-        r = chosen.flat_map {|m| generate1(m, inmap)}
-        # pp r
-        r
+        fail BackTrack.new("Can't generate from empty group choice socket yet") unless where.size > 1
+        begin
+          chosen = where[rand(where.size-1)+1]
+          chosen.flat_map {|m| generate1(m, inmap)}
+        rescue BackTrack
+          tries = where[1..-1].sample(where.size) - [chosen]
+          r = begin
+                if tries.empty?
+                  BackTrack.new("No suitable alternative in group choice")
+                else
+                  tries.pop.flat_map {|m| generate1(m, inmap)}
+                end
+              rescue BackTrack
+                retry
+              end
+          fail r if BackTrack === r
+          r
+        end
       when :map
         Hash[where[1..-1].flat_map {|m| generate1(m, true)}]
       when :recurse_grpent
@@ -177,10 +234,26 @@ module CDDL
         st += rand(en + 1 - st) if en != st
         kr = where[3]
         vr = where[4]
-        fail "member key not given in map for #{where}" unless kr if inmap
-        Array.new(st) { [ (generate1(kr) if kr), # XXX: need error in map context
-                         generate1(vr)
-                       ]}
+        if inmap
+          unless kr
+            if vr[0] == :grpent
+              fail "grpent in map #{vr.inspect}" unless vr.size == 2
+              g = generate1(vr[1], true)
+              # warn "GGG #{g.inspect}"
+              return g
+            else
+              fail "member key not given in map for #{where}"  # || vr == [:grpchoice]
+            end
+          end
+        end
+        begin
+          Array.new(st) { [ (generate1(kr) if kr), # XXX: need error in map context
+                            generate1(vr)
+                          ]}
+        rescue BackTrack
+          fail BackTrack("Need #{where[1]}..#{where[2]} of these: #{[kr, vr].inspect}") unless where[1] == 0
+          []
+        end
       when :string, :int, :float
         where[1]
       when :range
@@ -374,8 +447,13 @@ module CDDL
             end
           }
         when :member
+          unless k
+            fail "member name not known for group entry #{r} in map" unless v[0] == :grpent
+            d_check1 = d_check.dup
+            # XXX this is ignoring occur = [s, _e]
+            return map_check(d, d_check1, v[1..-1]) && d_check.replace(d_check1)
+          end
           # this is mostly quadratic; let's do the linear thing if possible
-          fail "member name not known for group entry #{r} in map" unless k
           simple, simpleval = extract_value(k)
           if simple
             #              puts "SIMPLE: #{d_check.inspect} #{simpleval}"
@@ -417,8 +495,8 @@ module CDDL
       when :array
         if Array === d
           # validate1 against the record
-          i = validate_forward(d, 0, where)
-          validate_result(i == d.size) { "cannot complete array #{d} for #{where}" }
+          idx = validate_forward(d, 0, where)
+          validate_result(idx == d.size) { "cannot complete array #{d} for #{where}" }
         end
       when :string, :int, :float
         _, v = extract_value(where)
@@ -534,17 +612,27 @@ module CDDL
         b
       else
         r = @rules[name]
+        unless r
+          if name[0] == "$"
+            r = @rules[name] = if name[1] == "$"
+                                 [:grpchoice]
+                               else
+                                 [:type1]
+                               end
+          end
+        end
         if r
           t = r_process(name, r)
           unless t[0] == :type1
-            fail "#{name} not a type #{t}" unless canbegroup && t[0] == :grpent
+            fail "#{name} not a type #{t}" unless canbegroup && (t[0] == :grpent || t[0] == :grpchoice)
           end
           t
         end
       end
     end
 
-    RECURSE_TYPE = {grpent: :recurse_grpent, type1: :recurse} # MMM
+    RECURSE_TYPE = {grpent: :recurse_grpent, grpchoice: :recurse_grpent,
+                    type1: :recurse} # MMM
     RECURSE_TYPE.default_proc = proc do |a|
       fail a.inspect
     end
@@ -557,6 +645,12 @@ module CDDL
                        @bindings.push(bindings)
                        r = [t, *r[1..-1].map {|e|
                               case t
+                              when :grpchoice
+                                fail e[0].inspect unless e[0] == :grpent
+                                fail e unless e.size == 2
+                                res = grpent(e[1])
+                                # warn "RES #{res.inspect}"
+                                res
                               when :grpent
                                 grpent(e)
                               when :type1
@@ -652,10 +746,18 @@ module CDDL
             }
           end
         else
-          if t[0] == :grpent
-            t = [t[0], *t[1..-1].flatten(1)]
+          if t[0] == :grpchoice && occ == [1, 1]
+            [t]
+          else
+            if t[0] == :grpent
+              t = [t[0], *t[1..-1].flatten(1)]
+            end
+            if occ[0] == 0 && t == [:grpchoice]
+              []                # we won't be able to generate any of those
+            else
+              [[:member, *occ, nil, t]]
+            end
           end
-          [[:member, *occ, nil, t]]
         end
       end
     end
@@ -730,7 +832,7 @@ module CDDL
           end
         when :recurse_grpent # XXX we don't have the entry yet
         when :member
-          fail "map entry without member key given: #{member}" unless member[3]
+          fail "map entry without member key given: #{member}" unless member[3] || member[4][0] == :grpent # || member[4] == [:grpchoice]
         else
           fail ["type1 member", member].inspect unless member[0] == :member
         end
@@ -778,7 +880,7 @@ module CDDL
         when /\A[\[{]/
           type = BRACE[str[0]]
           @insides << type
-          s = n.children(:group).flat_map {|ch| group(ch)}
+          s = n.children(:group).flat_map {|g| group(g)}
           @insides.pop
           if type == :map
             memberkey_check(s)
@@ -791,7 +893,7 @@ module CDDL
             s = group_recall(gn.to_s, n.genericarg).flatten(1)
           else
             @insides << :enum
-            s = n.children(:group).flat_map {|ch| group(ch)}
+            s = n.children(:group).flat_map {|g| group(g)}
             @insides.pop
           end
           [:type1, *s.map {|mem|

data/test-data/ifmap2.cddl

@@ -0,0 +1,21 @@
+response =
+  ["ifmap", "response",
+    [ ? validation-attributes ],
+    [ response-choice ]]
+
+response-choice = (
+    error-result // poll-result // search-result // subscribe-received //
+    publish-received // purge-publisher-received // new-session-result //
+    renew-session-result // end-session-result
+)
+
+error-result = 1
+poll-result = 2
+search-result = 3
+subscribe-received = 4
+publish-received = 5
+purge-publisher-received = 6
+new-session-result = 7
+renew-session-result = 8
+end-session-result = 9
+validation-attributes = (10, 11)

data/test/test-cddl.rb

@@ -428,7 +428,28 @@ HERE
     }
   end
 
-  
+  def test_another_simple_alternative_group_occur
+    parser = CDDL::Parser.new <<HERE
+test = {
+  ?(bar: int // bar: true)
+}
+HERE
+    pp parser.rules
+    parser.validate({})
+    10.times {
+      g = parser.generate
+      # pp ["tasag", g]
+      if g != {}
+        bar = g['bar']
+        fail "GGG #{g.inspect}" unless bar
+        assert bar == true || Integer(bar)
+        assert parser.validate(g)
+        refute parser.validate(g.merge(foo: 3), false)
+        refute parser.validate(g.merge(bar: "baz"), false)
+      end
+    }
+  end
+
   def test_bad_simple_alternative_group
     parser = CDDL::Parser.new <<HERE
 test = {
@@ -1068,6 +1089,176 @@ HERE
     assert parser.validate({})
   end
 
+  
+  def test_empty_group_augmented
+    parser = CDDL::Parser.new <<HERE
+a = {b}
+b = (
+)
+; b //= (3)   PENDING: need to recognize this as group
+b //= ()
+HERE
+    # puts "empty_group_sp AST:"
+    # puts parser.ast_debug
+    # puts "empty_group_sp RULES:"
+    # pp parser.rules
+    assert_equal({}, parser.generate)
+    assert parser.validate({})
+  end
+  
+  def test_simple_group_augmented
+    parser = CDDL::Parser.new <<HERE
+a = {b}
+b = ( "abs": 3 )
+; b //= (3)   PENDING: need to recognize this as group
+b //= ( "abs": -3 )
+b //= ( "abs": 5 )
+HERE
+    # puts "empty_group_sp AST:"
+    # puts parser.ast_debug
+    # puts "simple_group_augmented RULES:"
+    # pp parser.rules
+    assert_equal(["abs"], parser.generate.keys)
+    v = {}
+    20.times do
+      v[parser.generate["abs"]] = true
+    end
+    assert_equal({3 => true, -3 => true, 5 => true}, v)
+    assert parser.validate({"abs" => 3})
+    assert parser.validate({"abs" => 5})
+    assert parser.validate({"abs" => -3})
+  end
+  
+  def test_simple_group_augmented_uninitialized
+    parser = CDDL::Parser.new <<HERE
+a = {b}
+b //= ( "abs": 3 )
+; b //= (3)   PENDING: need to recognize this as group
+b //= ( "abs": -3 )
+HERE
+    # puts "empty_group_sp AST:"
+    # puts parser.ast_debug
+    # puts "simple_group_augmented_uninitialized RULES:"
+    # pp parser.rules
+    assert_equal(["abs"], parser.generate.keys)
+    v = {}
+    10.times do
+      v[parser.generate["abs"]] = true
+    end
+    assert_equal({3 => true, -3 => true}, v)
+    assert parser.validate({"abs" => 3})
+    assert parser.validate({"abs" => -3})
+  end
+
+  
+  def test_simple_type_augmented
+    parser = CDDL::Parser.new <<HERE
+a = {b}
+b = ( "abs": t1 )
+t1 = 3
+t1 /= -3
+HERE
+    # puts "empty_group_sp AST:"
+    # puts parser.ast_debug
+    # puts "simple_type_augmented RULES:"
+    # pp parser.rules
+    assert_equal(["abs"], parser.generate.keys)
+    v = {}
+    10.times do
+      v[parser.generate["abs"]] = true
+    end
+    assert_equal({3 => true, -3 => true}, v)
+    assert parser.validate({"abs" => 3})
+    assert parser.validate({"abs" => -3})
+  end
+
+    
+  def test_empty_type_socket
+    parser = CDDL::Parser.new <<HERE
+a = {b}
+b = ( "abs": $t1 )
+HERE
+    # puts "empty_group_sp AST:"
+    # puts parser.ast_debug
+    # puts "simple_type_augmented RULES:"
+    # pp parser.rules
+    assert_raise { parser.generate }
+  end
+
+      
+  def test_empty_group_socket
+    parser = CDDL::Parser.new <<HERE
+a = {$$t2}
+HERE
+    # puts "empty_group_sp AST:"
+    # puts parser.ast_debug
+    # puts "simple_type_augmented RULES:"
+    # pp parser.rules
+    assert_raise { parser.generate }
+  end
+
+      
+  def test_validate_empty_type_socket
+    parser = CDDL::Parser.new <<HERE
+a = {b}
+b = ( "abs": $t1 / 17 )
+HERE
+    # puts "empty_group_sp AST:"
+    # puts parser.ast_debug
+    # puts "simple_type_augmented RULES:"
+    # pp parser.rules
+    assert_equal parser.generate, {"abs" => 17}
+    assert parser.validate({"abs" => 17})
+  end
+
+      
+  def test_validate_empty_group_socket
+    parser = CDDL::Parser.new <<HERE
+a = {$$t2 // a: 1}
+HERE
+    # puts "empty_group_sp AST:"
+    # puts parser.ast_debug
+    # puts "simple_type_augmented RULES:"
+    # pp parser.rules
+    assert_equal parser.generate, {"a" => 1}
+    assert parser.validate({"a" => 1})
+  end
+
+        
+  def test_validate_empty_group_socket_in_star
+    parser = CDDL::Parser.new <<HERE
+a = {* $$t2}
+HERE
+    # puts "empty_group_sp AST:"
+    # puts parser.ast_debug
+    # puts "simple_type_augmented RULES:"
+    # pp parser.rules
+    assert_equal parser.generate, {}
+    assert parser.validate({})
+  end
+
+  
+  def test_simple_type_augmented_uninitialized
+    parser = CDDL::Parser.new <<HERE
+a = {b}
+b = ( "abs": t1 )
+t1 /= 3
+t1 /= -3
+HERE
+    # puts "empty_group_sp AST:"
+    # puts parser.ast_debug
+    # puts "simple_type_augmented_uninitialized RULES:"
+    # pp parser.rules
+    assert_equal(["abs"], parser.generate.keys)
+    v = {}
+    10.times do
+      v[parser.generate["abs"]] = true
+    end
+    assert_equal({3 => true, -3 => true}, v)
+    assert parser.validate({"abs" => 3})
+    assert parser.validate({"abs" => -3})
+  end
+
 
   def test_empty_group_indirect
     parser = CDDL::Parser.new <<HERE
@@ -1075,7 +1266,7 @@ a = {b}
 b = (c)
 c = ()
 HERE
-# XXX
+# XXX: Pending
 #    assert_equal({}, parser.generate)
 #    assert parser.validate({})
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cddl
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Carsten Bormann
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-05 00:00:00.000000000 Z
+date: 2015-07-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cbor-diag
@@ -106,6 +106,7 @@ files:
 - test-data/cdni-ct.cddl
 - test-data/dcaf1.cddl
 - test-data/ifmap-base-2.0v17.cddl
+- test-data/ifmap2.cddl
 - test-data/jcr-ex.cddl
 - test-data/minimal.cddl
 - test-data/reused_named_group.cddl
@@ -136,7 +137,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: CDDL generator and validator.