cbor-packed 0.1.5 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aac07ac277ddc9d142fcfd1d2b6b6b07279522354e3f72b4cbec52466e94b6c3
-  data.tar.gz: 7963b3afd7a8e205b65b5e4fb4a69496aa358e29aac1c1cc126fa4b14db38b20
+  metadata.gz: 9306aa8a05d1747901cda5a72e3636199ce2dc403e09c8731c2fbd6c6be93623
+  data.tar.gz: 9ccd87f2b36818c1b71b7e946cdfe370c230f40ea9331fc407e925a0ff214824
 SHA512:
-  metadata.gz: 2e25f214b1944aa20817ee2e4fc9640c7d2c8f698bb22fb9e207aa22d2ba7adb78a32fb8b2ef51e8b7d8c981e3d0b29b8aca97f932ca54cc70ad14268756f797
-  data.tar.gz: 1200e4a27c0e2063ed4073406a0e55f4a12eb0efec213b5e26b069924a4a699a450e180c80302cba144883e5cafad31b6fab11a3b8e7e3ce6e2b2c87003ee2d2
+  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.5"
+  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,66 +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
+      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
 
-      # 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
+      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
 
-      # now: take the best out???; re-visit that reducing by n; re-sort and filter???
+    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
 
-      # sort by descending number of references we'll get
-      # -- the higher reference counts go first
-      # then filter out the entries that actually improve
+    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
 
-      match_array = []
+    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
 
-      better_count.sort_by {|a| -a[1]}.each {|a|
-        match_array << a[0] if (REF_SIZE[match_array.size] || 4) < a[2]
+    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)
+        }
       }
-      # pp match_array
 
-      # XXX the below needs to be done with arrays and (hard!) maps as well
+      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
+
+    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
@@ -71,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])
@@ -87,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}"
@@ -97,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
@@ -124,49 +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(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
+      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
 
@@ -209,6 +400,16 @@ module CBOR
         # add checks
         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
@@ -268,8 +469,13 @@ module CBOR
         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)
@@ -284,11 +490,17 @@ 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)
@@ -319,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.5
+  version: 0.2.2
 platform: ruby
 authors:
 - Carsten Bormann
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-30 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.3.7
+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