cbor-simple 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f0cf7690f1fb741f8a95075b8a197168704fd2bf
+  data.tar.gz: 2c5d4756029677dd6ee6e4601b4d059305205242
+SHA512:
+  metadata.gz: 1e2a40952af4869b675e83ee68b42d5a2e82ec1ce30b9eb6d1f6dd4520e15ba98a361f5ec94553c97a00f5e2af63c7b835b848c361c4244d767980c9ae90ab44
+  data.tar.gz: 99542bf58913f7fa82b626a0d752d5c805e23f90545da64a1f63dfaef4c6cecc2a1363c3165d92d74a7a4de916fc18ba0028825d14379eee35b63aade9514484

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in cbor-simple.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Lucas Clemente
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,48 @@
+# CBOR Simple
+
+```ruby
+gem 'cbor-simple'
+```
+
+A basic but extensible implementation of [CBOR (RFC7049)](http://tools.ietf.org/html/rfc7049) in plain ruby.
+
+Use just like `JSON` or `YAML`:
+
+```ruby
+CBOR.dump(42)           # => "\x18\x2a"
+CBOR.load("\x18\x2a")   # => 42
+```
+
+You can add custom tags like this:
+
+```ruby
+CBOR.register_tag 0 do
+  Time.iso8601(load())
+end
+```
+
+And add classes for dumping:
+
+```ruby
+CBOR.register_class Time, 0 do |obj|
+  dump(obj.iso8601(6))
+end
+```
+
+Custom tags can also be given as second parameter to `load`, however this should be considered unstable and might change in the future.
+
+```ruby
+# Invert values tagged with 0x26 (nonstandard!)
+CBOR.load("\xd8\x26\xf5", {0x26 => ->{ !load }})  # => false
+```
+
+Currently supported classes:
+
+- (Unsigned) Integers
+- Floats (single and double)
+- Byte / Textstring (also symbols)
+- Arrays
+- Hashes
+- BigDecimals
+- UUIDs (if the gem `uuidtools` is visible)
+- Times

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.pattern = "test/*_test.rb"
+  t.libs.push "test"
+end
+
+task default: :test

data/cbor-simple.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cbor/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "cbor-simple"
+  spec.version       = CBOR::VERSION
+  spec.authors       = ["Lucas Clemente"]
+  spec.email         = ["lucas@clemente.io"]
+  spec.summary       = %q{Basic but extensible CBOR implementation for ruby.}
+  spec.homepage      = "https://github.com/lucas-clemente/cbor-simple"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "minitest-emoji"
+  spec.add_development_dependency "uuidtools"
+end

data/lib/cbor.rb

@@ -0,0 +1,68 @@
+require "bigdecimal"
+require "stringio"
+
+require "cbor/version"
+require "cbor/consts"
+require "cbor/error"
+require "cbor/dumper"
+require "cbor/loader"
+
+module CBOR
+  def self.dump(val)
+    Dumper.new.dump(val)
+  end
+
+  # Load CBOR-encoded data.
+  #
+  # `binary` can be either a String or an IO object. In both cases the first
+  # encoded object will be returned.
+  #
+  # Local tags (as a hash of tag => lambda) will only be valid within this method.
+  def self.load(binary, local_tags = {})
+    if binary.is_a? String
+      binary = StringIO.new(binary)
+    elsif !binary.is_a? IO
+      raise CborError.new("can only load from String or IO")
+    end
+    Loader.new(binary, local_tags).load
+  end
+
+  def self.register_class(klass, tag, &block)
+    Dumper.register_class(klass, tag, &block)
+  end
+
+  def self.register_tag(tag, &block)
+    Loader.register_tag(tag, &block)
+  end
+end
+
+CBOR.register_class Time, CBOR::Consts::Tag::DATETIME do |val|
+  dump(val.iso8601(6))
+end
+
+CBOR.register_tag CBOR::Consts::Tag::DATETIME do
+  Time.iso8601(load)
+end
+
+CBOR.register_class BigDecimal, CBOR::Consts::Tag::DECIMAL do |val|
+  sign, significant_digits, base, exponent = val.split
+  raise CBOR::CborError.new("NaN while sending BigDecimal #{val.inspect}") if sign == 0
+  val = sign * significant_digits.to_i(base)
+  dump([exponent - significant_digits.size, val])
+end
+
+CBOR.register_tag CBOR::Consts::Tag::DECIMAL do
+  arr = load
+  raise CBOR::CborError.new("invalid decimal") if arr.length != 2
+  BigDecimal.new(arr[1]) * (BigDecimal.new(10) ** arr[0])
+end
+
+if defined? UUIDTools::UUID
+  CBOR.register_class UUIDTools::UUID, CBOR::Consts::Tag::UUID do |val|
+    dump val.raw.b
+  end
+
+  CBOR.register_tag CBOR::Consts::Tag::UUID do
+    UUIDTools::UUID.parse_raw(load)
+  end
+end

data/lib/cbor/consts.rb

@@ -0,0 +1,27 @@
+module CBOR::Consts
+  module Major
+    UINT = 0
+    NEGINT = 1
+    BYTESTRING = 2
+    TEXTSTRING = 3
+    ARRAY = 4
+    MAP = 5
+    TAG = 6
+    SIMPLE = 7
+  end
+
+  module Tag
+    DATETIME = 0
+    DECIMAL = 4
+    UUID = 37
+  end
+
+  module Simple
+    FALSE = 20
+    TRUE = 21
+    NULL = 22
+    FLOAT16 = 25
+    FLOAT32 = 26
+    FLOAT64 = 27
+  end
+end

data/lib/cbor/dumper.rb

@@ -0,0 +1,67 @@
+class CBOR::Dumper
+  include CBOR::Consts
+
+  @@registered_classes = {}
+
+  def self.register_class(klass, tag, &block)
+    @@registered_classes[klass] = {
+      tag: tag,
+      block: block
+    }
+  end
+
+  def dump(val)
+    case val
+    when nil
+      dump_simple(Simple::NULL)
+    when TrueClass
+      dump_simple(Simple::TRUE)
+    when FalseClass
+      dump_simple(Simple::FALSE)
+    when Fixnum, Bignum
+      if val < 0
+        dump_uint(Major::NEGINT, -val-1)
+      else
+        dump_uint(Major::UINT, val)
+      end
+    when Float
+      dump_simple(Simple::FLOAT64) + [val].pack("G")
+    when String, Symbol
+      s = val.to_s.dup.force_encoding(Encoding::UTF_8)
+      dump_uint(s.valid_encoding? ? Major::TEXTSTRING : Major::BYTESTRING, s.bytesize) + s.b
+    when Array
+      dump_uint(Major::ARRAY, val.count) + val.map{|e| dump(e)}.join
+    when Hash
+      dump_uint(Major::MAP, val.count) + val.map{|k, v| dump(k.to_s) + dump(v)}.join
+    else
+      if h = @@registered_classes[val.class]
+        dump_uint(Major::TAG, h[:tag]) + instance_exec(val, &h[:block])
+      else
+        raise CBOR::CborError.new("dumping not supported for objects of type #{val.class} (#{val.inspect})")
+      end
+    end
+  end
+
+  private
+
+  def dump_uint(major, val)
+    typeInt = (major << 5);
+    if val <= 23
+      [typeInt | val].pack("C")
+    elsif val < 0x100
+      [typeInt | 24, val].pack("CC")
+    elsif val < 0x10000
+      [typeInt | 25, val].pack("CS>")
+    elsif val < 0x100000000
+      [typeInt | 26, val].pack("CL>")
+    elsif val < 0x10000000000000000
+      [typeInt | 27, val].pack("CQ>")
+    else
+      raise CBOR::CborError.new("this cbor implementation only supports integers up to 64bit")
+    end
+  end
+
+  def dump_simple(val)
+    [(Major::SIMPLE << 5) | val].pack("C")
+  end
+end

data/lib/cbor/error.rb

@@ -0,0 +1,3 @@
+module CBOR
+  class CborError < RuntimeError; end
+end

data/lib/cbor/loader.rb

@@ -0,0 +1,94 @@
+class CBOR::Loader
+  include CBOR::Consts
+
+  @@registered_tags = {}
+
+  def self.register_tag(tag, &block)
+    @@registered_tags[tag] = block
+  end
+
+  def initialize(io, local_tags)
+    @io = io
+    @local_tags = local_tags
+  end
+
+  def load
+    typeInt = get_bytes(1, "C")
+    major = (typeInt >> 5)
+
+    case major
+    when Major::UINT
+      get_uint(typeInt)
+    when Major::NEGINT
+      -get_uint(typeInt)-1
+    when Major::BYTESTRING
+      count = get_uint(typeInt)
+      get_bytes(count, "a*")
+    when Major::TEXTSTRING
+      count = get_uint(typeInt)
+      s = get_bytes(count, "a*").force_encoding(Encoding::UTF_8)
+      unless s.valid_encoding?
+        raise CBOR::CborError.new("Received non-utf8 string when expecting utf8")
+      end
+      s
+    when Major::ARRAY
+      count = get_uint(typeInt)
+      count.times.map { load }
+    when Major::MAP
+      count = get_uint(typeInt)
+      Hash[count.times.map { [load, load] }]
+    when Major::TAG
+      tag = get_uint(typeInt)
+      if block = @@registered_tags[tag]
+        instance_exec(&block)
+      elsif block = @local_tags[tag]
+        instance_exec(&block)
+      else
+        raise CBOR::CborError.new("Unknown tag #{tag}")
+      end
+    when Major::SIMPLE
+      case typeInt & 0x1F
+      when Simple::FALSE
+        false
+      when Simple::TRUE
+        true
+      when Simple::NULL
+        nil
+      when Simple::FLOAT32
+        get_bytes(4, "g")
+      when Simple::FLOAT64
+        get_bytes(8, "G")
+      else
+        raise CBOR::CborError.new("Unknown simple type #{simple}")
+      end
+    else
+      raise CBOR::CborError.new("Unknown major type #{major}")
+    end
+  end
+
+  private
+
+  def get_uint(typeInt)
+    smallLen = typeInt & 0x1F
+    case smallLen
+    when 24
+      get_bytes(1, "C")
+    when 25
+      get_bytes(2, "S>")
+    when 26
+      get_bytes(4, "L>")
+    when 27
+      get_bytes(8, "Q>")
+    else
+      smallLen
+    end
+  end
+
+  def get_bytes(count, pack_opts)
+    s = @io.read(count)
+    if s.size < count
+      raise CBOR::CborError.new("Unexpected end of input")
+    end
+    s.unpack(pack_opts).first
+  end
+end

data/lib/cbor/version.rb

@@ -0,0 +1,3 @@
+module CBOR
+  VERSION = "1.0.0"
+end

data/test/data.rb

@@ -0,0 +1,25 @@
+TEST_DATA = {
+  "\xf6".b => nil,
+  "\xf5".b => true,
+  "\xf4".b => false,
+  "\x01".b => 1,
+  "\x18\x2a".b => 42,
+  "\x18\x64".b => 100,
+  "\x1a\x00\x0f\x42\x40".b => 1000000,
+  "\x1b\x00\x00\x00\xe8\xd4\xa5\x10\x00".b => 1000000000000,
+  "\x20".b => -1,
+  "\x38\x63".b => -100,
+  "\x39\x03\xe7".b => -1000,
+  "\x3b\x00\x00\x00\xe8\xd4\xa5\x0f\xff".b => -1000000000000,
+  "\xfb\x3f\xf1\x99\x99\x99\x99\x99\x9a".b => 1.1,
+  "\xfb\x7e\x37\xe4\x3c\x88\x00\x75\x9c".b => 1.0e+300,
+  "\x42\xc3\x28".b => "\xc3\x28".b,
+  "\x66foobar".b => "foobar",
+  "\x67f\xc3\xb6obar".b => "föobar",
+  "\x82\x63foo\x63bar".b => ["foo", "bar"],
+  "\xa2\x63foo\x01\x63bar\x02".b => {"foo" => 1, "bar" => 2},
+  "\xc0\x78\x1b\x32\x30\x31\x33\x2d\x30\x33\x2d\x32\x31\x54\x32\x30\x3a\x30\x34\x3a\x30\x30.000000\x5a".b => Time.iso8601("2013-03-21T20:04:00Z"),
+  "\xc0\x78\x1b\x32\x30\x31\x33\x2d\x30\x33\x2d\x32\x31\x54\x32\x30\x3a\x30\x34\x3a\x30\x30.000001\x5a".b => Time.iso8601("2013-03-21T20:04:00.000001Z"),
+  "\xc4\x82\x21\x19\x6a\xb3".b => BigDecimal.new("273.15"),
+  "\xd8\x25\x50\xD5\x06\x81\xAE\xB2\xC1\x49\x4B\xB2\x6E\x7F\xA4\xF7\xEE\x61\x37".b => UUIDTools::UUID.parse("D50681AE-B2C1-494B-B26E-7FA4F7EE6137"),
+}

data/test/dump_test.rb

@@ -0,0 +1,27 @@
+require "test_helper"
+require "data"
+
+class TestDump < Minitest::Test
+  def test_dumping
+    TEST_DATA.each do |bin, val|
+      assert_equal bin, CBOR.dump(val), "dumping #{val.inspect}"
+    end
+  end
+
+  class Dummy; end
+  def test_dump_invalid
+    assert_raises CBOR::CborError do
+      CBOR.dump(Dummy.new)
+    end
+  end
+
+  def test_dump_large_int
+    assert_raises CBOR::CborError do
+      CBOR.dump(18446744073709551616)
+    end
+  end
+
+  def test_dumps_symbols
+    assert_equal "\x66foobar".b, CBOR.dump(:foobar)
+  end
+end

data/test/load_test.rb

@@ -0,0 +1,19 @@
+require "test_helper"
+
+class TestLoad < Minitest::Test
+  def test_loading
+    TEST_DATA.each do |bin, val|
+      assert_equal val, CBOR.load(bin), "loading #{val.inspect}"
+    end
+  end
+
+  def test_loading_from_junk
+    assert_raises CBOR::CborError do
+      CBOR.load(5)
+    end
+  end
+
+  def test_loading_local_tags
+    assert_equal false, CBOR.load("\xd8\x26\xf5", {0x26 => ->{ !load }})
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+require "minitest/autorun"
+require "minitest/emoji"
+require "uuidtools"
+require "cbor"

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: cbor-simple
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Lucas Clemente
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: minitest
+  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: minitest-emoji
+  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: uuidtools
+  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'
+description: 
+email:
+- lucas@clemente.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- cbor-simple.gemspec
+- lib/cbor.rb
+- lib/cbor/consts.rb
+- lib/cbor/dumper.rb
+- lib/cbor/error.rb
+- lib/cbor/loader.rb
+- lib/cbor/version.rb
+- test/data.rb
+- test/dump_test.rb
+- test/load_test.rb
+- test/test_helper.rb
+homepage: https://github.com/lucas-clemente/cbor-simple
+licenses:
+- MIT
+metadata: {}
+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: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Basic but extensible CBOR implementation for ruby.
+test_files:
+- test/data.rb
+- test/dump_test.rb
+- test/load_test.rb
+- test/test_helper.rb