cddl 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 14938c337d552f720d587e2b46be2c4738e48f8b
-  data.tar.gz: 9a2b6a95471d6d29b6acd051d3c838d30f1724c0
+  metadata.gz: ae990c0c1e630a5f206d115bc5ae8cbc2e5612cd
+  data.tar.gz: 7ff78e8928e1cd3e7f60fa1086e6b055b23e39d7
 SHA512:
-  metadata.gz: 557ce79dad209f8577c361effcb3aea96ee43be2b4dba7914fa34fdb9f7bca9d5e5adfe079dcdadce42062f07f1eb55c2e825ec1c30833f9d23d5ffb118ecaf1
-  data.tar.gz: a1d8f53c4baf9d5c50c65a7daf3a91d40a1c5c43616978f3fedcb0c84493012906335712003c90b73d04b0f2800d9e89d081200036e5506f99b20db8a95b23d6
+  metadata.gz: 25cb1b61914141616819edfbcfa2a7de955295a1c1863f22ed6af85700f5cc1fa9897c6cbf51a9bcd65814f927f026e389fd80c916713e07a195a2b42dbb5136
+  data.tar.gz: 042f0f7497d609872bfce8b95da45d98a273a06092c67d2816704618497067910add06f4bf88abfa7d066cc90dff30f19ead71f43dc2ddcceb10e61b57866a23

data/bin/cddl

@@ -15,8 +15,16 @@ def usage
   exit 1
 end
 
+def read_arg(arg)
+  if arg == "-"
+    STDIN.read
+  else
+    File.read(arg)
+  end
+end
+
 def parser
-  @parser ||= CDDL::Parser.new(File.read(ARGV[0]))
+  @parser ||= CDDL::Parser.new(read_arg(ARGV[0]))
 end
 
 case ARGV[1]

data/cddl.gemspec

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

data/lib/cddl.rb

@@ -10,6 +10,8 @@ module CDDL
   PRELUDE = File.read("#{DATA_DIR}/prelude.cddl")
   ABNF_SPEC = File.read("#{DATA_DIR}/cddl.abnf")
 
+  MANY = Float::INFINITY
+
   class Parser
     def initialize(source_text)
       @abnf = Peggy::ABNF.new
@@ -27,6 +29,8 @@ module CDDL
       end
       puts @abnf.ast? if $debug_ast
       @ast = @abnf.ast?
+      # our little argument stack for rule processing
+      @insides = []
     end
 
     def apr                     # for debugging
@@ -72,12 +76,11 @@ module CDDL
         generate(where[rand(where.size-1)+1])
       when :map
         Hash[where[1..-1].flat_map {|m| generate(m, true)}]
-      when :array
+      when :array, :grpent
         where[1..-1].flat_map {|m| generate(m).map{|e| e[1]}}
       when :member
         s = where[1]
-        e = where[2]
-        e = 4 if e == -1
+        e = [where[2], [s, 4].max].min # truncate to 4 unless must be more
         s += rand(e + 1 - s) if e != s
         kr = where[3]
         vr = where[4]
@@ -164,6 +167,36 @@ module CDDL
       )
     end
 
+    def validate_forward(d, start, where)
+      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)))
+          i += n
+          occ += 1
+        end
+        if occ < s
+          @last_message = "occur not reached in array #{d} for #{where}"
+          return false
+        end
+      }
+      i
+    end
+
+    # returns number of matches or false for breakage
+    def validate_linear(d, start, where)
+      fail unless Array === d
+      case where[0]
+      when :grpent
+        # must be inside an array with nested occurrences
+        validate_forward(d, start, where)
+      else
+        validate1(d[start], where) ? 1 : false
+      end
+    end
+
     def validate1(d, where=rules)
 #      puts "DATA: #{d.inspect}"
 #      puts "RULE: #{where.inspect}"
@@ -205,21 +238,7 @@ module CDDL
       when :array
         if Array === d
           # validate1 against the record
-          # XXX do that in some recursive descent fashion
-          i = 0
-          where[1..-1].each { |r|
-            t, s, e, _k, v = r # XXX
-            fail unless t == :member
-            occ = 0
-            while ((e == -1 || occ < e) && i != d.size && validate1(d[i], v))
-              i += 1
-              occ += 1
-            end
-            if occ < s
-              @last_message = "occur not reached in array #{d} for #{where}"
-              return false
-            end
-          }
+          i = validate_forward(d, 0, where)
           validate_result(i == d.size) { "cannot complete array #{d} for #{where}" }
         end
       when :string, :int, :float
@@ -310,25 +329,27 @@ module CDDL
         else
           type1(n.type1, true)              # type1 can be a group here!
         end
-        if t[0] == :grpent
+        if t[0] == :grpent && (@insides.last == :map || occ == [1, 1])
           # go through the members here and multiply the occs
-          # XXX only do this for maps.  Keep the structure up for the arrays!
           t1 = t[1..-1].flatten(1)
           t1.flat_map {|t2| 
             if t2[0] == :member
               [t2]
             else
-              fail unless t2[0] == :grpent
+              fail unless t2[0] == :grpent # XXX Where is the nested multiplication here?
               t2[1..-1]
             end
           }.map {|mem|
             # p mem
             mem[1] *= occ[0]
-            mem[2] *= [occ[1], -1].max
+            mem[2] *= occ[1]    # Does all the infinity magic
             # p mem
             mem
           }
         else
+          if t[0] == :grpent
+            t = [t[0], *t[1..-1].flatten(1)]
+          end
           [[:member, *occ, nil, t]]
         end
       end
@@ -407,15 +428,18 @@ module CDDL
         when /\A\(/
           type(n.type)
         when /\A[\[{]/
-          s = n.children(:group).flat_map {|ch| group(ch)}
           type = BRACE[str[0]]
+          @insides << type
+          s = n.children(:group).flat_map {|ch| group(ch)}
+          @insides.pop
           if type == :map
             s.each do |member|
               fail unless member[0] == :member
               fail "map entry without member key given: #{member}" unless member[3]
             end
-            # XXX do the occurrence multiplier here
+            # XXX could do the occurrence multiplier here
           end
+          # warn s.inspect
           [type, *s]
         else
           "unimplemented #{n}"
@@ -441,7 +465,7 @@ module CDDL
       when ""
         [1, 1]
       when "+"
-        [1, -1]
+        [1, MANY]
       when "?"
         [0, 1]
       when /\A(\d*)\*(\d*)\z/
@@ -451,7 +475,7 @@ module CDDL
           s = s.to_i
         end
         if (e = $2) == ""
-          e = -1
+          e = MANY
         else
           e = e.to_i
         end

data/test/test-cddl.rb

@@ -21,7 +21,7 @@ class TestABNF < Test::Unit::TestCase
    [:array,
     [:member,
      0,
-     -1,
+     CDDL::MANY,
      nil,
      [:map,
       [:member, 1, 1, [:string, "rater"], [:prim, 3]],
@@ -33,7 +33,7 @@ class TestABNF < Test::Unit::TestCase
       [:member, 0, 1, [:string, "sample-size"], [:prim, 0]],
       [:member, 0, 1, [:string, "generated"], [:prim, 0]],
       [:member, 0, 1, [:string, "expires"], [:prim, 0]],
-      [:member, 0, -1, [:type1, [:prim]], [:prim]]]]]]]]
+      [:member, 0, CDDL::MANY, [:type1, [:prim]], [:prim]]]]]]]]
 
   def test_aa_rfc7071_concise
     parser1 = CDDL::Parser.new(File.read("#{TEST_DATA_DIR}/7071-concise.cddl"))
@@ -56,7 +56,6 @@ HERE
     assert_equal [0x4711, 0b1011001110001111000], parser.generate
   end
 
-  
   def test_validate_person_occurs
     person = <<HERE
 person = (
@@ -67,19 +66,25 @@ HERE
     parser1 = CDDL::Parser.new "unlimitedpersons = [* person ]" + person
     parser2 = CDDL::Parser.new "oneortwoPerson = [1*2 person ]" + person
     parser3 = CDDL::Parser.new "min2Person = [2* person ]" + person
-    
+
     assert parser1.validate([])
     refute parser2.validate([], false)
     refute parser3.validate([], false)
     assert parser1.validate(["Methuselah", 969])
     assert parser2.validate(["Methuselah", 969])
     refute parser3.validate(["Methuselah", 969], false)
-    assert parser1.validate(["Methuselah", "Methuselah", 969, 969]) # XXX Sequence
-    assert parser2.validate(["Methuselah", "Methuselah", 969, 969])
-    assert parser3.validate(["Methuselah", "Methuselah", 969, 969])
-    assert parser1.validate(["Methuselah", "Methuselah", "Methuselah", 969, 969]) # XXX Sequence
+    assert parser1.validate(["Methuselah", 969, "Methuselah", 969])
+    assert parser2.validate(["Methuselah", 969, "Methuselah", 969])
+    assert parser3.validate(["Methuselah", 969, "Methuselah", 969])
+    assert parser1.validate(["Methuselah", 969, "Methuselah", 969, "Methuselah", 969])
+    refute parser2.validate(["Methuselah", 969, "Methuselah", 969, "Methuselah", 969], false)
+    assert parser3.validate(["Methuselah", 969, "Methuselah", 969, "Methuselah", 969])
+    refute parser1.validate(["Methuselah", "Methuselah", 969, 969], false)
+    refute parser2.validate(["Methuselah", "Methuselah", 969, 969], false)
+    refute parser3.validate(["Methuselah", "Methuselah", 969, 969], false)
+    refute parser1.validate(["Methuselah", "Methuselah", "Methuselah", 969, 969], false)
     refute parser2.validate(["Methuselah", "Methuselah", "Methuselah", 969, 969], false)
-    assert parser3.validate(["Methuselah", "Methuselah", "Methuselah", 969, 969])
+    refute parser3.validate(["Methuselah", "Methuselah", "Methuselah", 969, 969], false)
   end
 
   def test_validate
@@ -215,9 +220,9 @@ HERE
     # pp parser.apr
     assert parser.validate([])
     assert parser.validate([1, 2])
-    assert parser.validate([1, 1, 2, 2]) # XXX: This is probably a BUG
-    refute parser.validate([1, 2, 1, 2], false) # XXX->assert: major surgery required
-    assert parser.validate([1])          # XXX -> refute (rules left)
+    assert parser.validate([1, 2, 1, 2])
+    refute parser.validate([1, 1, 2, 2], false)
+    refute parser.validate([1], false)
     refute parser.validate([1, 2, 1], false)
   end
 
@@ -251,7 +256,7 @@ HERE
     # puts "APR:"
     # pp parser.apr
     assert parser.validate([])
-    assert parser.validate([1])
+    refute parser.validate([1], false)
     assert parser.validate([1, 2])
     refute parser.validate([2, 1], false)
     refute parser.validate([1, 1, 2, 2], false)
@@ -273,8 +278,8 @@ HERE
     refute parser.validate([1], false)
     assert parser.validate([1, 2])
     refute parser.validate([2, 1], false)
-    assert parser.validate([1, 1, 2, 2]) # XXX not sequence preserving
-    refute parser.validate([1, 2, 1, 2], false)
+    refute parser.validate([1, 1, 2, 2], false)
+    assert parser.validate([1, 2, 1, 2])
     refute parser.validate([1, 2, 1], false)
   end
 
@@ -289,15 +294,15 @@ HERE
     # puts "APR:"
     # pp parser.apr
     assert parser.validate([])
-    assert parser.validate([1])
+    refute parser.validate([1], false)
     assert parser.validate([1, 2])
     refute parser.validate([2, 1], false)
-    assert parser.validate([1, 1, 2, 2]) # XXX not sequence preserving
-    refute parser.validate([1, 2, 1, 2], false)
+    refute parser.validate([1, 1, 2, 2], false)
+    assert parser.validate([1, 2, 1, 2])
     refute parser.validate([1, 2, 1], false)
   end
 
-  
+
   def test_validate_occur23  # XXX need indirection for now
     # $debug_ast = true
     parser = CDDL::Parser.new <<HERE
@@ -313,11 +318,35 @@ HERE
     refute parser.validate([1], false)
     refute parser.validate([1, 2], false)
     refute parser.validate([2, 1], false)
-    assert parser.validate([1, 1, 2, 2]) # XXX not sequence preserving
-    assert parser.validate([1, 1, 1, 2, 2]) # XXX not sequence preserving
-    assert parser.validate([1, 1, 2, 2, 2]) # XXX not sequence preserving
-    assert parser.validate([1, 1, 1, 2, 2, 2]) # XXX not sequence preserving
-    refute parser.validate([1, 2, 1, 2], false)
+    assert parser.validate([1, 2, 1, 2])
+    assert parser.validate([1, 2, 1, 2, 1, 2])
+    refute parser.validate([1, 2, 1, 2, 1, 2, 1, 2], false)
+    refute parser.validate([1, 1, 2, 2, 2], false)
+    refute parser.validate([1, 1, 1, 2, 2, 2], false)
+    refute parser.validate([1, 2, 1], false)
+  end
+
+
+  def test_validate_occur12plus1  # XXX need indirection for now
+    # $debug_ast = true
+    parser = CDDL::Parser.new <<HERE
+test = [1*2 test1 1*1 test1]
+test1 = (one: 1, two: 2)
+HERE
+    # puts "RULES:"
+    # pp parser.rules
+    # puts "APR:"
+    # pp parser.apr
+    pp parser.generate
+    refute parser.validate([], false)
+    refute parser.validate([1], false)
+    refute parser.validate([1, 2], false)
+    refute parser.validate([2, 1], false)
+    refute parser.validate([1, 2, 1, 2], false) # !!! PEG semantics gets us here
+    assert parser.validate([1, 2, 1, 2, 1, 2])
+    refute parser.validate([1, 2, 1, 2, 1, 2, 1, 2], false)
+    refute parser.validate([1, 1, 2, 2, 2], false)
+    refute parser.validate([1, 1, 1, 2, 2, 2], false)
     refute parser.validate([1, 2, 1], false)
   end
 
@@ -363,5 +392,28 @@ HERE
     refute parser.validate(CBOR::Tagged.new(55799, CBOR::Tagged.new(999, [0, "barley", 1])), false)
   end
 
+  def test_nested_group_many1
+    parser = CDDL::Parser.new <<HERE
+foo = {* bar} 
+bar = (* b: 1)
+HERE
+    assert_equal [:type1, [:map, [:member, 0, CDDL::MANY, [:string, "b"], [:int, 1]]]], parser.rules
+  end
+
+  def test_nested_group_many2
+    parser = CDDL::Parser.new <<HERE
+foo = {* bar} 
+bar = (b: 1)
+HERE
+    assert_equal [:type1, [:map, [:member, 0, CDDL::MANY, [:string, "b"], [:int, 1]]]], parser.rules
+  end
+
+  def test_nested_group_many3
+    parser = CDDL::Parser.new <<HERE
+foo = {* bar} 
+bar = (4*6 b: 1)
+HERE
+    assert_equal [:type1, [:map, [:member, 0, CDDL::MANY, [:string, "b"], [:int, 1]]]], parser.rules
+  end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cddl
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Carsten Bormann
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-02 00:00:00.000000000 Z
+date: 2015-03-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cbor-diag
@@ -92,9 +92,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: CDDL generator and validator.
 test_files: []
-has_rdoc: