cddl 0.3.3 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c679a7c46cf375f7ebefc86fb2846f4c482fb67e
-  data.tar.gz: b1b1b2968c8ba46bf573074827fb818311946334
+  metadata.gz: 167e4f338b7d73dd31d38e050c736fe9d8041984
+  data.tar.gz: 62c373480ad582423abcf9c5475371a11f08425b
 SHA512:
-  metadata.gz: cff8854de5230152b6cb7223bb9078657c4296b359d244a15a5f34e3910296d0da1dead8a06c8a207d359780542cb690a1951034935d76117c7eb95b4c0b311a
-  data.tar.gz: 339c503e65b5159d14b5fd130528b8c93da567716a746d274558fb353cf72573c205bf535fc7d64b2cc3313ad1dd9ea62b422fea07876b76991f0e4ac5644c3f
+  metadata.gz: 6f26f2048e7a77f12175e23430bf1a0c5271deaa4e0d499683f1d25785aec4765b70966af4b7c155469f68a2db7cb9540658909da1764b6f3a221eed4dcfb92d
+  data.tar.gz: 7e922d96378421546a660cfda5c1dc3ff54efa5ee218767323e1015570f875e829c196e5a90e4115be42c504c9c7d2f51d73b5a8d05f7e14f7d5946886b97cce

data/cddl.gemspec

@@ -1,6 +1,6 @@
 spec = Gem::Specification.new do |s|
   s.name = 'cddl'
-  s.version = '0.3.3'
+  s.version = '0.4.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,13 @@
 cddl = S 1*rule
-rule = typename S "=" S type S
-     / groupname S "=" S group S
+rule = typename [genericparm] S "=" S type S
+     / groupname [genericparm] S "=" S group S
 
 typename = id
 groupname = id
 
+genericparm = "<" S id S *("," S id S ) ">"
+genericarg = "<" S type1 S *("," S type1 S ) ">"
+
 type = type1 S *("/" S type1 S)
 
 type1 = type2 [S (rangeop / annotator) S type2]
@@ -14,10 +17,10 @@ type1 = type2 [S (rangeop / annotator) S type2]
      / "{" S group S "}"
      / "[" S group S "]"
      / "&" S "(" S group S ")"
-     / "&" S groupname
+     / "&" S groupname [genericarg]
 
 type2 = value
-      / typename
+      / typename [genericarg]
       / "(" type ")"
 
 rangeop = "..." / ".."
@@ -28,7 +31,7 @@ group = "(" S *grpent S ")"
       / *grpent
 
 grpent = [occur S] [memberkey S] type1 optcom
-       / [occur S] groupname optcom ; always preempted by previous...
+       / [occur S] groupname [genericarg] optcom ; always preempted by previous...
 
 memberkey = type1 S "=>"
           / bareword S ":"

data/lib/cddl.rb

@@ -63,6 +63,8 @@ module CDDL
 
     def rules
       @rules = {}
+      @generics = {}
+      @bindings = [{}]
       ast.each :rule do |rule|
         rule_ast =
           if rulename = rule.groupname
@@ -73,19 +75,28 @@ module CDDL
             fail "Huh?"
           end
         n = rulename.to_s
-        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})"
+        if g = rule.genericparm
+          ids = g.children(:id).map(&:to_s)
+          # puts ["ids", ids].inspect
+          if b = @generics[n]
+            fail "Duplicate generics definition #{n} as #{rule_ast} (was #{b})"
+          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})"
+            end
           end
+          @rules[n] = rule_ast
         end
-        @rules[n] = rule_ast
       end
-      # pp @rules
-      @rootrule = @rules.keys.first
+      # pp @generics
+      @rootrule = @rules.keys.first # DRAFT: generics are ignored here.
       # now process the rules...
       @stage1 = {}
       result = r_process(@rootrule, @rules[@rootrule])
@@ -428,12 +439,28 @@ module CDDL
       w
     end
 
-    # XXX needs serious memoizing
+    def rule_lookup(name, canbegroup)
+      if b = @bindings.last[name]
+        b
+      else
+        r = @rules[name]
+        if r
+          t = r_process(name, r)
+          unless t[0] == :type1
+            fail "#{name} not a type #{t}" unless canbegroup && t[0] == :grpent
+          end
+          t
+        end
+      end
+    end
 
-    def r_process(n, r)
+    def r_process(n, r, bindings = {})
+      @bindings.push(bindings)
       t = r[0]
       # puts "Processing rule #{n} = #{t}"
-      @stage1[n] ||= [t, *r[1..-1].map {|e| send(t, e)}]
+      r = @stage1[n] ||= [t, *r[1..-1].map {|e| send(t, e)}]
+      @bindings.pop
+      r
     end
 
     def value(n)
@@ -482,7 +509,6 @@ module CDDL
               t2[1..-1]
             end
           }.map {|mem|
-            # p mem
             mem[1] *= occ[0]
             mem[2] *= occ[1]    # Does all the infinity magic
             # p mem
@@ -497,35 +523,32 @@ module CDDL
       end
     end
 
-    def label(n)
-      # if this is not a rulename, it's a bareword
-      if n.bareword
-        name = n.to_s
-        if r = @rules[name]
-          r_process(name, r)
-        else
-          [:string, name]
-        end
-      else
-        type1(n.type1)
-      end
+    def g_process(name, g, genericargs)
+      r, ids = g
+      args = genericargs.children(:type1).map {|x| type1(x, true)}
+      fail "number of args #{name} #{ids.size} #{args.size}" if ids.size != args.size
+      bindings = Hash[ids.zip(args)]
+      r_process("#{name}<#{genericargs._strip}>", r, bindings)
     end
 
-    def type_recall(name, canbegroup)
-      if r = @rules[name]
-        t = r_process(name, r)
-        unless t[0] == :type1
-          fail "#{name} not a type" unless canbegroup && t[0] == :grpent
-        end
+    def type_recall(name, canbegroup, genericargs)
+      # p genericargs, "GENERIC"
+      if genericargs && (generic = @generics[name])
+        t = g_process(name, generic, genericargs)
+        t
+      elsif !genericargs && (t = rule_lookup(name, canbegroup))
         t
       else
-        fail "Unknown type #{name}"
+        fail "Unknown type #{name} #{genericargs.inspect} #{@bindings} #{@abnf.ast?}"
       end
     end
 
-    def group_recall(name)
-      if r = @rules[name]
-        g = r_process(name, r)
+    def group_recall(name, genericargs)
+      if genericargs && (generic = @generics[name])
+        g = g_process(name, generic, genericargs)
+        fail "#{name} not a group" unless g[0] == :grpent
+        g[1..-1]
+      elsif !genericargs && (g = rule_lookup(name, true))
         fail "#{name} not a group" unless g[0] == :grpent
         g[1..-1]
       else
@@ -539,7 +562,8 @@ module CDDL
       elsif v = n.value
         value(n)
       elsif v = n.typename
-        t = type_recall(v.to_s, canbegroup)
+        ga = n.genericarg || (n.s && n.s.genericarg) # workaround
+        t = type_recall(v.to_s, canbegroup, ga)
         if t[0] == :type1
           if t.size == 2
             t = t[1]
@@ -614,7 +638,7 @@ module CDDL
           [type, *s]
         when /\A&/
           if gn = n.groupname
-            s = group_recall(gn.to_s).flatten(1)
+            s = group_recall(gn.to_s, n.genericarg).flatten(1)
           else
             @insides << :enum
             s = n.children(:group).flat_map {|ch| group(ch)}

data/test/test-cddl.rb

@@ -373,7 +373,7 @@ HERE
     assert_equal "foo", parser.generate
   end
 
-  
+
   def test_validate_number_key
     parser = CDDL::Parser.new <<HERE
 test = [test1, test2, test3]
@@ -718,4 +718,97 @@ HERE
     pp parser1.generate
   end
 
+
+  def test_generic1
+    parser = CDDL::Parser.new <<HERE
+d = a<1>
+a<b> = b
+HERE
+    assert_equal 1, parser.generate
+  end
+
+  def test_generic_group
+    parser = CDDL::Parser.new <<HERE
+d = a<mygr>
+a<gr> = { gr }
+mygr = (
+1 => 2
+)
+HERE
+    assert_equal({1 => 2}, parser.generate)
+  end
+
+  def test_generic_transitive
+    parser = CDDL::Parser.new <<HERE
+d = a<mygr>
+a<gr> = { b<gr> }
+b<foo> = foo
+mygr = (
+1 => 2
+)
+HERE
+    assert_equal({1 => 2}, parser.generate)
+  end
+
+  def test_generic_realistic
+    parser = CDDL::Parser.new <<HERE
+start = [request, response]
+request = message<0>
+response = message<1>
+message<code> = {
+  code: code
+  data: "hallo data"
+}
+HERE
+    assert_equal([{"code"=>0, "data"=>"hallo data"},
+                  {"code"=>1, "data"=>"hallo data"}], parser.generate)
+  end
+
+  def test_generic_enum
+    parser = CDDL::Parser.new <<HERE
+color<foo> = &foo
+color = 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
+
 end

metadata

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