gitlab-cbor 1.0.0

data/spec/packer_spec.rb

@@ -0,0 +1,127 @@
+# encoding: ascii-8bit
+require 'spec_helper'
+
+require 'stringio'
+if defined?(Encoding)
+  Encoding.default_external = 'ASCII-8BIT'
+end
+
+describe Packer do
+  let :packer do
+    Packer.new
+  end
+
+  it 'initialize' do
+    Packer.new
+    Packer.new(nil)
+    Packer.new(StringIO.new)
+    Packer.new({})
+    Packer.new(StringIO.new, {})
+  end
+
+  #it 'Packer' do
+  #  Packer(packer).object_id.should == packer.object_id
+  #  Packer(nil).class.should == Packer
+  #  Packer('').class.should == Packer
+  #  Packer('initbuf').to_s.should == 'initbuf'
+  #end
+
+  it 'write' do
+    packer.write([])
+    packer.to_s.should == "\x80"
+  end
+
+  it 'write_nil' do
+    packer.write_nil
+    packer.to_s.should == "\xf6"
+  end
+
+  it 'write_array_header 0' do
+    packer.write_array_header(0)
+    packer.to_s.should == "\x80"
+  end
+
+  it 'write_array_header 1' do
+    packer.write_array_header(1)
+    packer.to_s.should == "\x81"
+  end
+
+  it 'write_map_header 0' do
+    packer.write_map_header(0)
+    packer.to_s.should == "\xa0"
+  end
+
+  it 'write_map_header 1' do
+    packer.write_map_header(1)
+    packer.to_s.should == "\xa1"
+  end
+
+  it 'flush' do
+    io = StringIO.new
+    pk = Packer.new(io)
+    pk.write_nil
+    pk.flush
+    pk.to_s.should == ''
+    io.string.should == "\xf6"
+  end
+
+  it 'buffer' do
+    o1 = packer.buffer.object_id
+    packer.buffer << 'frsyuki'
+    packer.buffer.to_s.should == 'frsyuki'
+    packer.buffer.object_id.should == o1
+  end
+
+  it 'to_cbor returns String' do
+    nil.to_cbor.class.should == String
+    true.to_cbor.class.should == String
+    false.to_cbor.class.should == String
+    1.to_cbor.class.should == String
+    1.0.to_cbor.class.should == String
+    "".to_cbor.class.should == String
+    Hash.new.to_cbor.class.should == String
+    Array.new.to_cbor.class.should == String
+  end
+
+  class CustomPack01
+    def to_cbor(pk=nil)
+      return MessagePack.pack(self, pk) unless pk.class == MessagePack::Packer
+      pk.write_array_header(2)
+      pk.write(1)
+      pk.write(2)
+      return pk
+    end
+  end
+
+  class CustomPack02
+    def to_cbor(pk=nil)
+      [1,2].to_cbor(pk)
+    end
+  end
+
+  it 'calls custom to_cbor method' do
+    MessagePack.pack(CustomPack01.new).should == [1,2].to_cbor
+    MessagePack.pack(CustomPack02.new).should == [1,2].to_cbor
+    CustomPack01.new.to_cbor.should == [1,2].to_cbor
+    CustomPack02.new.to_cbor.should == [1,2].to_cbor
+  end
+
+  it 'calls custom to_cbor method with io' do
+    s01 = StringIO.new
+    MessagePack.pack(CustomPack01.new, s01)
+    s01.string.should == [1,2].to_cbor
+
+    s02 = StringIO.new
+    MessagePack.pack(CustomPack02.new, s02)
+    s02.string.should == [1,2].to_cbor
+
+    s03 = StringIO.new
+    CustomPack01.new.to_cbor(s03)
+    s03.string.should == [1,2].to_cbor
+
+    s04 = StringIO.new
+    CustomPack02.new.to_cbor(s04)
+    s04.string.should == [1,2].to_cbor
+  end
+end
+

data/spec/random_compat.rb

@@ -0,0 +1,24 @@
+
+unless defined? Random
+  class Random
+    def initialize(seed=Time.now.to_i)
+      Kernel.srand(seed)
+      @seed = seed
+    end
+
+    attr_reader :seed
+
+    def rand(arg)
+      Kernel.rand(arg)
+    end
+
+    def bytes(n)
+      array = []
+      n.times do
+        array << rand(256)
+      end
+      array.pack('C*')
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,68 @@
+require 'rubygems'              # for 1.8
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = [:should, :expect]
+  end
+  config.mock_with :rspec do |c|
+    c.syntax = [:should, :expect]
+  end
+end
+
+
+class String
+  if ''.respond_to? :encode
+    def encode_as_utf8
+      encode(Encoding::UTF_8)
+    end
+    def force_as_utf8
+      force_encoding(Encoding::UTF_8)
+    end
+    unless String.instance_methods.include?(:b)
+      def b
+        dup.force_encoding(Encoding::BINARY)
+      end
+    end
+  else
+    def encode_as_utf8
+      self                      # MRI 1.8
+    end
+    def force_as_utf8
+      self                      # MRI 1.8
+    end
+    def b
+      self
+    end
+  end
+  unless ''.respond_to? :clear
+    def clear
+      replace('')
+    end
+  end
+  def hexbytes(sep = '')
+    bytes.map{|x| "%02x" % x}.join(sep)
+  end
+end
+
+if ENV['SIMPLE_COV']
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter 'spec/'
+    add_filter 'pkg/'
+    add_filter 'vendor/'
+  end
+end
+
+if ENV['GC_STRESS']
+  puts "enable GC.stress"
+  GC.stress = true
+end
+
+require 'cbor'
+
+MessagePack = CBOR              # XXX
+
+Packer = MessagePack::Packer
+Unpacker = MessagePack::Unpacker
+Buffer = MessagePack::Buffer
+

data/spec/unpacker_spec.rb

@@ -0,0 +1,260 @@
+# encoding: ascii-8bit
+require 'spec_helper'
+
+describe Unpacker do
+  let :unpacker do
+    Unpacker.new
+  end
+
+  let :packer do
+    Packer.new
+  end
+
+  # TODO initialize
+
+  it 'read_array_header succeeds' do
+    unpacker.feed("\x81")
+    unpacker.read_array_header.should == 1
+  end
+
+  it 'read_array_header fails' do
+    unpacker.feed("\xa1")
+    lambda {
+      unpacker.read_array_header
+    }.should raise_error(MessagePack::TypeError)
+  end
+
+  it 'read_array_header converts an array to value sequence' do
+    packer.write_array_header(2)
+    packer.write("e")
+    packer.write(1)
+    unpacker = Unpacker.new
+    unpacker.feed(packer.to_s)
+    unpacker.read_array_header.should == 2
+    unpacker.read.should == "e"
+    unpacker.read.should == 1
+  end
+
+  it 'read_map_header succeeds' do
+    unpacker.feed("\xa1")
+    unpacker.read_map_header.should == 1
+  end
+
+  it 'read_map_header converts an map to key-value sequence' do
+    packer.write_map_header(1)
+    packer.write("k")
+    packer.write("v")
+    unpacker = Unpacker.new
+    unpacker.feed(packer.to_s)
+    unpacker.read_map_header.should == 1
+    unpacker.read.should == "k"
+    unpacker.read.should == "v"
+  end
+
+  it 'read_map_header fails' do
+    unpacker.feed("\x81")
+    lambda {
+      unpacker.read_map_header
+    }.should raise_error(MessagePack::TypeError)
+  end
+
+  it 'skip_nil succeeds' do
+    unpacker.feed("\xf6")
+    unpacker.skip_nil.should == true
+  end
+
+  it 'skip_nil fails' do
+    unpacker.feed("\x80")
+    unpacker.skip_nil.should == false
+  end
+
+  it 'skip skips objects' do
+    packer.write(1)
+    packer.write(2)
+    packer.write(3)
+    packer.write(4)
+    packer.write(5)
+
+    unpacker = Unpacker.new(packer.buffer)
+
+    unpacker.read.should == 1
+    unpacker.skip
+    unpacker.read.should == 3
+    unpacker.skip
+    unpacker.read.should == 5
+  end
+
+  it 'read raises EOFError' do
+    lambda {
+      unpacker.read
+    }.should raise_error(EOFError)
+  end
+
+  it 'skip raises EOFError' do
+    lambda {
+      unpacker.skip
+    }.should raise_error(EOFError)
+  end
+
+  it 'skip_nil raises EOFError' do
+    lambda {
+      unpacker.skip_nil
+    }.should raise_error(EOFError)
+  end
+
+  let :sample_object do
+    [1024, {["a","b"]=>["c","d"]}, ["e","f"], "d", 70000, 4.12, 1.5, 1.5, 1.5]
+  end
+
+  it 'sample object OK' do
+    obj2 = MessagePack.unpack(sample_object.to_cbor)
+    obj2.should == sample_object
+  end
+
+  it 'feed and each continue internal state' do
+    raw = sample_object.to_cbor.to_s * 4
+    objects = []
+
+    raw.split(//).each do |b|
+      unpacker.feed(b)
+      unpacker.each {|c|
+        objects << c
+      }
+    end
+
+    objects.should == [sample_object] * 4
+  end
+
+  it 'feed_each continues internal state' do
+    raw = sample_object.to_cbor.to_s * 4
+    objects = []
+
+    raw.split(//).each do |b|
+      unpacker.feed_each(b) {|c|
+        objects << c
+      }
+    end
+
+    objects.should == [sample_object] * 4
+  end
+
+  it 'reset clears internal buffer' do
+    # 1-element array
+    unpacker.feed("\x91")
+    unpacker.reset
+    unpacker.feed("\x01")
+
+    unpacker.each.map {|x| x }.should == [1]
+  end
+
+  it 'reset clears internal state' do
+    # 1-element array
+    unpacker.feed("\x91")
+    unpacker.each.map {|x| x }.should == []
+
+    unpacker.reset
+
+    unpacker.feed("\x01")
+    unpacker.each.map {|x| x }.should == [1]
+  end
+
+  it 'buffer' do
+    o1 = unpacker.buffer.object_id
+    unpacker.buffer << 'frsyuki'
+    unpacker.buffer.to_s.should == 'frsyuki'
+    unpacker.buffer.object_id.should == o1
+  end
+
+  it 'frozen short strings' do
+    raw = sample_object.to_cbor.to_s.force_as_utf8
+    lambda {
+      unpacker.feed_each(raw.freeze) { }
+    }.should_not raise_error
+  end
+
+  it 'frozen long strings' do
+    raw = (sample_object.to_cbor.to_s * 10240).force_as_utf8
+    lambda {
+      unpacker.feed_each(raw.freeze) { }
+    }.should_not raise_error
+  end
+
+  it 'read raises level stack too deep error' do
+    512.times { packer.write_array_header(1) }
+    packer.write(nil)
+
+    unpacker = Unpacker.new(packer.buffer)
+    lambda {
+      unpacker.read
+    }.should raise_error(MessagePack::StackError)
+  end
+
+  it 'skip raises level stack too deep error' do
+    512.times { packer.write_array_header(1) }
+    packer.write(nil)
+
+    unpacker = Unpacker.new(packer.buffer)
+    lambda {
+      unpacker.skip
+    }.should raise_error(MessagePack::StackError)
+  end
+
+  it 'read raises invalid byte error' do
+    unpacker.feed("\xdf")
+    lambda {
+      unpacker.read
+    }.should raise_error(MessagePack::MalformedFormatError)
+  end
+
+  it 'skip raises invalid byte error' do
+    unpacker.feed("\xdf")
+    lambda {
+      unpacker.skip
+    }.should raise_error(MessagePack::MalformedFormatError)
+  end
+
+  it "gc mark" do
+    raw = sample_object.to_cbor.to_s * 4
+
+    n = 0
+    raw.split(//).each do |b|
+      GC.start
+      unpacker.feed_each(b) {|o|
+        GC.start
+        o.should == sample_object
+        n += 1
+      }
+      GC.start
+    end
+
+    n.should == 4
+  end
+
+  it "buffer" do
+    orig = "a"*32*1024*4
+    raw = orig.to_cbor.to_s
+
+    n = 655
+    times = raw.size / n
+    times += 1 unless raw.size % n == 0
+
+    off = 0
+    parsed = false
+
+    times.times do
+      parsed.should == false
+
+      seg = raw[off, n]
+      off += seg.length
+
+      unpacker.feed_each(seg) {|obj|
+        parsed.should == false
+        obj.should == orig
+        parsed = true
+      }
+    end
+
+    parsed.should == true
+  end
+end
+

metadata

@@ -0,0 +1,189 @@
+--- !ruby/object:Gem::Specification
+name: gitlab-cbor
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Carsten Bormann, standing on the tall shoulders of Sadayuki Furuhashi
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-11-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.3
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.11'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.11
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.11
+description: GitLab's fork of the cbor gem. Decoding no longer reconstructs object-constructing
+  tags (Regexp, URI) unless the caller opts in via reconstruct_from_tags:, so an untrusted
+  CBOR.decode cannot reach Regexp.new. Based on Carsten Bormann's cbor, itself based
+  on Sadayuki Furuhashi's MessagePack library.
+email: cabo@tzi.org
+executables: []
+extensions:
+- ext/cbor/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".gitlab-ci.yml"
+- ".travis.yml"
+- CHANGELOG.md
+- ChangeLog
+- Gemfile
+- README.rdoc
+- Rakefile
+- ci/test.rb
+- doclib/cbor.rb
+- doclib/cbor/buffer.rb
+- doclib/cbor/core_ext.rb
+- doclib/cbor/error.rb
+- doclib/cbor/packer.rb
+- doclib/cbor/simple.rb
+- doclib/cbor/tagged.rb
+- doclib/cbor/unpacker.rb
+- ext/cbor/buffer.c
+- ext/cbor/buffer.h
+- ext/cbor/buffer_class.c
+- ext/cbor/buffer_class.h
+- ext/cbor/cbor.h
+- ext/cbor/compat.h
+- ext/cbor/core_ext.c
+- ext/cbor/core_ext.h
+- ext/cbor/extconf.rb
+- ext/cbor/packer.c
+- ext/cbor/packer.h
+- ext/cbor/packer_class.c
+- ext/cbor/packer_class.h
+- ext/cbor/rbinit.c
+- ext/cbor/renamer.h
+- ext/cbor/rmem.c
+- ext/cbor/rmem.h
+- ext/cbor/sysdep.h
+- ext/cbor/sysdep_endian.h
+- ext/cbor/sysdep_types.h
+- ext/cbor/unpacker.c
+- ext/cbor/unpacker.h
+- ext/cbor/unpacker_class.c
+- ext/cbor/unpacker_class.h
+- gitlab-cbor.gemspec
+- lib/cbor.rb
+- lib/cbor/version.rb
+- spec/buffer_io_spec.rb
+- spec/buffer_spec.rb
+- spec/cases.cbor
+- spec/cases.cbor_stream
+- spec/cases.json
+- spec/cases.msg
+- spec/cases_compact.msg
+- spec/cases_spec.rb
+- spec/format_spec.rb
+- spec/packer_spec.rb
+- spec/random_compat.rb
+- spec/spec_helper.rb
+- spec/unpacker_spec.rb
+homepage: https://gitlab.com/gitlab-org/ruby/gems/gitlab-cbor
+licenses:
+- Apache-2.0
+metadata:
+  source_code_uri: https://gitlab.com/gitlab-org/ruby/gems/gitlab-cbor
+  upstream_uri: https://rubygems.org/gems/cbor
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: CBOR, Concise Binary Object Representation (GitLab security fork).
+test_files: []