cddl 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3d195f7221754d19c72524ad9e7f813021ffbb06
-  data.tar.gz: 3db97cb441c00b2abc6a420163352243e8c89e07
+  metadata.gz: 18e49f92e707d92bff7762be5f4905702b48f179
+  data.tar.gz: 4f3fb0f3fc4573ec189ab16cf280ae1fcb63ead0
 SHA512:
-  metadata.gz: c6fe1856503d0f3b316830fc61b6b9569014981528fd5058c8390553565adf5cf7e4fb16712e4d2a47877dcb02d066ba818775d75c12121db3c41f8e63d2cb52
-  data.tar.gz: 84da634e9885f93badaeda4f0642163a9959ebf362b8e544189b4810076e1abf574378e6c470e4cc5b2eeeb560b251a0c1265734fd6b6de615891f39cdd10d81
+  metadata.gz: 81b2b4241507fdb26f88164daacff36dc73e7f67df3d85662a9f76999f1aa7d7ae2fce72e93e87fbe55991a7b3f8459aa064cfff47f545f05e1904a3e1bef20a
+  data.tar.gz: 89b707e68854724d991785432dac1ed3e2814ae0d92791e3b30ade4e769eeb8508cfb457e0f4fc19b36494320ddbc98caa1ad04b7551359e15c59d4aae7a7a0f

data/cddl.gemspec

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

data/data/cddl.abnf

@@ -7,14 +7,20 @@ groupname = id
 
 type = type1 S *("/" S type1 S)
 
-type1 = value
+type1 = type2 [rangeop type2]
      / "#" "6" ["." uint] "(" S type S ")" ; note no space!
      / "#" DIGIT ["." uint]                ; major/ai
      / "#"                                 ; any
      / "{" S group S "}"
      / "[" S group S "]"
-     / "(" type ")"
-     / typename
+     / "&" S "(" S group S ")"
+     / "&" S groupname
+
+type2 = value
+      / typename
+      / "(" type ")"
+
+rangeop = "..." / ".."
 
 group = "(" S *grpent S ")"
       / *grpent

data/lib/cddl.rb

@@ -97,6 +97,8 @@ module CDDL
                        ]}
       when :string, :int, :float
         where[1]
+      when :range
+        rand(where[1])
       when :prim
         case where[1]
         when nil
@@ -134,17 +136,17 @@ module CDDL
       end
     end
 
-    VALUE_TYPE = {string: true, int: true, float: true}
+    VALUE_TYPE = {string: String, int: Integer, float: Float}
     SIMPLE_VALUE = {
-      [:prim, 7, 20] => [true, false],
-      [:prim, 7, 21] => [true, true],
-      [:prim, 7, 22] => [true, nil],
-      [:prim, 7, 23] => [true, :undefined],
+      [:prim, 7, 20] => [true, false, :bool],
+      [:prim, 7, 21] => [true, true, :bool],
+      [:prim, 7, 22] => [true, nil, :nil],
+      [:prim, 7, 23] => [true, :undefined, :undefined],
     }
 
     def extract_value(t)
-      if VALUE_TYPE[t[0]]
-        [true, t[1]]
+      if vt = VALUE_TYPE[t[0]]
+        [true, t[1], vt]
       elsif v = SIMPLE_VALUE[t]
         v
       else
@@ -251,6 +253,8 @@ module CDDL
       when :string, :int, :float
         _, v = extract_value(where)
         d == v
+      when :range
+        where[2] === d && where[1].include?(d)
       when :prim
         # warn "validate prim WI #{where.inspect} #{d.inspect}"
         case where[1]
@@ -336,7 +340,7 @@ module CDDL
         else
           type1(n.type1, true)              # type1 can be a group here!
         end
-        if t[0] == :grpent && (@insides.last == :map || occ == [1, 1])
+        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| 
@@ -398,11 +402,10 @@ module CDDL
       end
     end
 
-    BRACE = {"{" => :map, "[" => :array}
-
-    def type1(n, canbegroup = false)
-#      puts "NVALUE #{n.value.inspect}"
-      if v = n.value
+    def type2(n, canbegroup = false)
+      if v = n.type
+        type(n.type)
+      elsif v = n.value
         value(n)
       elsif v = n.typename
         t = type_recall(v.to_s, canbegroup)
@@ -421,6 +424,28 @@ module CDDL
           end
         end                     # XXX should flatten the thing, too
         t
+      end
+    end
+
+    BRACE = {"{" => :map, "[" => :array}
+    RANGE_EXCLUDE_END = {".." => false, "..." => true}
+
+    def type1(n, canbegroup = false)
+#      puts "NVALUE #{n.value.inspect}"
+      if v = n.type2
+        if ro = n.rangeop
+          cats = []
+          [:range, Range.new(*n.children(:type2).map {|l|
+             ok, val, cat = extract_value(type2(l))
+             fail "Can't have range with #{l}" unless ok
+             # XXX really should be checking type coherence of range
+             cats << cat
+             val
+           }, RANGE_EXCLUDE_END[ro.to_s]),
+           cats[0] == cats[1] ? cats[0] : fail("Incompatible range #{cats}")]
+        else
+          type2(v, canbegroup)
+        end
       else
         case str = n.to_s
         when "#"
@@ -432,8 +457,6 @@ module CDDL
               s << type(tagged_type)
           end
           s
-        when /\A\(/
-          type(n.type)
         when /\A[\[{]/
           type = BRACE[str[0]]
           @insides << type
@@ -448,6 +471,20 @@ module CDDL
           end
           # warn s.inspect
           [type, *s]
+        when /\A&/
+          if gn = n.groupname
+            s = group_recall(gn.to_s).flatten(1)
+          else
+            @insides << :enum
+            s = n.children(:group).flat_map {|ch| group(ch)}
+            @insides.pop
+          end
+          [:type1, *s.map {|mem|
+             t, _s, _e, _k, v = mem
+             fail unless t == :member
+             v
+           }
+          ]
         else
           "unimplemented #{n}"
         end

data/test/test-cddl.rb

@@ -425,4 +425,169 @@ HERE
     assert_equal [:type1, [:map, [:member, 0, CDDL::MANY, [:string, "b"], [:int, 1]]]], parser.rules
   end
 
+  def test_range_integer
+    parser = CDDL::Parser.new <<HERE
+color = 0..12
+HERE
+    pp parser.generate
+    10.times {
+      assert parser.generate.between?(0, 12)
+    }
+    assert parser.validate(0)
+    assert parser.validate(7)
+    assert parser.validate(12)
+    refute parser.validate(-1, false)
+    refute parser.validate(13, false)
+  end
+
+  def test_range_integer_excl
+    parser = CDDL::Parser.new <<HERE
+color = 0...13
+HERE
+    10.times {
+      assert parser.generate.between?(0, 12)
+    }
+    assert parser.validate(0)
+    assert parser.validate(7)
+    refute parser.validate(7.0)
+    assert parser.validate(12)
+    refute parser.validate(-1, false)
+    refute parser.validate(13, false)
+  end
+
+  def test_range_float
+    parser = CDDL::Parser.new <<HERE
+color = 0.5..max
+max = 12.5
+HERE
+    pp parser.rules
+    10.times {
+      assert parser.generate.between?(0.5, 12.5)
+    }
+    refute parser.validate(0.0, false)
+    assert parser.validate(0.5)
+    assert parser.validate(7.0)
+    refute parser.validate(7)
+    assert parser.validate(12.0)
+    assert parser.validate(12.5)
+    refute parser.validate(-1.0, false)
+    refute parser.validate(13.0, false)
+  end
+
+  def test_enum
+    parser = CDDL::Parser.new <<HERE
+color = &(
+  black: 0,
+  red: 1,
+  green: 2,
+  yellow: 3,
+  blue: 4,
+  magenta: 5,
+  cyan: 6,
+  white: 7,
+  orange: 8,
+  pink: 9,
+  purple: 10,
+  brown: 11,
+  grey: 12,
+)
+HERE
+    # brittle on type1 nesting optimization
+    assert_equal [:type1,
+                  [:type1,
+                   [:int, 0],
+                   [:int, 1],
+                   [:int, 2],
+                   [:int, 3],
+                   [:int, 4],
+                   [:int, 5],
+                   [:int, 6],
+                   [:int, 7],
+                   [:int, 8],
+                   [:int, 9],
+                   [:int, 10],
+                   [:int, 11],
+                   [:int, 12]]], parser.rules
+    10.times {
+      assert parser.generate.between?(0, 12)
+    }
+  end
+
+  def test_enum_indirect
+    parser = CDDL::Parser.new <<HERE
+color = &colors
+basecolors = (
+  red: 1,
+  green: 2,
+  blue: 4,
+  lila,
+)
+lila = (
+  magenta: 5,
+  pink: 9,
+  purple: 10,
+)
+colors = (
+  black: 0,
+  basecolors,
+  yellow: 3,
+  cyan: 6,
+  white: 7,
+  orange: 8,
+  brown: 11,
+  grey: 12,
+)
+HERE
+    # brittle on type1 nesting optimization
+    assert_equal [:type1,
+                  [:type1,
+                   [:int, 0],
+                   [:int, 1],
+                   [:int, 2],
+                   [:int, 4],
+                   [:int, 5],
+                   [:int, 9],
+                   [:int, 10],
+                   [:int, 3],
+                   [:int, 6],
+                   [:int, 7],
+                   [:int, 8],
+                   [:int, 11],
+                   [:int, 12]]], parser.rules
+    10.times {
+      assert parser.generate.between?(0, 12)
+    }
+  end
+
+  def test_invalidate_unequal_range
+    # $debug_ast = true
+    parser = CDDL::Parser.new <<HERE
+test =  1..2.5
+HERE
+    # puts "RULES:"
+    assert_raise {  # TODO: This really should be checked at parse time
+      pp parser.rules
+    }
+    # puts "APR:"
+    # pp parser.apr
+    assert_raise { puts parser.generate() }
+    assert_raise { parser.validate({}) }
+  end
+
+  def test_invalidate_boolean_range
+    # $debug_ast = true
+    parser = CDDL::Parser.new <<HERE
+test = false..true
+HERE
+    # puts "RULES:"
+    assert_raise {  # TODO: This really should be checked at parse time
+      pp parser.rules
+    }
+    # puts "APR:"
+    # pp parser.apr
+    assert_raise { puts parser.generate() }
+    assert_raise { parser.validate({}) }
+  end
+
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cddl
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - Carsten Bormann
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-04 00:00:00.000000000 Z
+date: 2015-03-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cbor-diag