libcbor 0.1.0.pre.alpha

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 72e98b82d68080ed07cff8821dc4a1416bc3a9f4
+  data.tar.gz: 99c9cfbfd0952ce27307a538c2983f2e8a0831f0
+SHA512:
+  metadata.gz: d7e39fb6fa4221c4bc220612b6b1b65e9f572e19723dfb83dcff4d51d3caa75c86dd667dc9570b506cf386115280a1ce7154c313a8f67aaf37d74cdde468b622
+  data.tar.gz: 5f03642c8f5505fa28a2a950e4706b59333e840cf3fa274511de0aef460fecc3e2f120b4bce89af9183e151ed628384bbbc5ba487d8e0c5611d36bfca37f290c

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.idea
+.ruby-version

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,16 @@
+language: ruby
+rvm:
+  - jruby
+  - rbx-2.1.1
+  - 2.0.0
+  - 2.1.1
+  - 2.2.1
+script: bundle exec rspec spec
+before_install:
+  - wget https://github.com/PJK/libcbor/archive/master.zip
+  - unzip master.zip
+  - cd libcbor-master
+  - cmake .
+  - make cbor cbor_shared
+  - sudo make install
+  - cd ..

data/Gemfile

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

data/README.md

@@ -0,0 +1,39 @@
+# libcbor
+
+The Ruby bindings for [libcbor](https://github.com/PJK/libcbor)
+
+
+## Installation
+
+Make sure that `libffi-dev` is present on your system.
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'libcbor'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install libcbor
+
+## Usage
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/libcbor/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "libcbor"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/examples/data/indef_string.cbor

@@ -0,0 +1 @@
+eHellofworld!�

data/examples/data/integer.cbor

@@ -0,0 +1 @@
+*

data/examples/data/map.cbor

@@ -0,0 +1 @@
+�dcbor#)djson�gbaaaaad

data/examples/data/nested_array.cbor

@@ -0,0 +1 @@
+�
���

data/examples/data/tagged_date.cbor

@@ -0,0 +1 @@
+�t2013-03-21T20:04:00Z

data/examples/load_file.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+# Load all CBOR files passed as arguments and prints the result.
+# Example usage:
+# $ ./examples/load_file.rb examples/data/*
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..'))
+require 'lib/libcbor'
+require 'pp'
+
+ARGV.each { |_| PP.pp  CBOR.decode(IO.read(_)) }

data/lib/libcbor.rb

@@ -0,0 +1,45 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'rubygems'
+require 'ffi'
+
+require 'libcbor/version'
+require 'libcbor/inner/lib_cbor'
+require 'libcbor/inner/lib_c'
+require 'libcbor/cache'
+require 'libcbor/tag'
+require 'libcbor/helpers'
+require 'libcbor/cbor_item'
+require 'libcbor/streaming/callback_simplifier'
+require 'libcbor/streaming/buffered_decoder'
+require 'libcbor/streaming/encoder'
+
+module CBOR
+	class DecodingError < StandardError; end
+
+	def self.encode(obj)
+		obj.to_cbor
+	end
+
+	def method_name
+		@@method_name
+	end
+
+	def self.load!(name = nil)
+		@@method_name = name
+		%w{Fixnum Float Array Hash String TrueClass FalseClass NilClass Tag}.each do |klass|
+			const_get(klass).send(:include, const_get('::CBOR::' + klass + 'Helper'))
+		end
+	end
+
+	def self.decode(data)
+		res = FFI::MemoryPointer.new LibCBOR::CborLoadResult
+		CBORItem.new(
+			LibCBOR.cbor_load(FFI::MemoryPointer.from_string(data), data.bytes.count, res).
+				tap { |ptr| raise DecodingError if ptr.null? }
+		).value
+	end
+end
+
+
+

data/lib/libcbor/cache.rb

@@ -0,0 +1,26 @@
+module CBOR
+	# Provides caching for simple values (true, false, nil)
+	class Cache
+		@@bfr = FFI::Buffer.new(:uchar, 1)
+
+		def self.get_bool(val)
+			@@bfr.get_bytes(0, LibCBOR.cbor_encode_bool(val, @@bfr, 1))
+		end
+
+		def self.get_null
+			@@bfr.get_bytes(0, LibCBOR.cbor_encode_null(@@bfr, 1))
+		end
+
+		def self.true
+			@@true ||= get_bool(true)
+		end
+
+		def self.false
+			@@false ||= get_bool(false)
+		end
+
+		def self.nil
+			@@null ||= get_null
+		end
+	end
+end

data/lib/libcbor/cbor_item.rb

@@ -0,0 +1,64 @@
+module CBOR
+	# Wraps native `cbor_item_t *`
+	class CBORItem < Struct.new(:handle)
+		def type
+			LibCBOR.cbor_typeof(handle)
+		end
+
+		def value
+			case type
+				when :uint
+					LibCBOR.cbor_get_int(handle)
+				when :negint
+					-LibCBOR.cbor_get_int(handle) - 1
+				when :string
+					LibCBOR
+						.cbor_string_handle(handle)
+						.get_string(0, LibCBOR.cbor_string_length(handle))
+				when :bytestring
+					LibCBOR
+						.cbor_bytestring_handle(handle)
+						.get_string(0, LibCBOR.cbor_bytestring_length(handle))
+				when :array
+					LibCBOR
+						.cbor_array_handle(handle)
+						.read_array_of_type(LibCBOR::CborItemTRef, :read_pointer, LibCBOR.cbor_array_size(handle))
+						.map { |item| CBORItem.new(item).value }
+				when :map
+					pairs_handle = LibCBOR.cbor_map_handle(handle)
+					Hash[LibCBOR.cbor_map_size(handle).times.map { |idx|
+						pair = LibCBOR::CborPair.new(pairs_handle + LibCBOR::CborPair.size * idx)
+						[pair[:key], pair[:value]].map { |ptr| CBORItem.new(ptr).value }
+					}]
+				when :tag
+					Tag.new(
+						LibCBOR.cbor_tag_value(handle),
+						CBORItem.new(LibCBOR.cbor_tag_item(handle)).value
+					)
+				when :float_ctrl
+					load_float
+				else
+					raise 'Unknown type - the FFI enum mapping is probably broken. Please report this bug.'
+			end
+		end
+
+		protected
+
+		def load_float
+			if LibCBOR.cbor_float_ctrl_is_ctrl(handle)
+				case ctr_val = LibCBOR.cbor_ctrl_value(handle)
+					when 20
+						false
+					when 21
+						true
+					when 22
+						nil
+					else
+						ctr_val
+				end
+			else
+				LibCBOR.cbor_float_get_float(handle)
+			end
+		end
+	end
+end

data/lib/libcbor/helpers.rb

@@ -0,0 +1,82 @@
+module CBOR
+	module FixnumHelper
+		def to_cbor
+			@@bfr ||= FFI::Buffer.new(:uchar, 9)
+			if self >= 0
+				@@bfr.get_bytes(0, LibCBOR.cbor_encode_uint(self, @@bfr, 9))
+			else
+				@@bfr.get_bytes(0, LibCBOR.cbor_encode_negint(-self - 1, @@bfr, 9))
+			end
+		end
+	end
+
+	module FloatHelper
+		def to_cbor
+			@@bfr ||= FFI::Buffer.new(:uchar, 9)
+			@@bfr.get_bytes(0, LibCBOR.cbor_encode_single(self, @@bfr, 9))
+		end
+	end
+
+	module StringHelper
+		def to_cbor
+			@@item ||= LibCBOR.cbor_new_definite_string
+			string = FFI::MemoryPointer.from_string(self)
+			out_bfr = FFI::MemoryPointer.new :pointer
+			out_bfr_len = FFI::MemoryPointer.new :size_t
+			LibCBOR.cbor_string_set_handle(@@item, string, bytes.length)
+			res_len = LibCBOR.cbor_serialize_alloc(@@item, out_bfr, out_bfr_len)
+			out_bfr.read_pointer.get_bytes(0, res_len).tap do
+				LibC.free(out_bfr.read_pointer)
+			end
+		end
+	end
+
+	module ArrayHelper
+		def to_cbor
+			@@bfr ||= FFI::Buffer.new(:uchar, 9)
+			header = @@bfr.get_bytes(0, LibCBOR.cbor_encode_array_start(count, @@bfr, 9))
+			each do |member|
+				header += member.to_cbor
+			end
+			header
+		end
+	end
+
+	module HashHelper
+		def to_cbor
+			@@bfr ||= FFI::Buffer.new(:uchar, 9)
+			header = @@bfr.get_bytes(0, LibCBOR.cbor_encode_map_start(count, @@bfr, 9))
+			each do |member|
+				header += member.first.to_cbor
+				header += member.last.to_cbor
+			end
+			header
+		end
+	end
+
+	module TagHelper
+		def to_cbor
+			@@bfr ||= FFI::Buffer.new(:uchar, 9)
+			header = @@bfr.get_bytes(0, LibCBOR.cbor_encode_tag(value, @@bfr, 9))
+			header + item.to_cbor
+		end
+	end
+
+	module TrueClassHelper
+		def to_cbor
+			Cache.true
+		end
+	end
+
+	module FalseClassHelper
+		def to_cbor
+			Cache.false
+		end
+	end
+
+	module NilClassHelper
+		def to_cbor
+			Cache.nil
+		end
+	end
+end

data/lib/libcbor/inner.rb

@@ -0,0 +1,28 @@
+require 'ffi'
+
+module LibC
+	ffi_lib FFI::Library::LIBC
+	extend FFI::Library
+
+	# memory allocators
+	attach_function :malloc, [:size_t], :pointer
+	attach_function :calloc, [:size_t], :pointer
+	attach_function :valloc, [:size_t], :pointer
+	attach_function :realloc, [:pointer, :size_t], :pointer
+	attach_function :free, [:pointer], :void
+
+	# memory movers
+	attach_function :memcpy, [:pointer, :pointer, :size_t], :pointer
+	attach_function :bcopy, [:pointer, :pointer, :size_t], :void
+
+end # module LibC
+
+module Libcbor
+	extend FFI::Library
+	ffi_lib 'cbor'
+	attach_function :cbor_new_int8, [], :pointer
+	attach_function :cbor_set_uint16, [:pointer, :ushort], :void
+	attach_function :cbor_set_uint8, [:pointer, :uchar], :void
+	attach_function :cbor_serialize, [:pointer, :pointer, :size_t], :size_t
+	puts 'yo'
+end

data/lib/libcbor/inner/lib_c.rb

@@ -0,0 +1,11 @@
+# Provides
+module CBOR::LibC
+	extend FFI::Library
+	ffi_lib FFI::Library::LIBC
+
+	attach_function :malloc, [:size_t], :pointer
+	attach_function :free, [:pointer], :void
+
+	attach_function :memcpy, [:pointer, :pointer, :size_t], :pointer
+	attach_function :bcopy, [:pointer, :pointer, :size_t], :void
+end

data/lib/libcbor/inner/lib_cbor.rb

@@ -0,0 +1,135 @@
+module CBOR
+	module LibCBOR
+		extend FFI::Library
+		ffi_lib 'cbor'
+
+		CborItemTRef = typedef :pointer, :cbor_item_t_ref
+		typedef :pointer, :cbor_item_t_ref_array
+		typedef :pointer, :buffer
+		typedef :pointer, :memblock # unsigned char * - string & bytestring handles, raw blocks
+
+		ErrorCode = enum(:none, :notenoughdata, :nodata, :malformated, :memerror, :syntaxerror)
+
+		class CborError < FFI::Struct
+			layout :position, :size_t,
+				:code, ErrorCode
+		end
+
+		class CborLoadResult < FFI::Struct
+			layout :error, CborError,
+				:read, :size_t
+		end
+
+		class CborPair < FFI::Struct
+			layout :key, CborItemTRef,
+				:value, CborItemTRef
+		end
+
+		typedef :pointer, :cbor_pair_array
+
+		typedef :pointer, :cbor_load_result_ref
+
+		attach_function :cbor_decref, [:pointer], :void
+		attach_function :cbor_serialize, [:pointer, :pointer, :size_t], :size_t
+		attach_function :cbor_encode_uint, [:uint64, :pointer, :size_t], :size_t
+		attach_function :cbor_encode_negint, [:uint64, :pointer, :size_t], :size_t
+		attach_function :cbor_encode_single, [:float, :pointer, :size_t], :size_t
+		attach_function :cbor_encode_array_start, [:size_t, :pointer, :size_t], :size_t
+		attach_function :cbor_encode_map_start, [:size_t, :pointer, :size_t], :size_t
+		attach_function :cbor_encode_tag, [:uint64, :pointer, :size_t], :size_t
+		attach_function :cbor_encode_bool, [:bool, :pointer, :size_t], :size_t
+		attach_function :cbor_encode_null, [:pointer, :size_t], :size_t
+		attach_function :cbor_encode_undef, [:pointer, :size_t], :size_t
+		# size_t cbor_serialize_alloc(const cbor_item_t * item, unsigned char ** buffer, size_t * buffer_size);
+		attach_function :cbor_serialize_alloc, [:pointer, :pointer, :pointer], :size_t
+
+		attach_function :cbor_new_definite_string, [], :pointer
+		# void cbor_string_set_handle(cbor_item_t *item, unsigned char *data, size_t length);
+		attach_function :cbor_string_set_handle, [:pointer, :pointer, :size_t], :void
+
+		Type = enum(:uint, :negint, :bytestring, :string, :array, :map, :tag, :float_ctrl)
+
+		attach_function :cbor_typeof, [:cbor_item_t_ref], Type
+		attach_function :cbor_load, [:buffer, :size_t, :cbor_load_result_ref], :cbor_item_t_ref
+
+		attach_function :cbor_get_int, [:cbor_item_t_ref], :uint64
+
+		attach_function :cbor_string_length, [:cbor_item_t_ref], :size_t
+		attach_function :cbor_string_handle, [:cbor_item_t_ref], :memblock
+
+		attach_function :cbor_bytestring_length, [:cbor_item_t_ref], :size_t
+		attach_function :cbor_bytestring_handle, [:cbor_item_t_ref], :memblock
+
+		attach_function :cbor_array_size, [:cbor_item_t_ref], :size_t
+		attach_function :cbor_array_handle, [:cbor_item_t_ref], :cbor_item_t_ref_array
+
+		attach_function :cbor_map_size, [:cbor_item_t_ref], :size_t
+		attach_function :cbor_map_handle, [:cbor_item_t_ref], :cbor_pair_array
+
+		attach_function :cbor_tag_value, [:cbor_item_t_ref], :uint64
+		attach_function :cbor_tag_item, [:cbor_item_t_ref], :cbor_item_t_ref
+
+		attach_function :cbor_float_ctrl_is_ctrl, [:cbor_item_t_ref], :bool
+		attach_function :cbor_ctrl_value, [:cbor_item_t_ref], :uint8
+		attach_function :cbor_float_get_float, [:cbor_item_t_ref], :double
+
+		callback :cbor_int8_callback, [:pointer, :uint8], :void
+		callback :cbor_int16_callback, [:pointer, :uint16], :void
+		callback :cbor_int32_callback, [:pointer, :uint32], :void
+		callback :cbor_int64_callback, [:pointer, :uint64], :void
+		callback :cbor_simple_callback, [:pointer], :void
+		callback :cbor_string_callback, [:pointer, :pointer, :size_t], :void
+		callback :cbor_collection_callback, [:pointer, :size_t], :void
+		callback :cbor_float_callback, [:pointer, :float], :void
+		callback :cbor_double_callback, [:pointer, :double], :void
+		callback :cbor_bool_callback, [:pointer, :bool], :void
+
+		class CborCallbacks < FFI::Struct
+			layout :uint8, :cbor_int8_callback,
+				:uint16, :cbor_int16_callback,
+				:uint32, :cbor_int32_callback,
+				:uint64, :cbor_int64_callback,
+
+				:negint8, :cbor_int8_callback,
+				:negint16, :cbor_int16_callback,
+				:negint32, :cbor_int32_callback,
+				:negint64, :cbor_int64_callback,
+
+				:byte_string, :cbor_string_callback,
+				:byte_string_start, :cbor_simple_callback,
+
+				:string, :cbor_string_callback,
+				:string_start, :cbor_simple_callback,
+
+				:array_start, :cbor_collection_callback,
+				:indef_array_start, :cbor_simple_callback,
+
+				:map_start, :cbor_collection_callback,
+				:indef_map_start, :cbor_simple_callback,
+
+				:tag, :cbor_int64_callback,
+
+				:float2, :cbor_float_callback,
+				:float4, :cbor_float_callback,
+				:float8, :cbor_double_callback,
+
+				:undefined, :cbor_simple_callback,
+				:null, :cbor_simple_callback,
+				:boolean, :cbor_bool_callback,
+
+				:indef_break, :cbor_simple_callback
+		end
+
+		DecoderStatus = enum(:finished, :not_enough_data, :buffer_error, :error)
+
+		class CborDecoderResult < FFI::Struct
+			layout :read, :size_t,
+				:status, DecoderStatus
+		end
+
+		# buffer, buffer size, callbacks, context
+		attach_function :cbor_stream_decode, [:pointer, :size_t, :pointer, :pointer], CborDecoderResult.by_value
+
+		attach_function :cbor_encode_tag, [:uint64, :memblock, :size_t], :size_t
+	end
+end

data/lib/libcbor/inner/prealloc.rb

@@ -0,0 +1,10 @@
+# Provides a fixed, pre-allocated pool of common data items
+# that can be used for quickly encoding atomic values without
+# the need for allocation
+module CBOR
+	class Prealloc
+		def initialize
+
+		end
+	end
+end

data/lib/libcbor/streaming/buffered_decoder.rb

@@ -0,0 +1,51 @@
+module CBOR
+	module Streaming
+		class BufferedDecoder
+			def initialize(callbacks = {})
+				@callbacks = {
+					integer: Proc.new {},
+					string: Proc.new {},
+					chunked_string_start: Proc.new {},
+					byte_string: Proc.new {},
+					chunked_byte_string_start: Proc.new {},
+					float: Proc.new {},
+					definite_array: Proc.new {},
+					array_start: Proc.new {},
+					definite_map: Proc.new {},
+					map_start: Proc.new {},
+					tag: Proc.new {},
+					bool: Proc.new {},
+					null: Proc.new {},
+					simple: Proc.new {},
+					break: Proc.new {},
+				}.merge(callbacks)
+				@buffer = ''
+				@proxy = CallbackSimplifier.new(self)
+			end
+
+			def <<(data)
+				@buffer += data
+				loop do
+					read = LibCBOR.cbor_stream_decode(
+						FFI::MemoryPointer.from_string(@buffer),
+						@buffer.bytes.length,
+						@proxy.callback_set.to_ptr,
+						nil
+					)[:read]
+					break if read == 0
+					@buffer = @buffer[read .. -1]
+				end
+			end
+
+			def callback(name, *args)
+				callbacks[name].call(*args)
+			end
+
+			attr_reader :buffer
+
+			protected
+
+			attr_reader :callbacks
+		end
+	end
+end

data/lib/libcbor/streaming/callback_simplifier.rb

@@ -0,0 +1,55 @@
+module CBOR
+	module Streaming
+		# Abstracts aways callback specifics, such as integer width
+		class CallbackSimplifier < Struct.new(:target)
+			def callback_set
+				@cset ||= build_callback_set
+			end
+
+			protected
+
+			def build_callback_set
+				callbacks = LibCBOR::CborCallbacks.new
+				callbacks[:uint8] = Proc.new { |_ctx, val| target.callback(:integer, val) }
+				callbacks[:uint16] = callbacks[:uint8]
+				callbacks[:uint32] = callbacks[:uint8]
+				callbacks[:uint64] = callbacks[:uint8]
+
+				callbacks[:negint8] = Proc.new { |_ctx, val| target.callback(:integer, -val - 1) }
+				callbacks[:negint16] = callbacks[:negint8]
+				callbacks[:negint32] = callbacks[:negint8]
+				callbacks[:negint64] = callbacks[:negint8]
+
+				callbacks[:byte_string] = Proc.new { |_ctx, ptr, size|
+					target.callback(:byte_string, ptr.get_string(0, size))
+				}
+				callbacks[:byte_string_start] = Proc.new { |_ctx| target.callback(:chunked_byte_string_start) }
+
+				callbacks[:string] = Proc.new { |_ctx, ptr, size|
+					target.callback(:string, ptr.get_string(0, size))
+				}
+				callbacks[:string_start] = Proc.new { |_ctx| target.callback(:chunked_string_start) }
+
+				callbacks[:array_start] = Proc.new { |_ctx, size| target.callback(:definite_array, size) }
+				callbacks[:indef_array_start] = Proc.new { |_ctx| target.callback(:array_start) }
+
+				callbacks[:map_start] = Proc.new { |_ctx, size| target.callback(:definite_map, size) }
+				callbacks[:indef_map_start] = Proc.new { |_ctx| target.callback(:map_start) }
+
+				callbacks[:tag] = Proc.new { |_ctx, val| target.callback(:tag, val) }
+
+				callbacks[:float2] = Proc.new { |_ctx, val| target.callback(:float, val) }
+				callbacks[:float4] = callbacks[:float2]
+				callbacks[:float8] = callbacks[:float2]
+
+				callbacks[:undefined] = Proc.new { |_ctx| target.callback(:simple, 23) }
+				callbacks[:null] = Proc.new { |_ctx| target.callback(:null) }
+				callbacks[:boolean] = Proc.new { |_ctx, val| target.callback(:bool, val) }
+
+				callbacks[:indef_break] = Proc.new { |_ctx| target.callback(:break) }
+
+				callbacks
+			end
+		end
+	end
+end

data/lib/libcbor/streaming/encoder.rb

@@ -0,0 +1,34 @@
+module CBOR
+	module Streaming
+		class Encoder < Struct.new(:target)
+			def <<(object)
+				target.write(object.to_cbor)
+			end
+
+			def start_array
+				target.write("\x9f")
+			end
+
+			def start_map
+				target.write("\xbf")
+			end
+
+			def start_chunked_string
+				target.write("\x9f")
+			end
+
+			def start_chunked_byte_string
+				target.write("\x5f")
+			end
+
+			def tag(value)
+				@@bfr ||= FFI::Buffer.new(:uchar, 9)
+				@@bfr.get_bytes(0, LibCBOR.cbor_encode_tag(value, @@bfr, 9))
+			end
+
+			def break
+				target.write("\xff")
+			end
+		end
+	end
+end

data/lib/libcbor/tag.rb

@@ -0,0 +1,4 @@
+module CBOR
+	class Tag < Struct.new(:value, :item)
+	end
+end

data/lib/libcbor/version.rb

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

data/libcbor.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'libcbor/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "libcbor"
+  spec.version       = CBOR::VERSION
+  spec.authors       = ["PJK"]
+  spec.email         = ["me@pavelkalvoda.com"]
+
+  spec.summary       = %q{A Ruby binding for libcbor}
+  spec.description   = %q{CBOR (Concise Binary Object Representation) implementation based on the libcbor C library. Provides all the encoding and decoding facilities of libcbor, including the streaming interface}
+  spec.homepage      = "https://github.com/PJK/libcbor-ruby"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+
+  spec.add_development_dependency "bundler", "> 1.8"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "> 3"
+  spec.add_development_dependency "pry"
+
+  spec.add_runtime_dependency "ffi"
+end

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification
+name: libcbor
+version: !ruby/object:Gem::Version
+  version: 0.1.0.pre.alpha
+platform: ruby
+authors:
+- PJK
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-05-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.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>'
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>'
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>'
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: pry
+  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: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: CBOR (Concise Binary Object Representation) implementation based on the
+  libcbor C library. Provides all the encoding and decoding facilities of libcbor,
+  including the streaming interface
+email:
+- me@pavelkalvoda.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- examples/data/floats.cbor
+- examples/data/indef_string.cbor
+- examples/data/integer.cbor
+- examples/data/map.cbor
+- examples/data/nested_array.cbor
+- examples/data/tagged_date.cbor
+- examples/load_file.rb
+- lib/libcbor.rb
+- lib/libcbor/cache.rb
+- lib/libcbor/cbor_item.rb
+- lib/libcbor/helpers.rb
+- lib/libcbor/inner.rb
+- lib/libcbor/inner/lib_c.rb
+- lib/libcbor/inner/lib_cbor.rb
+- lib/libcbor/inner/prealloc.rb
+- lib/libcbor/streaming/buffered_decoder.rb
+- lib/libcbor/streaming/callback_simplifier.rb
+- lib/libcbor/streaming/encoder.rb
+- lib/libcbor/tag.rb
+- lib/libcbor/version.rb
+- libcbor.gemspec
+homepage: https://github.com/PJK/libcbor-ruby
+licenses: []
+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: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: A Ruby binding for libcbor
+test_files: []