cbor-packed 0.1.3 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ec7bd11d45d35c418a0fe98aa43c369b3384b2b43cb94486fd6e3463eae3232
-  data.tar.gz: 88efc5decfeeedb1c049df0e5a9ba126c35bdf8a661218e29db3eb836c39f9c6
+  metadata.gz: 9306aa8a05d1747901cda5a72e3636199ce2dc403e09c8731c2fbd6c6be93623
+  data.tar.gz: 9ccd87f2b36818c1b71b7e946cdfe370c230f40ea9331fc407e925a0ff214824
 SHA512:
-  metadata.gz: 1b6add7d575ff6ab3f239c9cf8f4f434ec8cc3c7d02e717c58b8c79a2007dd6d033ec10739c8bbac788e73d292f37501a002730303a8f58479a7131243fd04ac
-  data.tar.gz: efd9b83c4da71f11354398048e6421770583b2fef0e22b4e3ac1f964ba2d5f4d2d69b2cb1e6441058062313940d6fee492f6dd7579dd0e25202734229a33058b
+  metadata.gz: b35a19072f26120f7aa4e67c9f4b3af64f3aea70eeaa0203b3d7d0c228d8ab20ea006cebd09e62d26233ea10c8fbacad5b9024e75f180f9f9462c81fe1e5632a
+  data.tar.gz: 57a9c79818180b0433230c3666fdc5742d3b8fa22e9fd1deda8941a8a75eef05b0f933c249c1131afb5f615b23920cce16b5d81fc09d30b07d04ac0d233dd8f9

data/cbor-packed.gemspec

@@ -1,13 +1,12 @@
 Gem::Specification.new do |s|
   s.name = "cbor-packed"
-  s.version = "0.1.3"
+  s.version = "0.2.2"
   s.summary = "CBOR (Concise Binary Object Representation) packer"
   s.description = %q{cbor-packed implements packed encoding for CBOR, RFC 7049 Section 3.9}
   s.author = "Carsten Bormann"
   s.email = "cabo@tzi.org"
   s.license = "Apache-2.0"
   s.homepage = "http://cbor.io/"
-  s.has_rdoc = false
   s.test_files = Dir['test/**/*.rb']
   s.files = Dir['lib/**/*.rb'] + %w(cbor-packed.gemspec) + Dir['bin/**/*.rb']
   s.executables = Dir['bin/**/*.rb'].map {|x| File.basename(x)}

data/lib/cbor-packed.rb

@@ -1,56 +1,220 @@
 # -*- coding: utf-8 -*-
 
-require "cbor" unless defined? CBOR
-# require "pp"
+require "cbor-pure" unless defined? CBOR
+require "pp"
 
 $compression_hack = 0
 
+# class String
+#   def xeh
+#     gsub(/\s/, "").chars.each_slice(2).map{ |x| Integer(x.join, 16).chr("BINARY") }.join
+#   end
+# end
+
 module CBOR
-  PACKED_TAG = 51
+  PACKED_TAG = 1113
+  MIXED_PACKED_TAG = 113
   REF_TAG = 6
+  STRAIGHT_11_SIZE = 32         # How many 1+1 straight tags do we have
+
+  HEX_UC_TAG = 23
+  HEX_LC_TAG = 108              # 'l'.ord, SQUATTING, fix this
+  RECORD_TAG = 114              # 'r'.ord
+  UNDEFINED = CBOR::Simple.new(23)
+
+  # Use with || 4
+  #            simple             6(1+0)             6(1+1)
+  REF_SIZE = [*Array.new(16, 1), *Array.new(48, 2), *Array.new(512-48, 3)]
 
   class Packer
-    def self.from_item(item)
+    def self.build_match_array(item)
+      # Hash with all data items as keys and the number of times they occur as values:
       count = Hash.new(0)
       item.cbor_visit do |o|
         (count[o] += 1) == 1
         # if the count gets > 1, we can stop visiting, so we return false in the block
       end
-      # pp count
-      # count is now a Hash with all data items as keys and the number of times they occur as values
 
       # choose those matches that are occurring > 1, make first rough estimate of saving
-      good_count = count.select {|k, v| v > 1}.map {|k, v| [k, v, l = k.to_cbor.length,
-                                                            (v-1)*(l-1)]}
-      # good_count is now an array of [k, v, length, savings] tuples
-
-      # select those that potentially have savings (> 0) and sort by best saving first
-      better_count = good_count.to_a.select {|a| a[3] > 0}.sort_by {|a| -a[3]}
-      # pp better_count
+      good_count = count
+                     .select {|k, v| v > 1}
+                     .map {|k, v|
+                        l = k.to_cbor.length
+                        # v-1: We can only save space for the second etc.
+                        # l-1: We'll need at least 1 byte for the reference
+                        gain = (v-1)*(l-1)
+                        [k, v, l] if gain > 0
+                     }.compact
+                     .sort_by {|a| -a[1]}
+      # good_count is now an array of [value, count, length] tuples that have potential gain,
+      # sorted by descending number of references we'll get
 
-      # now: take the best out???; re-visit that reducing by n; re-sort and filter???
-      # sort by descending number of references we'll get -- the higher reference counts go first
-      match_array = better_count.sort_by {|a| -a[1]}.map {|a| a[0]}
+      match_array = []
+      good_count.each {|a|
+        match_array << a[0] if (REF_SIZE[match_array.size] || 4) < a[2]
+      }
       # pp match_array
+      [count, match_array]
+    end
+
+    def self.argref(n, casezero = 6)
+      case n
+      when 0
+        casezero
+      when 1..31
+        n + 224
+      when 32...0x1000
+        n + 0x7000
+      when 0x1000...0x10000000
+        n + 0x70000000
+      end
+    end
+
+    def self.sharedref(i)
+      if i < 16
+        CBOR::Simple.new(i)
+      else
+        i -= 16
+        CBOR::Tagged.new(REF_TAG, (i >> 1) ^ -(i & 1))
+      end
+    end
+
+    def self.build_bytes_from_hex(strings, count, match_array, item, translate, prefixes)
+      optimizable, others = strings.partition do |str|
+        if /(?:(?<lc>(?:[0-9a-f][0-9a-f]){4,})|(?<uc>(?:[0-9A-F][0-9A-F]){4,}))$/ =~ str
+          left = $`
+          # warn [:lc, left, lc, uc].inspect
+          bytes = [
+            if lc
+              tag = HEX_LC_TAG
+              fail if uc
+              lc
+            else
+              fail unless uc
+              tag = HEX_UC_TAG
+              uc
+            end].pack('H*').b
+          if outer = translate[str]
+            fail outer.inspect unless CBOR::Tagged === outer && left == outer.value # XXX
+          else
+            referto = bytes
+            if (count[bytes] += 1) == 2 # patch up match_array...
+              # translate[bytes] = sharedref(match_array.size) # happens later, too
+              match_array << bytes
+              referto = sharedref(match_array.size-1)
+            end
+            prefixes << left unless prefixes[-1] == left
+            translate[str] = CBOR::Tagged.new(argref(prefixes.size-1),
+                                              CBOR::Tagged.new(tag, referto)) unless count[bytes] > 2
+            # don't overwrite any entry made at == 2
+          end
+          true
+        end
+      end
+      others
+    end
+
+    def self.build_maps(count, match_array, translate, prefixes)
+      klcount = Hash.new(0)
+      mapvalues = Hash.new {|h, kl|      # kl = key list
+        h.member?(kl) or h[kl] = Hash.new {|hv, kv|
+          hv.member?(kv) or hv[kv] = Hash.new(0)
+        }
+      }
+
+      count.select {|o, _n| Hash === o}.each do |o, _n|
+        kl = o.keys.sort
+        klcount[kl] += 1
+        v = o.values_at(*kl)
+        z = kl.zip(v)
+        z.each do |k1, v1|
+          mapvalues[kl][k1][v1] += 1
+        end
+      end
+      repkl = klcount.select {|kl, n| n > 1}.sort_by {|kl, n| -n} # sort not needed
+      # fudge here -- ignore single children even in parent selection
+
+      # parent selection
+
+      klparents = {}
+      repkl.map do |kl, n|
+        klparent = {}
+        mapvalues[kl].each do |k1, v1|
+          repv = v1.to_a.select{|k2, v2| v2 > (n+3)/2} # low-hanging ->
+          if repv != []             # -> should be zero or one of them
+            # pp [k1, repv]
+            # The k1 values are those that go into the head arrays
+            # first .first: low-hanging, second .first: repeated member value
+            klparent[k1] = repv.first.first
+          end
+        end
+        # pp klparent
+        if klparent != {}
+          ix = prefixes.size
+          prefixes << klparent
+          constant_keys = Set[*klparent.keys]
+          variable_keys = Set[*kl] - constant_keys
+          klparents[kl] = [
+            klparent, argref(ix), constant_keys, variable_keys.to_a
+          ]
+        end
+      end
+
+      klmatch = {}
+
+      count.select {|o, _n| Hash === o}.each do |o, _n|
+        kl = o.keys.sort
+        klp, ref, constant_keys, variable_kl = klparents[kl]
+        if klp # split off parent, return to common code then
+          oouter = o
+          o = o.reject {|k| constant_keys.include? k}
+          kl = variable_kl
+        end
+        if kl.size > 1 && (klp || klcount[kl] > 1) # TODO: tune
+          unless ix = klmatch[kl]
+            ix = prefixes.size
+            prefixes << CBOR::Tagged.new(RECORD_TAG, kl)
+            klmatch[kl] = ix
+          end
+          packed = translate[o] = CBOR::Tagged.new(argref(ix), o.values_at(*kl)) # needs packing
+        end
+        if packed && klp
+          translate[oouter] = CBOR::Tagged.new(ref, packed) # merge Hashes
+        end
+      end
+
+    end
 
-      # XXX the below needs to be done with arrays and (hard!) maps as well
+    CBOR_PACKED_HEX = ENV["CBOR_PACKED_HEX"]
+    CBOR_PACKED_MAPS = ENV["CBOR_PACKED_MAPS"]
+
+    def self.from_item(item)
+      count, match_array = build_match_array(item)
+
+      # TODO: the below needs to be done with arrays and (hard!) maps as well
       # do this on the reverse to find common suffixes
+
+      translate = {}            # map (sub)items to their arg-packed versions
+      prefixes = []             # provisional prefix table used in the above
+
       # select all strings (ignoring reference counts) and sort them
       strings = count.select {|k, v| String === k}.map(&:first).sort
       if strings != []
-        string_common = strings[1..-1].zip(strings).map{ |y, x|
-          l = x.chars.zip(y.chars).take_while{|a, b| a == b}.length # should be bytes
-          [x, l]
-        } << [strings[-1], 0]
+        strings = build_bytes_from_hex(strings, count, match_array, item, translate, prefixes) if CBOR_PACKED_HEX
+        if strings != []
+          string_common = strings[1..-1].zip(strings).map{ |y, x|
+            l = x.chars.zip(y.chars).take_while{|a, b| a == b}.length # should be bytes
+            [x, l]
+          } << [strings[-1], 0]
+        end
         # string_common: list of strings/counts of number of /bytes/ matching with next
         # pp string_common
       end
-      translate = {}
-      prefixes = []
       if string_common
+        
       prefix_stack = [[0, false]] # sentinel
       pos = 0                     # mirror prefix_stack[-1][0]
-      tag_no = REF_TAG
+      tag_no = argref(prefixes.size) # REF_TAG
       string_common.each do |s, l|
         if l > pos + 2 + $compression_hack
           if t = prefix_stack[-1][1] # if we still have a prefix left
@@ -61,8 +225,9 @@ module CBOR
           prefix_stack << [l, tag_no]
           pos = l
           tag_no += 1
-          tag_no = 225 if tag_no == REF_TAG+1
+          tag_no = 225 if tag_no == REF_TAG+1 # skip 224, as we always can use 6 here
           tag_no = 28704 if tag_no == 256
+          tag_no = 1879052288 if tag_no == 32768
         end
         if t = prefix_stack[-1][1] # if we still have a viable prefix left
           translate[s] = CBOR::Tagged.new(t, s[pos..-1])
@@ -77,8 +242,45 @@ module CBOR
       end
         
       end
-      # pp translate
-      # XXX test replacing match_array here
+      # pp [:TRANSLATE, translate]
+      # pp [:PREFIXES, prefixes]
+      # Note that we didn't compute a suffix table to mix in
+
+      build_maps(count, match_array, translate, prefixes)  if CBOR_PACKED_MAPS
+
+      match_array_size = match_array.size
+      mixed = match_array_size + prefixes.size <= STRAIGHT_11_SIZE
+      if mixed && match_array_size != 0
+        # We need to shift by match_array_size
+        translate = Hash[translate.map {|k, v|
+                           PP.pp v, STDERR
+                           newtag = v.tag
+                           if newtag == REF_TAG
+                             newtag = 224
+                           end
+                           # this works only if <= STRAIGHT_11_SIZE (above)
+                           newtag += match_array_size
+                           [k, CBOR::Tagged.new(newtag, v.value)]
+                         }]
+        prefixes = prefixes.map {|p|
+          if CBOR::Tagged === p
+            case p.tag
+            when REF_TAG
+              CBOR::Tagged.new(224 + match_array_size, p.value)
+            when 224..255
+              CBOR::Tagged.new(p.tag + match_array_size, p.value)
+            else   # this works only if <= STRAIGHT_11_SIZE (above)
+              p
+            end
+          else
+            p
+          end
+        }
+        # pp translate
+        # pp prefixes
+      end
+
+      # Check match_array for direct entries of an arg-packed string
       match_array = match_array.map do |v|
         if r = translate[v]
           # puts "*** replacing #{v.inspect} by #{r.inspect}"
@@ -87,18 +289,18 @@ module CBOR
           v
         end
       end
-      # pp [:PREFIXES, prefixes]
-      # pp translate
-      new(match_array, prefixes, [], translate)
+
+      new(match_array, prefixes, translate, mixed)
     end
-    def initialize(match_array, prefix_array, suffix_array, translate)
+    def initialize(match_array, argument_array, translate, mixed)
+      @mixed = mixed
       @hit = translate
       # XXX: make sure we don't overwrite the existing prefix compression values!
       # (this should really be done downwards, ...) 16 x 1, 160 x 2, (512-48) x 3
       match_array[0...16].each_with_index do |o, i|
         @hit[o] = CBOR::Simple.new(i)
       end
-      # if m = match_array[16...128]
+      # if m = match_array[16...128]    # no allocation for simple(16...128)
       #   m.each_with_index do |o, i|
       #     @hit[o] = CBOR::Simple.new(i + 128)
       #   end
@@ -114,45 +316,48 @@ module CBOR
           @hit[k] = r
         end
       end
-      # p @hit
+      # warn [:HIT, @hit['688921AF59455E4D35D2FFE5FD21CA0598D42374'.xeh]].inspect
       @match_array = match_array
       # @prefix = {} -- do that later
-      @prefix_array = prefix_array
-      @suffix_array = suffix_array
+      @argument_array = argument_array
     end
     def has(o)
+      # warn [:HIT1].inspect if o == '688921AF59455E4D35D2FFE5FD21CA0598D42374'.xeh
       @hit[o]
     end
     def pack(pa)
-      # Don't forget to pack the match_array!
-      CBOR::Tagged.new(PACKED_TAG, [@match_array, @prefix_array, @suffix_array, pa])
+      pa = pa.to_packed_cbor1(self) # should also sort by frequency...
+      if @mixed
+        mixed_array = @match_array + @argument_array
+        CBOR::Tagged.new(MIXED_PACKED_TAG, [mixed_array, pa])
+      else
+        CBOR::Tagged.new(PACKED_TAG, [@match_array, @argument_array, pa])
+      end
     end
   end
 
   class Unpacker
-    def initialize(match_array, prefix_array, suffix_array)
+    def initialize(match_array, argument_array)
       @simple_array = match_array[0...16]
       @tagged_array = match_array[16..-1]
       # index with 2i for i >= 0 or ~2i for i < 0
       # no map as we need to populate in progress
-      # pp prefix_array
-      @prefix_array = []
-      prefix_array.each {|x| @prefix_array << x.to_unpacked_cbor1(self)}
-      @suffix_array = []
-      suffix_array.each {|x| @prefix_array << x.to_unpacked_cbor1(self)}
-      # XXX order? -- must do lazily!
+      # pp argument_array
+      @argument_array = []
+      @raw_argument_array = argument_array
     end
     def unsimple(sv)
-      @simple_array[sv]
+      @simple_array[sv].to_unpacked_cbor1(self)
     end
-    def untag(tv)
-      @tagged_array[(i << 1) ^ (i >> 63)]
+    def untag(i)
+      # @tagged_array[(i << 1) ^ (i >> 63)]
+      ix = (i << 1) ^ (i >> 63)
+      ret = @tagged_array[ix]
+      # warn "** UNTAG i=#{i} ix=#{ix} ret=#{ret}"
+      ret.to_unpacked_cbor1(self)
     end
     def unprefix(n)
-      @prefix_array[n]
-    end
-    def unsuffix(n)
-      @suffix_array[n]
+      @argument_array[n] ||= @raw_argument_array[n].to_unpacked_cbor1(self)
     end
   end
 
@@ -193,7 +398,26 @@ module CBOR
     module String_Packed_CBOR
       def packed_merge(other, unpacker)
         # add checks
-        to_unpacked_cbor1(unpacker) + other.to_unpacked_cbor1(unpacker)
+        lhs = to_unpacked_cbor1(unpacker)
+        rhs = other.to_unpacked_cbor1(unpacker)
+        if CBOR::Tagged === rhs
+          case rhs.tag
+          when HEX_LC_TAG
+            rhs = rhs.value.unpack("H*").first
+          when HEX_UC_TAG
+            rhs = rhs.value.unpack("H*").first.upcase
+          else
+            fail ArgumentError, "*** String#packed_merge: unknown tag #{rhs.tag} on rhs"
+          end
+        end
+        begin
+          lhs + rhs
+        rescue => detail
+          warn "** lhs = #{lhs.inspect}"
+          warn "** rhs = #{rhs.inspect}"
+          warn "** error: #{detail}"
+          lhs + rhs.to_s
+        end
       end
     end
     String.send(:include, String_Packed_CBOR)
@@ -211,7 +435,7 @@ module CBOR
       end
       def to_packed_cbor1(packer = Packer.from_item(self))
         if c = packer.has(self)
-          c.to_unpacked_cbor1(unpacker)
+          c.to_packed_cbor1(packer)
         else
           # TODO: Find useful prefixes
           map {|x| x.to_packed_cbor1(packer)}
@@ -238,15 +462,20 @@ module CBOR
       end
       def to_packed_cbor1(packer = Packer.from_item(self))
         if c = packer.has(self)
-          c.to_unpacked_cbor1(unpacker)
+          c.to_packed_cbor1(packer)
         else
           # TODO: Find useful prefixes
           Hash[map {|k, v| [k.to_packed_cbor1(packer), v.to_packed_cbor1(packer)]}]
         end
       end
       def packed_merge(other, unpacker)
-        # TODO: add checks
-        to_unpacked_cbor1(unpacker).merge other.to_unpacked_cbor1(unpacker)
+        rhs = other
+        until Hash === rhs
+          rhso = rhs
+          rhs = rhs.to_unpacked_cbor1(unpacker)
+          fail ArgumentError, "*** In #{self.inspect}, cannot further unpack #{rhs.inspect}" unless rhso != rhs
+        end
+        to_unpacked_cbor1(unpacker).merge rhs
       end
     end
     Hash.send(:include, Hash_Packed_CBOR)
@@ -261,20 +490,30 @@ module CBOR
         if tag == PACKED_TAG
           # check that this really is an array
           # warn value.to_yaml
-          ma, pa, sa, pv = value
-          unpacker = Unpacker.new(ma, pa, sa)
+          ma, aa, pv = value
+          unpacker = Unpacker.new(ma, aa)
+          pv.to_unpacked_cbor1(unpacker)
+        elsif tag == MIXED_PACKED_TAG
+          # check that this really is an array
+          # warn value.to_yaml
+          args, pv = value
+          unpacker = Unpacker.new(args, args)
           pv.to_unpacked_cbor1(unpacker)
         else
-          fail "error message here"
+          fail "*** Don't know how to unpack tag #{tag}"
         end
       end
       def to_unpacked_cbor1(unpacker)
         case tag
         when REF_TAG
-          if Integer === value
-            unpacker(untag(value))
+          # warn "** REF_TAG1 value #{value.class.inspect} #{value.inspect}"
+          unpacked_value = value.to_unpacked_cbor1(unpacker)
+          # warn "** REF_TAG2 value #{unpacked_value.class.inspect} #{unpacked_value.inspect}"
+          if Integer === unpacked_value
+            # warn "** I REF_TAG value #{value.class.inspect} #{value.inspect}"
+            unpacker.untag(unpacked_value)
           else
-            unpacker.unprefix(0).packed_merge value, unpacker
+            unpacker.unprefix(0).packed_merge unpacked_value, unpacker
           end
         when 225...256
           unpacker.unprefix(tag-(256-32)).packed_merge value, unpacker
@@ -292,9 +531,30 @@ module CBOR
           CBOR::Tagged.new(tag, value.to_unpacked_cbor1(unpacker))
         end
       end
+      def packed_merge(other, unpacker)
+        # tag must be a function tag -- TODO add standin tag decoder for lhs (value)
+        case tag
+        when RECORD_TAG
+          rhs = other.to_unpacked_cbor1(unpacker)
+          raise ArgumentError, "*** need arrays for record tag (#{
+            value.inspect}, #{rhs.inspect})" unless Array === value && Array === rhs
+          n = value.size - rhs.size
+          if n > 0
+            rhs += [UNDEFINED] * n
+          elsif n < 0
+            raise ArgumentError, "*** too many values (#{rhs.inspect
+              }) for record tag keys (#{value.inspect
+              })" unless Array === value && Array === rhs
+          end
+          Hash[value.zip(rhs).select{|k, v| v != UNDEFINED}]
+        else
+          raise ArgumentError, "*** function tag #{tag} not implemented"
+        end
+      end
+
       def to_packed_cbor1(packer = Packer.from_item(self))
         if c = packer.has(self)
-          c
+          c.to_packed_cbor1(packer)
         else
           CBOR::Tagged.new(tag, value.to_packed_cbor1(packer))
         end

data/test/exa2r1.rb

@@ -0,0 +1,58 @@
+require 'cbor-pure'
+require 'cbor-packed'
+require 'treetop'
+require 'cbor-diag-parser'
+require 'cbor-diagnostic'
+require 'json'
+require 'yaml'
+
+input = DATA.read
+
+
+parser = CBOR_DIAGParser.new
+if result = parser.parse(input)
+  o = result.to_rb.to_unpacked_cbor
+  puts o.cbor_diagnostic
+else
+  puts "*** can't parse #{i}"
+  puts "*** #{parser.failure_reason}"
+end
+
+# ruby -I ../lib exa2r.rb | jq > .out1
+# jq < ~/big/wot-thing-description/test-bed/data/plugfest/2017-05-osaka/MyLED_f.jsonld > .out2
+# ruby .check
+# => true
+
+
+__END__
+
+1113([/shared/["name", "@type", "links", "href", "mediaType",
+             /  0       1       2        3         4 /
+     "application/json", "outputData", {"valueType": {"type":
+          /  5               6               7 /
+     "number"}}, ["Property"], "writable", "valueType", "type"],
+                /   8            9           10           11 /
+    /prefix/ ["http://192.168.1.10", 6("3:8445/wot/thing"),
+               / 6                        225 /
+    225("/MyLED/"), 226("rgbValue"), "rgbValue",
+      / 226             227           228     /
+    {simple(6): simple(7), simple(9): true, simple(1): simple(8)}],
+      / 229 /
+    /rump/ {simple(0): "MyLED",
+            "interactions": [
+      229({simple(2): [{simple(3): 227("Red"), simple(4): simple(5)}],
+       simple(0): 228("Red")}),
+      229({simple(2): [{simple(3): 227("Green"), simple(4): simple(5)}],
+       simple(0): 228("Green")}),
+      229({simple(2): [{simple(3): 227("Blue"), simple(4): simple(5)}],
+       simple(0): 228("Blue")}),
+      229({simple(2): [{simple(3): 227("White"), simple(4): simple(5)}],
+       simple(0): "rgbValueWhite"}),
+      {simple(2): [{simple(3): 226("ledOnOff"), simple(4): simple(5)}],
+       simple(6): {simple(10): {simple(11): "boolean"}}, simple(0):
+       "ledOnOff", simple(9): true, simple(1): simple(8)},
+      {simple(2): [{simple(3): 226("colorTemperatureChanged"),
+       simple(4): simple(5)}], simple(6): simple(7), simple(0):
+       "colorTemperatureChanged", simple(1): ["Event"]}],
+      simple(1): "Lamp", "id": "0", "base": 225(""),
+      "@context": 6("2:8444/wot/w3c-wot-td-context.jsonld")}])

data/test/test-packed.rb

@@ -35,16 +35,18 @@ puts "CBOR packed: #{cbp.length}"
 File.write("/tmp/cbp", cbp)
 File.write("/tmp/cbu", cb)
 pad = CBOR.decode(cbp)
-# puts pad.to_yaml
+puts "--- packed decoded ---"
+puts pad.to_yaml
 up =  pad.to_unpacked_cbor
-pp up == jo
+pp [:EQUAL, up == jo]
 if up != jo
+  puts "--- not equal ---"
   puts up.to_yaml
   puts pad.to_yaml   # get rid of unwanted sharing...
 end
 
 # puts "#{pa.value.map {|x| x.to_cbor.length}}"
-puts pa.value[1].to_json
+puts "pa.value[1].to_json: ", pa.value[1].to_json
 
 exin = JSON.load(DATA)
 exout = exin.to_packed_cbor

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cbor-packed
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.2
 platform: ruby
 authors:
 - Carsten Bormann
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-04 00:00:00.000000000 Z
+date: 2025-01-03 00:00:00.000000000 Z
 dependencies: []
 description: cbor-packed implements packed encoding for CBOR, RFC 7049 Section 3.9
 email: cabo@tzi.org
@@ -20,6 +20,7 @@ files:
 - lib/cbor-packed.rb
 - test/exa2.rb
 - test/exa2r.rb
+- test/exa2r1.rb
 - test/test-packed.rb
 homepage: http://cbor.io/
 licenses:
@@ -40,11 +41,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.15
+rubygems_version: 3.5.14
 signing_key:
 specification_version: 4
 summary: CBOR (Concise Binary Object Representation) packer
 test_files:
 - test/exa2.rb
 - test/exa2r.rb
+- test/exa2r1.rb
 - test/test-packed.rb