cddl 0.6.2 → 0.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e5369f34b05a1ece8d8f11f3b4a04d704928850e
-  data.tar.gz: a35dff8b713d0a6baca7bca0554fdfad498fd490
+  metadata.gz: 7ed6608fc505b18aec7d8e30bac4b1faca1265da
+  data.tar.gz: 46a78ea14fc09cc01a56ca63320e2f8a9de175d3
 SHA512:
-  metadata.gz: 8d21bb24a81af9f70f698e97f38e96fa3ae37bc904841f3f29abf246b013a450816a28612729e0b82c0505a376603330156c7666e943e39ad296422c581cc818
-  data.tar.gz: 086513c70f53d7b21e7e8447f36002aa05cab7e66d1f744711600967bd0fbfad3741d318c00e4696cbbaa8b5e82ff16b440e5dd1b79129fc717c2674b5ff81f0
+  metadata.gz: c941909e3cf4064ae0fbcb3f94e8bb54a10da19c294f1b6a7d5152cb0dd653a7ac6652f11bddc3d2a0e30a8679e823585b235acdf3479e660a66ba33b793e069
+  data.tar.gz: 2dd6ad6d49ab40dc1ccba874ee722aa3e490075886f8af51255ad33b5656c0b5c009f326727689f36f0ebd2cc7a30944e69209c6340fead7277a8294dc2878ba

data/bin/cddl

@@ -1,5 +1,6 @@
 #!/usr/bin/env ruby
 # -*- coding: utf-8 -*-
+# require_relative '../lib/cddl'
 require 'cddl'
 require 'cbor-diagnostic'
 require 'json'
@@ -28,17 +29,44 @@ def parser
   @parser ||= CDDL::Parser.new(read_arg(ARGV[0]))
 end
 
+def my_pp(v)
+  if $annotate
+    CBOR::PP.pp v
+  else
+    pp v
+  end
+end
+
+def my_diag(v)
+  if $annotate
+    CBOR::PP.pp v
+  else
+    puts v.cbor_diagnostic
+  end
+end
+
 begin
+  case ARGV[1]
+  when /\A.p/
+    $annotate = true
+    require_relative '../lib/cbor-pp'
+  end
   case ARGV[1]
   when /\Ar/                      # secret
     $advanced = true
-    pp parser.rules
+    my_pp parser.rules
   when /\Ag/
     n = 1
     n = ARGV[2].to_i if ARGV[2]
     n.times do
       g = parser.generate
-      puts g.cbor_diagnostic
+      if $annotate
+        g = g.cbor_clone if ENV["EXPERIMENTAL_ANNOTATE"]
+        ann = parser.validate(g)
+        # my_pp ann
+        g.cbor_add_annotations_from(ann) rescue nil
+      end
+      my_diag(g)
     end
   when /\Aj/
     n = 1
@@ -50,7 +78,11 @@ begin
   when /\Av/
     instance = read_arg(ARGV[2])
     instance = CBOR.decode(instance.b) rescue JSON.load(instance)
-    p parser.validate(instance)
+    instance = instance.cbor_clone if $annotate && ENV["EXPERIMENTAL_ANNOTATE"]
+    ann = parser.validate(instance)
+    # my_pp ann
+    instance.cbor_add_annotations_from(ann) rescue nil
+    my_diag(instance) if $annotate
   else
     usage
   end

data/cddl.gemspec

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

data/data/prelude.cddl

@@ -11,7 +11,7 @@ bytes = bstr
 tstr = #3
 text = tstr
 
-tdate = #6.0(tstr)
+tdate = #6.0(tstr .regexp "\\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[1-2]\\d|3[0-1])[Tt]([0-1]\\d|2[0-3]):([0-5]\\d):([0-5]\\d)(\\.\\d+)?([Zz]|[+\\-](?:[0-1]\\d|2[0-3]):[0-5]\\d)")
 time = #6.1(number)
 number = int / float
 biguint = #6.2(bstr)

data/lib/cbor-pp-play.rb

@@ -0,0 +1,13 @@
+require_relative "cbor-pp"
+
+a = [1, {foo: "bar", busel: "basel", baz: "bass", ant: "cat", bat: "dog", eel: "fox"},
+             2, 3, 4, [3]*55, "foo".b, 0.00006103515625, 0.0000099, 1e-7, nil]
+a[1].cbor_annotation_add "fasel"
+CBOR::PP.pp a
+
+a = [1, "baz", 3]
+a.cbor_annotation_add "foo"
+a[1].cbor_annotation_add "bar"
+CBOR::PP.pp(a)
+
+p 1.cbor_annotation_format

data/lib/cbor-pp.rb

@@ -0,0 +1,180 @@
+require 'prettyprint'
+require 'cbor-diagnostic'
+require 'delegate'
+
+class CBOR::PP < PrettyPrint
+  # Outputs +obj+ to +out+ in pretty printed format of
+  # +width+ columns in width.
+  #
+  # If +out+ is omitted, <code>$></code> is assumed.
+  # If +width+ is omitted, 79 is assumed.
+  #
+  # CBOR::PP.pp returns +out+.
+  def self.pp(obj, out=$>, width=79)
+    q = new(out, width)
+    q.pp obj
+    q.flush
+    #$pp = q
+    out << "\n"
+  end
+
+  module PPMethods
+    # Adds +obj+ to the pretty printing buffer
+    # using Object#cbor_pp.
+    def pp(obj)
+      group {obj.cbor_pp self}
+    end
+
+    # XXX: a nested group that is broken should not have things added at the end
+    def comma_breakable
+      text ','
+      fill_breakable
+    end
+
+    def seplist(list, sep=nil, iter_method=:each) # :yield: element
+      sep ||= lambda { comma_breakable }
+      first = true
+      list.__send__(iter_method) {|*v|
+        if first
+          first = false
+        else
+          sep.call
+        end
+        yield(*v)
+      }
+    end
+
+    # A pretty print for a Hash
+    def pp_hash(obj, anno)
+      s = "#{anno}{"
+      group(1, s, '}') {
+        seplist(obj, nil, :each_pair) {|k, v|
+          group {
+            pp k
+            text ':'
+            group(1) {
+              breakable ' '
+              pp v
+            }
+          }
+        }
+      }
+    end
+  end
+
+  include PPMethods
+
+  module ObjectMixin # :nodoc:
+    def cbor_pp(q)
+      if @cbor_annotation
+        q.text cbor_annotation_format
+      end
+      q.text cbor_diagnostic
+    end
+    def cbor_annotation_add(v)
+      unless frozen?
+        @cbor_annotation ||= []
+        @cbor_annotation << v unless @cbor_annotation.include? v
+      end
+    end
+    def cbor_annotation_replace(v)
+      @cbor_annotation = [v]
+    end
+    def cbor_annotations
+      @cbor_annotation
+    end
+    def cbor_annotation_format
+      if @cbor_annotation
+        "/" << @cbor_annotation.join(", ") << "/ "
+      end
+    end
+    def cbor_add_annotations_from(ann_list)
+      _data, anno = ann_list.find{|data, _anno| equal?(data)}
+      f = anno.cbor_annotations
+      f.each {|a| cbor_annotation_add(a)} if f
+    end
+    def cbor_clone
+      if frozen?
+        CBOR::PP::Cloak.new(self)
+      else
+        self
+      end
+    end
+    def eql?(other)
+      if other.respond_to? :__getobj__
+        eql? other.__getobj__
+      else
+        super
+      end
+    end
+  end
+
+  def self.add_annotations(tree, ann_list)
+    tree.cbor_add_annotations_from(ann_list)
+  end
+
+  class Cloak < ::SimpleDelegator
+    def class
+      @delegate_sd_obj.class
+    end
+    include CBOR::PP::ObjectMixin
+  end
+end
+
+class Class
+  def ===(other)
+    if other.respond_to? :__getobj__
+      other.__getobj__.kind_of? self
+    else
+      other.kind_of? self
+    end
+  end
+end
+
+class Array # :nodoc:
+  def cbor_pp(q) # :nodoc:
+    s = "#{cbor_annotation_format}["
+    q.group(1, s, ']') {
+      q.seplist(self) {|v|
+        q.pp v
+      }
+    }
+  end
+  def cbor_add_annotations_from(ann_list)
+    super
+    each {|m| m.cbor_add_annotations_from(ann_list)}
+  end
+  def cbor_clone
+    map(&:cbor_clone)
+  end
+end
+
+class Hash # :nodoc:
+  def cbor_pp(q) # :nodoc:
+    q.pp_hash self, cbor_annotation_format
+  end
+  def cbor_add_annotations_from(ann_list)
+    super
+    each {|k, v| 
+      # k.cbor_add_annotations_from(ann_list)
+      v.cbor_add_annotations_from(ann_list)
+    }
+  end
+  def cbor_clone
+    to_a.cbor_clone.to_h
+  end
+end
+
+class Numeric
+  def eql?(other)
+    if other.respond_to? :__getobj__
+      eql? other.__getobj__
+    else
+      super
+    end
+  end
+end
+
+class Object < BasicObject # :nodoc:
+  include CBOR::PP::ObjectMixin
+end

data/lib/cddl.rb

@@ -377,10 +377,10 @@ module CDDL
 
     def validate(d, warn=true)
       @recursion = 0
-      result = validate1(d)
+      result = validate1a(d, rules)
       unless result
         if warn
-          warn "CDDL validation failure:"
+          warn "CDDL validation failure (#{result.inspect} for #{d.inspect}):"
           PP::pp(validate_diag, STDERR)
         end
       end
@@ -395,60 +395,72 @@ module CDDL
     end
 
     def validate_forward(d, start, where)
+      # warn ["valforw", d, start, where].inspect
       i = 0
+      ann = []
       where[1..-1].each { |r|
         t, s, e, _k, v = r # XXX
         if t == :recurse_grpent
           rule = lookup_recurse_grpent(s)
-          n = validate_linear(d, start+i, rule)
-          return false unless n
+          n, ann2 = validate_linear(d, start+i, rule)
+          return [false, ann] unless n
           i += n
+          ann.concat(ann2)
         elsif t == :grpchoice
-          return false unless r[1..-1].any? {|cand|
-            if n = validate_forward(d, start+i, [:foo, *cand])
+          return [false, ann] unless r[1..-1].any? {|cand|
+            n, ann2 = validate_forward(d, start+i, [:foo, *cand])
+            if n
               i += n
+              ann.concat(ann2)
             end}
         else
           fail r.inspect unless t == :member
           occ = 0
-          while ((occ < e) && i != d.size && (n = validate_linear(d, start+i, v)))
+          while ((occ < e) && i != d.size && ((n, ann2 = validate_linear(d, start+i, v)); n))
             i += n
             occ += 1
+            ann.concat(ann2)
           end
           if occ < s
             @last_message = "occur not reached in array #{d} for #{where}"
-            return false
+            return [false, ann]
           end
         end
       }
-      i
+      # warn ["valforw>", i].inspect
+      [i, ann]
     end
 
     # returns number of matches or false for breakage
     def validate_linear(d, start, where)
+      # warn ["vallin", d, start, where].inspect
       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
+        (ann = validate1a(d[start], where)) ? [1, ann] : [false, ann]
       end
     end
 
     def map_check(d, d_check, members)
-      members.all? { |r|
+      anno = []
+      anno if members.all? { |r|
         # puts "SUBRULE: #{r.inspect}"
-        t, s, _e, k, v = r
+        t, s, e, k, v = r
         case t
         when :recurse_grpent
           rule = lookup_recurse_grpent(s)
-          map_check(d, d_check, rule[1..-1])
+          if ann2 = map_check(d, d_check, rule[1..-1])
+            anno.concat(ann2)
+          end
         when :grpchoice
           r[1..-1].any? {|cand|
             cand_d_check = d_check.dup
-            if map_check(d, cand_d_check, cand)
+            if ann2 = map_check(d, cand_d_check, cand)
               d_check.replace(cand_d_check)
+              anno.concat(ann2)
             end
           }
         when :member
@@ -462,8 +474,20 @@ module CDDL
               fail "member name not known for group entry #{r} in map"
             end
             d_check1 = d_check.dup
-            # XXX this is ignoring occur = [s, _e]  FIXME!
-            return map_check(d, d_check1, entries) && d_check.replace(d_check1)
+            occ = 0
+            ann2 = []
+            while occ < e && (ann3 = map_check(d, d_check1, entries))
+              occ += 1
+              ann2.concat(ann3)
+            end
+            if occ >= s
+              d_check.replace(d_check1)
+              anno.concat(ann2)
+              return anno
+            else
+              # leave some diagnostic breadcrumbs?
+              return false
+            end
           end
           # this is mostly quadratic; let's do the linear thing if possible
           simple, simpleval = extract_value(k)
@@ -474,7 +498,10 @@ module CDDL
             if actual == :not_found
               s == 0          # minimum occurrence must be 0 then
             else
-              validate1(actual, v) && d_check.delete(simpleval)
+              if (ann2 = validate1a(actual, v)) &&
+                 d_check.delete(simpleval) {:not_found} != :not_found
+                anno.concat(ann2)
+              end
             end
           else
             #              puts "COMPLEX: #{k.inspect} #{simple.inspect} #{simpleval.inspect}"
@@ -482,7 +509,10 @@ module CDDL
             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)
+              if (ann2 = validate1a(d[val], v)) && 
+                 d_check.delete(val) {:not_found} != :not_found
+                anno.concat(ann2)
+              end
             }
           end
         else
@@ -491,42 +521,60 @@ module CDDL
       }
     end
 
-    def validate1(d, where=rules)
+    def validate1a(d, where)
+      if ann = validate1(d, where)
+        here = [d, where]
+        if Array === ann
+          [here, *ann]
+        else
+          [here]
+        end
+      end
+    end
+
+    def validate1(d, where)
 #      puts "DATA: #{d.inspect}"
 #      puts "RULE: #{where.inspect}"
+      # warn ["val1", d, where].inspect
       @last_data = d
       @last_rule = where
+      ann = nil
       case where[0]
       when :type1
-        where[1..-1].any? {|r| validate1(d, r)}
+        if where[1..-1].any? {|r| ann = validate1a(d, r)}
+          ann
+        end
       when :map
         if Hash === d
           d_check = d.dup
-          map_check(d, d_check, where[1..-1]) && d_check == {}
+          if (ann = map_check(d, d_check, where[1..-1])) && d_check == {}
+            ann
+          end
         end
       when :array
+        # warn ["valarr", d, where].inspect
         if Array === d
           # validate1 against the record
-          idx = validate_forward(d, 0, where)
-          validate_result(idx == d.size) { "cannot complete array #{d} for #{where}" }
+          idx, ann = validate_forward(d, 0, where)
+          ann if validate_result(idx == d.size) { "cannot complete array #{d} for #{where}" }
         end
       when :string, :int, :float
         _, v = extract_value(where)
-        d == v
+        [] if d == v
       when :range
-        where[2] === d && where[1].include?(d)
+        [] if where[2] === d && where[1].include?(d)
       when :anno
         target = where[2]
-        if validate1(d, target)
+        if ann = validate1a(d, target)
           control = where[3]
           case where[1]
           when :size
-            validate1(d.bytesize, control)
+            ann if validate1(d.bytesize, control)
           when :bits
             if String === d
               d.each_byte.with_index.all? { |b, i|
                 bit = i << 3
-                8.times.all? { |nb|
+                ann if 8.times.all? { |nb|
                   b[nb] == 0 || validate1(bit+nb, control)
                 }
               }
@@ -540,10 +588,11 @@ module CDDL
                   end
                   d >>= 1; i += 1
                 end
-                ok
+                ann if ok
               end
             end
           when :regexp
+            ann if (
             if String === d
               ok, v, vt = extract_value(control)
               if ok && vt == String
@@ -552,6 +601,7 @@ module CDDL
                 d.match(re)
               end
             end
+            )
           else
             fail "Don't know yet how to validate against #{where}"
           end
@@ -570,7 +620,7 @@ module CDDL
         when 3
           String === d && d.encoding != Encoding::BINARY # cheat
         when 6
-          CBOR::Tagged === d && d.tag == where[2] && validate1(d.data, where[3])
+          CBOR::Tagged === d && d.tag == where[2] && validate1a(d.data, where[3])
         when 7
           t, v = extract_value(where)
           if t
@@ -594,13 +644,15 @@ module CDDL
         rule = @stage1[name]
         if @recursion < MAX_RECURSE
           @recursion += 1
-          r = validate1(d, rule)
+          r = validate1a(d, rule)
           @recursion -= 1
           r
         else
           fail "Deep recursion into #{name}: #{rule}, not yet implemented"
         end
       else
+        @last_message = "Don't know how to validate #{where}"
+        false
         # fail where
       end
     end
@@ -671,6 +723,7 @@ module CDDL
                                 fail t
                               end}]
                        @bindings.pop
+                       r.cbor_annotation_add(n) rescue nil # AAA
                        r
                      end
     end
@@ -729,7 +782,10 @@ module CDDL
       else
         t = if nbw = nt.bareword
               t1 = nbw.type1 # || n.bareword.s.type.type1 # workaround
-              type1(t1, true)
+              rest = type_collect(nt, true)
+              s = [:type1, type1(t1, true), *rest]
+              # warn "T2: #{s.size} #{s}" -- maybe this should have a parenthesis warning?
+              s.size == 2 ? s[1] : s # decapsulate single-element choice
             else
               type(nt, true)              # type can actually be a group here!
             end
@@ -767,6 +823,9 @@ module CDDL
             if occ[0] == 0 && t == [:grpchoice]
               []                # we won't be able to generate any of those
             else
+              if t[0] == :grpchoice # FIXME: need to package grpchoice into grpent in a member
+                t = [:grpent, t]
+              end
               [[:member, *occ, nil, t]]
             end
           end
@@ -790,7 +849,7 @@ module CDDL
       elsif !genericargs && (t = rule_lookup(name, canbegroup))
         t
       else
-        fail "Unknown type #{name} #{genericargs.inspect} #{@bindings} #{@abnf.ast?}"
+        fail "Unknown type #{name} #{genericargs.inspect} #{@bindings}"  #{@abnf.ast?}"
       end
     end
 
@@ -801,7 +860,7 @@ module CDDL
         g[1..-1]
       elsif !genericargs && (g = rule_lookup(name, true))
         fail "#{name} not a group" unless g[0] == :grpent
-        g[1..-1]
+        g[1..-1]                # AAA
       else
         fail "Unknown group #{name}"
       end
@@ -829,6 +888,8 @@ module CDDL
 
           end
         end                     # XXX should flatten the thing, too
+        t = t.dup
+        t.cbor_annotation_replace(v.to_s) rescue nil # AAA
         t
       else
         fail [n, n.children].inspect
@@ -911,6 +972,7 @@ module CDDL
           [:type1, *s.map {|mem|
              t, _s, _e, _k, v = mem
              fail "enum #{t.inspect}" unless t == :member
+             v.cbor_annotation_add(generate1(_k)) rescue nil # AAA (XXX: what if more than one?)
              v
            }
           ]
@@ -920,9 +982,13 @@ module CDDL
       end
     end
 
+    def type_collect(n, canbegroup)
+      n.children(:type1).map {|ch| type1(ch, canbegroup)}
+    end
+
     def type(n, canbegroup = false)
       # pp ["nch", n.children]
-      s = n.children(:type1).map {|ch| type1(ch, canbegroup)}
+      s = type_collect(n, canbegroup)
       if s.size == 1
         s.first
       else