cddl 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bc6439f876088c1d9355f78363bfa34eaa844613
+  data.tar.gz: eb88cc041f3a03ef495aeecf4b663af0a2384673
+SHA512:
+  metadata.gz: 449e97a60fb3ee5584b582dc8da13d54de607f99ce02020a5565d7495142a8547965429b9d429582a2c898f8c6680a64d089339ff6c8fe4def07887da9ddd782
+  data.tar.gz: af6dd64fe9c1267fe4f86fbf4825e7da9faa4be03545991369b647c5766e5735fb1c760341bdf0afb7a4f07f3f7f06279bb1e900c459795eaf150c5c76cbb9a1

data/bin/cddl

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+require 'cddl'
+require 'cbor-diagnostic'
+require 'json'
+
+Encoding.default_external = "UTF-8" # wake up, smell the coffee
+
+def usage
+  warn "Usage:"
+  warn "#$0 spec.cddl generate [n]"
+  warn "#$0 spec.cddl json-generate [n]"
+  warn "#$0 spec.cddl validate instance.cbor"
+  warn "#$0 spec.cddl validate instance.json"
+  exit 1
+end
+
+case ARGV[1]
+when /\Ag/
+  parser = CDDL::Parser.new(File.read(ARGV[0]))
+  n = 1
+  n = ARGV[2].to_i if ARGV[2]
+  n.times do
+    g = parser.generate
+    puts g.cbor_diagnostic
+  end
+when /\Aj/
+  parser = CDDL::Parser.new(File.read(ARGV[0]))
+  n = 1
+  n = ARGV[2].to_i if ARGV[2]
+  n.times do
+    g = parser.generate
+    puts JSON.pretty_generate(g)
+  end
+when /\Av/
+  parser = CDDL::Parser.new(File.read(ARGV[0]))
+  instance = File.read(ARGV[2])
+  instance = CBOR.decode(instance) rescue JSON.load(instance)
+  p parser.validate(instance)
+else
+  usage
+end

data/cddl.gemspec

@@ -0,0 +1,19 @@
+spec = Gem::Specification.new do |s|
+  s.name = 'cddl'
+  s.version = '0.1.0'
+  s.summary = "CDDL generator and validator."
+  s.description = %{A parser, generator, and validator for CDDL}
+  s.add_dependency('cbor-diag')
+  s.add_dependency('abnc')
+  s.add_dependency('json')
+  s.files = `git ls-files`.split("\n").grep(/^[a-z]/)
+  s.files = Dir['lib/**/*.rb'] + %w(cddl.gemspec) + Dir['data/**/*.abnf'] + Dir['data/**/*.cddl'] + Dir['test-data/**/*.cddl'] + Dir['test/**/*.rb']
+  s.require_path = 'lib'
+  s.executables = ['cddl']
+  s.default_executable = 'cddl'
+  s.required_ruby_version = '>= 1.9.2'
+  s.author = "Carsten Bormann"
+  s.email = "cabo@tzi.org"
+  s.homepage = "http://github.com/cabo/cddl"
+  s.license = 'MIT'
+end

data/data/cddl.abnf

@@ -0,0 +1,62 @@
+cddl = S 1*rule
+rule = typename S "=" S type S
+     / groupname S "=" S group S
+
+typename = id
+groupname = id
+
+type = type1 S *("/" S type1 S)
+
+type1 = value
+     / "#" "6" ["." uint] "(" S type S ")" ; note no space!
+     / "#" DIGIT ["." uint]                ; major/ai
+     / "#"                                 ; any
+     / "{" S group S "}"
+     / "[" S group S "]"
+     / "(" type ")"
+     / typename
+
+group = "(" S *grpent S ")"
+      / *grpent
+
+grpent = [occur S] [memberkey S] type1 optcom
+       / [occur S] groupname optcom       ; always preempted by previous...
+
+memberkey = membername S ":"
+membername = bareword              ; note that this can be a typename
+           / type1                 ; can be preempted by previous...
+
+bareword = id
+
+optcom = S ["," S]
+
+occur = [uint] "*" [uint]
+      / "+"
+      / "?"
+
+uint = "0"
+     / DIGIT1 *DIGIT
+
+value = int
+      / float
+      / string
+
+int = ["-"] uint
+
+float = int ["." 1*DIGIT] ["e" int ]
+
+string = %x22 *SCHAR %x22
+SCHAR = %x20-21 / %x23-7E / SESC
+SESC = "\" %x20-7E
+
+id = ALPHA *(ALPHA / DIGIT / "_" / "-")
+ALPHA = %x41-5A / %x61-7A
+DIGIT = %x30-39
+DIGIT1 = %x31-39
+S = *WS
+WS = SP / NL
+SP = %x20
+NL = COMMENT / CRLF
+COMMENT = ";" *(SP / VCHAR) CRLF
+VCHAR = %x21-7E
+CRLF = %x0A / %x0D.0A

data/data/prelude.cddl

@@ -0,0 +1,43 @@
+; --- prelude ---
+
+any = #
+
+uint = #0
+nint = #1
+int = uint / nint
+
+bstr = #2
+tstr = #3
+
+tdate = #6.0(tstr)
+time = #6.1(number)
+number = int / float
+biguint = #6.2(bstr)
+bignint = #6.3(bstr)
+bigint = biguint / bignint
+integer = int / bigint
+decfrac = #6.4([e10: int, m: integer])
+bigfloat = #6.5([e2: int, m: integer])
+eb64url = #6.21(any)
+eb64legacy = #6.21(any)
+eb16 = #6.21(any)
+encoded-cbor = #6.24(bstr)
+uri = #6.32(tstr)
+b64url = #6.33(tstr)
+b64legacy = #6.34(tstr)
+regexp = #6.35(tstr)
+mime-message = #6.36(tstr)
+cbor-any = #6.55799(any)
+
+float16 = #7.25
+float32 = #7.26
+float64 = #7.27
+float16-32 = float16 / float32
+float32-64 = float32 / float64
+float = float16-32 / float64
+
+false = #7.20
+true = #7.21
+nil = #7.22
+undefined = #7.23
+

data/lib/cddl.rb

@@ -0,0 +1,442 @@
+require 'abnc'
+require 'pp'
+require 'pathname'
+
+module CDDL
+
+  DATA_DIR = Pathname.new(__FILE__).split[0] + '../data'
+
+  PRELUDE = File.read("#{DATA_DIR}/prelude.cddl")
+  ABNF_SPEC = File.read("#{DATA_DIR}/cddl.abnf")
+
+  class Parser
+    def initialize(source_text)
+      @abnf = Peggy::ABNF.new
+      _cresult = @abnf.compile! ABNF_SPEC, ignore: :s
+      presult = @abnf.parse? :cddl, (source_text + PRELUDE)
+      expected_length = source_text.length + PRELUDE.length
+      if expected_length != presult
+        upto = @abnf.parse_results.keys.max
+        puts "UPTO: #{upto}"
+        pp @abnf.parse_results[upto]
+        pp @abnf.parse_results[presult]
+        p presult
+        puts @abnf.ast?
+        raise "parse error at #{presult} upto #{upto} of #{expected_length}"
+      end
+      puts @abnf.ast? if $debug_ast
+      @ast = @abnf.ast?
+    end
+
+    def apr                     # for debugging
+      @abnf.parse_results
+    end
+
+    def rules
+      @rules = {}
+      ast.each :rule do |rule|
+        # p rule
+        if rulename = rule.groupname
+          fail "Duplicate rule #{rulename.to_s}" if @rules[rulename.to_s]
+          @rules[rulename.to_s] = [:grpent, *rule.group.children(:grpent)]
+        elsif rulename = rule.typename
+          fail "Duplicate rule #{rulename.to_s}" if @rules[rulename.to_s]
+          @rules[rulename.to_s] = [:type1, *rule.type.children(:type1)]
+        else
+          fail "Huh?"
+        end
+      end
+      # pp @rules
+      @rootrule = @rules.keys.first
+      # now process the rules...
+      @stage1 = {}
+      r_process(@rootrule, @rules[@rootrule])
+      # @rules.each do |n, r|     # debug only loop
+      #   r_process(n, r)
+      # end
+      # @stage1
+    end
+
+    def generate(where=rules, inmap = false)
+      case where[0]
+      when :type1
+        generate(where[rand(where.size-1)+1])
+      when :map
+        Hash[where[1..-1].flat_map {|m| generate(m, true)}]
+      when :array
+        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
+        s += rand(e + 1 - s) if e != s
+        kr = where[3]
+        vr = where[4]
+        fail "member key not given in map for #{where}" unless kr if inmap
+        Array.new(s) { [ (generate(kr) if kr), # XXX: need error in map context
+                         generate(vr)
+                       ]}
+      when :string, :int, :float
+        where[1]
+      when :prim
+        case where[1]
+        when nil
+          gen_word
+        when 0
+          rand(4711)
+        when 1
+          ~rand(815)
+        when 2
+          gen_word.force_encoding(Encoding::BINARY)
+        when 3
+          gen_word
+        when 7
+          case where[2]
+          when nil
+            Math::PI
+          when 20
+            false
+          when 21
+            true
+          when 22
+            nil
+          when 23
+            :undefined
+          when 25, 26, 27
+            rand()
+          end
+        else
+          fail "Can't generate prim #{where[1]}"
+        end
+      else
+        # fail where
+      end
+    end
+
+    VALUE_TYPE = {string: true, int: true, float: true}
+    SIMPLE_VALUE = {
+      [:prim, 7, 20] => [true, false],
+      [:prim, 7, 21] => [true, true],
+      [:prim, 7, 22] => [true, nil],
+      [:prim, 7, 23] => [true, :undefined],
+    }
+
+    def extract_value(t)
+      if VALUE_TYPE[t[0]]
+        [true, t[1]]
+      elsif v = SIMPLE_VALUE[t]
+        v
+      else
+        [false]
+      end
+    end
+
+    def validate_diag
+      [@last_data, @last_rule, @last_message]
+    end
+
+    def validate(d, warn=true)
+      result = validate1(d)
+      unless result
+        if warn
+          warn "CDDL validation failure:"
+          PP::pp(validate_diag, STDERR)
+        end
+      end
+      result
+    end
+
+    def validate_result(check)
+      check || (
+        @last_message = yield
+        false
+      )
+    end
+
+    def validate1(d, where=rules)
+#      puts "DATA: #{d.inspect}"
+#      puts "RULE: #{where.inspect}"
+      @last_data = d
+      @last_rule = where
+      case where[0]
+      when :type1
+        where[1..-1].any? {|r| validate1(d, r)}
+      when :map
+        if Hash === d
+          d_check = d.dup
+          where[1..-1].all? { |r|
+            # puts "SUBRULE: #{r.inspect}"
+            t, s, _e, k, v = r
+            fail unless t == :member
+            # 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}"
+              # add occurrence check; check that val is present in the first place
+              actual = d.fetch(simpleval, :not_found)
+              if actual == :not_found
+                s == 0          # minimum occurrence must be 0 then
+              else
+                validate1(actual, v) && d_check.delete(simpleval)
+              end
+            else
+#              puts "COMPLEX: #{k.inspect} #{simple.inspect} #{simpleval.inspect}"
+              keys = d_check.keys
+              ta, keys = keys.partition{ |key| validate1(key, k)}
+              # XXX check ta.size against s/e
+              ta.all? { |val|
+                validate1(d[val], v) && d_check.delete(val)
+              }
+            end
+          } && d_check == {}
+        end
+      when :array
+        if Array === d
+          # validate1 against the record
+          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
+          }
+          validate_result(i == d.size) { "cannot complete array #{d} for #{where}" }
+        end
+      when :string, :int, :float
+        _, v = extract_value(where)
+        d == v
+      when :prim
+        case where[1]
+        when nil
+          true
+        when 0
+          Integer === d && d >= 0 && d <= 0xffffffffffffffff
+        when 1
+          Integer === d && d < 0 && d >= -0x10000000000000000
+        when 2
+          String === d && d.encoding == Encoding::BINARY
+        when 3
+          String === d && d.encoding != Encoding::BINARY # cheat
+        when 7
+          t, v = extract_value(where)
+          if t
+            v == d
+          else
+            case where[2]
+            when nil
+              # XXX
+              fail
+            when 25, 26, 27
+              Float === d
+            else
+              fail
+            end
+          end
+
+        else
+          fail "Can't generate prim #{where[1]}"
+        end
+      else
+        # fail where
+      end
+    end
+
+
+    attr_reader :ast
+
+    private
+
+    def gen_word
+      @words ||= File.read("/usr/share/dict/words").lines.shuffle
+      @wordptr ||= 0
+      @wordptr = 0 if @wordptr == @words.size
+      w = @words[@wordptr].chomp
+      @wordptr += 1
+      w
+    end
+
+    # XXX needs serious memoizing
+
+    def r_process(n, r)
+      t = r[0]
+      # puts "Processing rule #{n} = #{t}"
+      @stage1[n] ||= [t, *r[1..-1].map {|e| send(t, e)}]
+    end
+
+    def value(n)
+      # cheat:
+      val = eval(n.to_s)
+      [case val
+       when Integer; :int
+       when Numeric; :float
+       when String; :string
+       else fail "huh? value #{val.inspect}"
+       end, val]
+    end
+
+    def grpent(n)               # returns array of entries
+      occ = occur(n.occur)
+      if mk = n.memberkey       # work around unclear bug in ast generation
+        [[:member, *occ, label(mk.membername), type1(n.type1)]]
+      else
+        # fail n.inspect unless n.type1
+        t = if n.membername # work around unclear bug, part 2
+          type1(n.membername.type1, true)
+        else
+          type1(n.type1, true)              # type1 can be a group here!
+        end
+        if t[0] == :grpent
+          # XXX 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
+              t2[1..-1]
+            end
+          }.map {|mem|
+            # p mem
+            mem[1] *= occ[0]
+            mem[2] *= [occ[1], -1].max
+            # p mem
+            mem
+          }
+        else
+          [[:member, *occ, nil, t]]
+        end
+      end
+    end
+
+    def label(n)
+      # if this is not a rulename, it's a bareword
+      name = n.to_s
+      if r = @rules[name]
+        r_process(name, r)
+      else
+        [:string, name]
+      end
+    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
+        t
+      else
+        fail "Unknown type #{name}"
+      end
+    end
+
+    def group_recall(name)
+      if r = @rules[name]
+        g = r_process(name, r)
+        fail "#{name} not a group" unless g[0] == :grpent
+        g[1..-1]
+      else
+        fail "Unknown group #{name}"
+      end
+    end
+
+    BRACE = {"{" => :map, "[" => :array}
+
+    def type1(n, canbegroup = false)
+#      puts "NVALUE #{n.value.inspect}"
+      if v = n.value
+        value(n)
+      elsif v = n.typename
+        t = type_recall(v.to_s, canbegroup)
+        if t[0] == :type1
+          if t.size == 2
+            t = t[1]
+          else
+            t = [:type1, *t[1..-1].flat_map {|t1|
+                   if t1[0] == :type1
+                     t1[1..-1]
+                   else
+                     [t1]
+                   end
+                 }]
+
+          end
+        end                     # XXX should flatten the thing, too
+        t
+      else
+        case str = n.to_s
+        when "#"
+          [:prim]
+        when /\A#(\d+)/
+          maj = $1.to_i
+          s = [:prim, maj, *n.children(:uint).map(&:to_s).map(&:to_i)]
+          if tagged_type = n.type
+              s << type(tagged_type)
+          end
+          s
+        when /\A\(/
+          type(n.type)
+        when /\A[\[{]/
+          s = n.children(:group).flat_map {|ch| group(ch)}
+          type = BRACE[str[0]]
+          if type == :map
+            s.each do |member|
+              fail unless member[0] == :member
+              fail "map entry without member key given: #{member}" unless member[3]
+            end
+          end
+          [type, *s]
+        else
+          "unimplemented #{n}"
+        end
+      end
+    end
+
+    def type(n)
+      s = n.children(:type1).map {|ch| type1(ch)}
+      if s.size == 1
+        s.first
+      else
+        [:type1, *s]
+      end
+    end
+
+    def group(n)                # returns array
+      n.children(:grpent).flat_map {|ch| grpent(ch)}
+    end
+
+    def occur(n)
+      case n.to_s
+      when ""
+        [1, 1]
+      when "+"
+        [1, -1]
+      when "?"
+        [0, 1]
+      when /\A(\d*)\*(\d*)\z/
+        if (s = $1) == ""
+          s = 0
+        else
+          s = s.to_i
+        end
+        if (e = $2) == ""
+          e = -1
+        else
+          e = e.to_i
+        end
+        [s, e]
+      else
+        fail "huh #{n.to_s}"
+      end
+    end
+
+  end
+end

data/test-data/7071-concise.cddl

@@ -0,0 +1,17 @@
+reputation-object = {
+  application: tstr
+  reputons: [* reputon]
+}
+
+reputon = {
+  rater: tstr
+  assertion: tstr
+  rated: tstr
+  rating: float16
+  ? confidence: float16
+  ? normal-rating: float16
+  ? sample-size: uint
+  ? generated: uint
+  ? expires: uint
+  * any: any
+}

data/test-data/7071-verbose.cddl

@@ -0,0 +1,42 @@
+
+
+reputation-object = {
+  reputation-context,
+  reputon-list
+}
+
+reputation-context = (
+  application: tstr
+)
+
+reputon-list = (
+  reputons: reputon-array
+)
+
+reputon-array = [* reputon]
+
+reputon = {
+  rater-value,
+  assertion-value,
+  rated-value,
+  rating-value,
+  ? conf-value,
+  ? normal-value,
+  ? sample-value,
+  ? gen-value,
+  ? expire-value,
+  * ext-value,
+}
+
+rater-value = ( rater: tstr )
+assertion-value = ( assertion: tstr )
+rated-value = ( rated: tstr )
+rating-value = ( rating: float16 )
+conf-value = ( confidence: float16 )
+normal-value = ( normal-rating: float16 )
+sample-value = ( sample-size: uint )
+gen-value = ( generated: uint )
+expire-value = ( expires: uint )
+ext-value = ( any: any )
+
+

data/test/test-cddl.rb

@@ -0,0 +1,292 @@
+require 'test/unit'
+require 'pathname'
+
+require 'cbor-pretty.rb'
+require 'cbor-diagnostic.rb'
+
+require_relative '../lib/cddl'
+
+
+class TestABNF < Test::Unit::TestCase
+
+  TEST_DATA_DIR = Pathname.new(__FILE__).split[0] + '../test-data'
+
+  EXPECTED_RULES = [:type1,
+ [:map,
+  [:member, 1, 1, [:string, "application"], [:prim, 3]],
+  [:member,
+   1,
+   1,
+   [:string, "reputons"],
+   [:array,
+    [:member,
+     0,
+     -1,
+     nil,
+     [:map,
+      [:member, 1, 1, [:string, "rater"], [:prim, 3]],
+      [:member, 1, 1, [:string, "assertion"], [:prim, 3]],
+      [:member, 1, 1, [:string, "rated"], [:prim, 3]],
+      [:member, 1, 1, [:string, "rating"], [:prim, 7, 25]],
+      [:member, 0, 1, [:string, "confidence"], [:prim, 7, 25]],
+      [:member, 0, 1, [:string, "normal-rating"], [:prim, 7, 25]],
+      [: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]]]]]]]]
+
+  def test_aa_rfc7071_concise
+    parser1 = CDDL::Parser.new(File.read("#{TEST_DATA_DIR}/7071-concise.cddl"))
+    assert_equal EXPECTED_RULES, parser1.rules
+  end
+
+  def test_aa_rfc7071_verbose
+    parser2 = CDDL::Parser.new(File.read("#{TEST_DATA_DIR}/7071-verbose.cddl"))
+    assert_equal EXPECTED_RULES, parser2.rules
+    3.times do
+      # puts CBOR::pretty(CBOR::encode(parser2.generate(EXPECTED_RULES)))
+      puts parser2.generate.cbor_diagnostic
+    end
+  end
+
+  def test_validate
+    parser1 = CDDL::Parser.new(File.read("test-data/7071-concise.cddl"))
+    g = parser1.generate
+    pp g
+    assert parser1.validate(g)
+    old = g["application"]
+    g["application"] = 4711
+    refute parser1.validate(g, false)
+    g["application"] = old
+    g["reputons"] << 5712
+    refute parser1.validate(g, false)
+  end
+
+  def test_validate_1
+    parser = CDDL::Parser.new <<HERE
+test = 1
+HERE
+    assert parser.validate(1)
+  end
+
+  def test_validate_a
+    parser = CDDL::Parser.new <<HERE
+test = [* one: 1]
+HERE
+    assert parser.validate([])
+    assert parser.validate([1])
+    assert parser.validate([1, 1])
+    refute parser.validate([1, 2], false)
+    refute parser.validate([2, 1], false)
+  end
+
+  def test_validate_a_string
+    parser = CDDL::Parser.new <<HERE
+test = [* one: "one"]
+HERE
+    assert parser.validate([])
+    assert parser.validate(["one"])
+    assert parser.validate(["one", "one"])
+    refute parser.validate([1], false)
+    refute parser.validate(['two'], false)
+    refute parser.validate(["one", "two"], false)
+  end
+
+
+  def test_validate_a_string_string
+    parser = CDDL::Parser.new <<HERE
+test = [* "two": "one"]
+HERE
+    assert parser.validate([])
+    assert parser.validate(["one"])
+    assert parser.validate(["one", "one"])
+    refute parser.validate([1], false)
+    refute parser.validate(['two'], false)
+    refute parser.validate(["one", "two"], false)
+  end
+
+  def test_validate_a_once
+    # $debug_ast = true
+    parser = CDDL::Parser.new <<HERE
+test = [1]
+HERE
+    # puts "RULES:"
+    # pp parser.rules
+    # puts "APR:"
+    # pp parser.apr
+    refute parser.validate([], false)
+    assert parser.validate([1])
+    refute parser.validate([1, 1], false)
+    refute parser.validate([1, 2], false)
+    refute parser.validate([2, 1], false)
+  end
+
+  def test_validate_unknown_key
+    # $debug_ast = true
+    parser = CDDL::Parser.new <<HERE
+test = { 1, 2 }
+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_validate_not_unknown_key
+    # $debug_ast = true
+    parser = CDDL::Parser.new <<HERE
+test = [ 1, 2 ]
+HERE
+    # puts "RULES:"
+    # pp parser.rules
+    # puts "APR:"
+    # pp parser.apr
+    assert_equal [1, 2], parser.generate()
+    refute parser.validate({}, false)
+    refute parser.validate([], false)
+    refute parser.validate([1], false)
+    assert parser.validate([1, 2])
+  end
+
+  
+  def test_validate_not_unknown_key_paren
+    # $debug_ast = true
+    parser = CDDL::Parser.new <<HERE
+test = [ (1, 2) ]
+HERE
+    # puts "RULES:"
+    # pp parser.rules
+    # puts "APR:"
+    # pp parser.apr
+    assert_equal [1, 2], parser.generate()
+    refute parser.validate({}, false)
+    refute parser.validate([], false)
+    refute parser.validate([1], false)
+    assert parser.validate([1, 2])
+  end
+
+
+  def test_validate_alternate3  # XXX need indirection for now
+    # $debug_ast = true
+    parser = CDDL::Parser.new <<HERE
+test = [* test1]
+test1 = (one: 1, two: 2)
+HERE
+    # puts "RULES:"
+    # pp parser.rules
+    # puts "APR:"
+    # 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)
+    refute parser.validate([1, 2, 1], false)
+  end
+
+  def test_validate_occur1  # XXX need indirection for now
+    # $debug_ast = true
+    parser = CDDL::Parser.new <<HERE
+test = [test1]
+test1 = (one: 1, two: 2)
+HERE
+    # puts "RULES:"
+    # pp parser.rules
+    # puts "APR:"
+    # pp parser.apr
+    refute parser.validate([], false)
+    refute parser.validate([1], false)
+    assert parser.validate([1, 2])
+    refute parser.validate([2, 1], false)
+    refute parser.validate([1, 1, 2, 2], false)
+    refute parser.validate([1, 2, 1, 2], false)
+    refute parser.validate([1, 2, 1], false)
+  end
+
+  def test_validate_occur01  # XXX need indirection for now
+    # $debug_ast = true
+    parser = CDDL::Parser.new <<HERE
+test = [? test1]
+test1 = (one: 1, two: 2)
+HERE
+    # puts "RULES:"
+    # pp parser.rules
+    # puts "APR:"
+    # pp parser.apr
+    assert parser.validate([])
+    assert parser.validate([1])
+    assert parser.validate([1, 2])
+    refute parser.validate([2, 1], false)
+    refute parser.validate([1, 1, 2, 2], false)
+    refute parser.validate([1, 2, 1, 2], false)
+    refute parser.validate([1, 2, 1], false)
+  end
+
+  def test_validate_occur1n  # XXX need indirection for now
+    # $debug_ast = true
+    parser = CDDL::Parser.new <<HERE
+test = [+ test1]
+test1 = (one: 1, two: 2)
+HERE
+    # puts "RULES:"
+    # pp parser.rules
+    # puts "APR:"
+    # pp parser.apr
+    refute parser.validate([], false)
+    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, 2, 1], false)
+  end
+
+  def test_validate_occur0n  # XXX need indirection for now
+    # $debug_ast = true
+    parser = CDDL::Parser.new <<HERE
+test = [* test1]
+test1 = (one: 1, two: 2)
+HERE
+    # puts "RULES:"
+    # pp parser.rules
+    # puts "APR:"
+    # pp parser.apr
+    assert parser.validate([])
+    assert parser.validate([1])
+    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, 2, 1], false)
+  end
+
+  
+  def test_validate_occur23  # XXX need indirection for now
+    # $debug_ast = true
+    parser = CDDL::Parser.new <<HERE
+test = [2*3 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)
+    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)
+    refute parser.validate([1, 2, 1], false)
+  end
+
+
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: cddl
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Carsten Bormann
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cbor-diag
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: abnc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A parser, generator, and validator for CDDL
+email: cabo@tzi.org
+executables:
+- cddl
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/cddl
+- cddl.gemspec
+- data/cddl.abnf
+- data/prelude.cddl
+- lib/cddl.rb
+- test-data/7071-concise.cddl
+- test-data/7071-verbose.cddl
+- test/test-cddl.rb
+homepage: http://github.com/cabo/cddl
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: CDDL generator and validator.
+test_files: []
+has_rdoc: