rencoder 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2e4a5fe649e623f7058b7e081b03710bb11a16dc
+  data.tar.gz: f1a19bd39b9d269f72ca11d22deb1f12abbb859a
+SHA512:
+  metadata.gz: d5f773dac8f19d1409d5febdac6cb94f2360b7fb21962fcafa59c662725b955804594ccf93d802e02df950ae5a3e24423268b0cf97c59d10dcaeabc3d5179685
+  data.tar.gz: 716bfbe002718eac3ea92b3803e8a3426e788d3d882405d1862afd62cd0cec33a3fc4a21671cf22bd6d4d42fcaabf167662c85f857a22aeacbe52a02fbaa432d

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+*.gem

data/.ruby-version

@@ -0,0 +1 @@
+2.1.4

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rencoder.gemspec
+gemspec
+
+gem 'rencode-ruby'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Igor Yamolov
+
+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,65 @@
+# Rencoder
+
+Rencoder is pure Ruby implementation of Rencoder serialization format encoding/decoding.
+
+Rencoder is *FULLY* compliant with Python implementation, and uses all optimizations (by-type-offset integers, strings, arrays, hashes) both in encoding and decoding.
+
+## Usage
+
+### Serialization
+
+```ruby
+require 'rencoder'
+
+Rencode.dump("Hello World") # Strings
+
+Rencode.dump(100) # Integer
+
+Rencoder.dump(1.0001) # Floats
+
+Rencoder.dump({ hello: "world" }) # Hashes
+
+Rencoder.dump(["hello", :world, 123]) # Arrays
+```
+
+**Float precion notice**
+Rencoder uses 64-bit precision by default.
+It's highly recommended to stay that way.
+If there is strong reason to use 32-bit precision, then please specify 
+``float32: true`` option for ``Rencoder.dump``:
+
+```ruby
+Rencoder.dump(1.000001, float32: true)
+```
+***Using 32-bit precision is highly NOT recommended***
+
+### Deserialization
+
+```ruby
+require 'rencoder'
+
+Rencoder.load(hash_data)
+# => { 'hello': 'world' }
+
+Rencoder.load(string_data)
+# => "Hello World"
+
+# etc
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rencoder'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rencoder
+

data/lib/rencoder/coder.rb

@@ -0,0 +1,12 @@
+module Rencoder
+  class Coder
+    attr_reader :options
+
+    def initialize(options = {})
+      @options = options
+    end
+
+    include Rencoder::Encoder
+    include Rencoder::Decoder
+  end
+end

data/lib/rencoder/decoder.rb

@@ -0,0 +1,122 @@
+module Rencoder
+  module Decoder
+    INTEGER_DECODING_MAP = {
+      CHR_INT1 => [1, 'c'],
+      CHR_INT2 => [2, 's>'],
+      CHR_INT4 => [4, 'l>'],
+      CHR_INT8 => [8, 'q>']
+    }
+
+    def decode(buffer)
+      buffer = StringIO.new(buffer) unless buffer.respond_to?(:read) # IO object
+
+      type = buffer.getbyte
+
+      case type
+      when STR_HEADER, STR_FIXED
+        decode_string(buffer, type)
+      when CHR_INT, CHR_INT1, CHR_INT2, CHR_INT4, CHR_INT8, INT_POS_FIXED, INT_NEG_FIXED
+        decode_integer(buffer, type)
+      when CHR_FLOAT32, CHR_FLOAT64
+        decode_float(buffer, type)
+      when CHR_TRUE, CHR_FALSE
+        decode_boolean(buffer, type)
+      when CHR_NONE
+        decode_nil(buffer, type)
+      when CHR_LIST, LIST_FIXED
+        decode_array(buffer, type)
+      when CHR_DICT, DICT_FIXED
+        decode_hash(buffer, type)
+      when CHR_TERM
+        :rencode_term
+      else
+        raise "Unknown type '#{type.inspect}'"
+      end
+    end
+
+    private
+
+    def decode_integer(buffer, type)
+      case type
+      when CHR_INT
+        read_till(buffer).to_i
+      when CHR_INT1, CHR_INT2, CHR_INT4, CHR_INT8
+        size, template = INTEGER_DECODING_MAP[type]
+
+        buffer.read(size).unpack(template).first
+      when INT_POS_FIXED
+        type - INT_POS_FIXED_START
+      when INT_NEG_FIXED
+        -1-(type - INT_NEG_FIXED_START)
+      end
+    end
+
+    def decode_float(buffer, type)
+      case type
+      when CHR_FLOAT32
+        buffer.read(4).unpack('g')
+      when CHR_FLOAT64
+        buffer.read(8).unpack('G')
+      end.first
+    end
+
+    def decode_string(buffer, type)
+      case type
+      when STR_FIXED
+        buffer.read(type - STR_FIXED_START)
+      when STR_HEADER
+        length = type.chr + read_till(buffer, ':')
+
+        buffer.read(length.to_i)
+      end
+    end
+
+    def decode_boolean(buffer, type)
+      type == CHR_TRUE
+    end
+
+    def decode_array(buffer, type)
+      case type
+      when CHR_LIST
+        result = []
+
+        while (item = decode(buffer)) != :rencode_term
+          result << item
+        end
+
+        result
+      when LIST_FIXED
+        size = type - LIST_FIXED_START
+
+        size.times.map do |i|
+          decode(buffer)
+        end
+      end
+    end
+
+    def decode_hash(buffer, type)
+      case type
+      when CHR_DICT
+        result = {}
+
+        while (key = decode(buffer)) != :rencode_term
+          result[key] = decode(buffer)
+        end
+
+        result
+      when DICT_FIXED
+        size = type - DICT_FIXED_START
+
+        Hash[size.times.map { [decode(buffer), decode(buffer)] }]
+      end
+    end
+
+    def decode_nil(buffer, type)
+      nil
+    end
+
+    def read_till(buffer, separator = CHR_TERM.chr)
+      buffer.gets(separator).chomp(separator)
+    end
+  end
+end

data/lib/rencoder/encoder.rb

@@ -0,0 +1,96 @@
+module Rencoder
+  module Encoder
+    class EncodingError < StandardError; end
+
+    def encode(object)
+      case object
+      when String, Symbol then encode_string(object)
+      when Fixnum then encode_integer(object)
+      when Float then encode_float(object)
+      when TrueClass, FalseClass then encode_boolean(object)
+      when NilClass then encode_nil(object)
+      when Array then encode_array(object)
+      when Hash then encode_hash(object)
+      else
+        raise EncodingError, "Unable to serialize '#{object.class}'"
+      end
+    end
+
+    def encode_integer(object)
+      case object
+      when (0...INT_POS_FIXED_COUNT) # predefined positive intger
+        [INT_POS_FIXED_START + object].pack('C')
+      when (-INT_NEG_FIXED_COUNT...0) # predefined negative integer
+        [INT_NEG_FIXED_START-1-object].pack('C')
+      when (-128...128)
+        [CHR_INT1, object].pack('Cc') # 8-bit signed
+      when (-32768...32768)
+        [CHR_INT2, object].pack('Cs>') # 16-bit signed
+      when (-2147483648...2147483648)
+        [CHR_INT4, object].pack('Cl>') # 32-bit signed
+      when (-9223372036854775808...9223372036854775808)
+        [CHR_INT8, object].pack('Cq>') # 64-bit signed
+      else # encode as ASCII
+        bytes = object.to_s.bytes
+
+        if bytes.size >= MAX_INT_LENGTH
+          raise EncodingError, "Unable to serialize Fixnum #{object} due to overflow"
+        end
+
+        [CHR_INT, *bytes, CHR_TERM].pack('C*')
+      end
+    end
+
+    def encode_float(object)
+      # Always serialize floats as 64-bit, since single-precision serialization is a poo
+      # If you don't believe me try this:
+      #
+      # [1.1].pack('F').unpack('F').first
+      # => 1.100000023841858
+      #
+      if options[:float32] # not recommended
+        [CHR_FLOAT32, object].pack('Cg')
+      else
+        [CHR_FLOAT64, object].pack('CG')
+      end
+    end
+
+    def encode_string(object)
+      bytes = object.to_s
+
+      if bytes.size < STR_FIXED_COUNT
+        (STR_FIXED_START + bytes.size).chr + bytes
+      else
+        "#{bytes.bytesize.to_s}:#{bytes}"
+      end
+    end
+
+    def encode_boolean(object)
+      [object ? CHR_TRUE : CHR_FALSE].pack('C')
+    end
+
+    def encode_array(object)
+      array_data = object.map { |item| encode(item) }.join
+
+      if object.size < LIST_FIXED_COUNT
+        (LIST_FIXED_START + object.size).chr + array_data
+      else
+        CHR_LIST.chr + array_data + CHR_TERM.chr
+      end
+    end
+
+    def encode_hash(object)
+      hash_data = object.map { |key, value| encode(key) + encode(value) }.join
+
+      if object.size < DICT_FIXED_COUNT
+        (DICT_FIXED_START + object.size).chr + hash_data
+      else
+        CHR_DICT.chr + hash_data + CHR_TERM.chr
+      end
+    end
+
+    def encode_nil(object)
+      [CHR_NONE].pack('C')
+    end
+  end
+end

data/lib/rencoder/version.rb

@@ -0,0 +1,3 @@
+module Rencoder
+  VERSION = '0.1.0'
+end

data/lib/rencoder.rb

@@ -0,0 +1,63 @@
+require 'rencoder/version'
+
+module Rencoder
+  # Rencoder Constants
+  MAX_INT_LENGTH = 64
+
+  # Type constants
+  CHR_LIST    = 59
+  CHR_DICT    = 60
+  CHR_INT     = 61
+  CHR_INT1    = 62
+  CHR_INT2    = 63
+  CHR_INT4    = 64
+  CHR_INT8    = 65
+  CHR_FLOAT32 = 66
+  CHR_FLOAT64 = 44
+  CHR_TRUE    = 67
+  CHR_FALSE   = 68
+  CHR_NONE    = 69
+  CHR_TERM    = 127
+
+  # Dictionaries with length embedded in typecode.
+  DICT_FIXED_START = 102
+  DICT_FIXED_COUNT = 25
+  DICT_FIXED = (DICT_FIXED_START...DICT_FIXED_START + DICT_FIXED_COUNT)
+
+  # Positive integers with value embedded in typecode.
+  INT_POS_FIXED_START = 0
+  INT_POS_FIXED_COUNT = 44
+  INT_POS_FIXED = (INT_POS_FIXED_START...INT_POS_FIXED_START + INT_POS_FIXED_COUNT)
+
+  # Negative integers with value embedded in typecode.
+  INT_NEG_FIXED_START = 70
+  INT_NEG_FIXED_COUNT = 32
+  INT_NEG_FIXED = (INT_NEG_FIXED_START...INT_NEG_FIXED_START + INT_NEG_FIXED_COUNT)
+
+  # String length header
+  STR_HEADER = ('0'.ord..'9'.ord)
+
+  # Strings with length embedded in typecode.
+  STR_FIXED_START = 128
+  STR_FIXED_COUNT = 64
+  STR_FIXED = (STR_FIXED_START..STR_FIXED_START + STR_FIXED_COUNT)
+
+  # Lists with length embedded in typecode.
+  LIST_FIXED_START = STR_FIXED_START+STR_FIXED_COUNT
+  LIST_FIXED_COUNT = 64
+  LIST_FIXED = (LIST_FIXED_START..LIST_FIXED_START + LIST_FIXED_COUNT)
+
+  require_relative 'rencoder/encoder'
+  require_relative 'rencoder/decoder'
+  require_relative 'rencoder/coder'
+
+  def load(buffer, options = {})
+    Rencoder::Coder.new(options).decode(buffer)
+  end
+
+  def dump(object, options = {})
+    Rencoder::Coder.new(options).encode(object)
+  end
+
+  module_function :dump, :load
+end

data/rencoder.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rencoder/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'rencoder'
+  spec.version       = Rencoder::VERSION
+  spec.authors       = ['Igor Yamolov']
+  spec.email         = ['clouster@yandex.ru']
+  spec.summary       = %q{Rencoder is pure Ruby implementation of Rencoder serialization format encoding/decoding.}
+  spec.description   = %q{Rencoder is implementation of Rencoder encoding/decoding.}
+  spec.homepage      = 'https://github.com/t3hk0d3/rencoder'
+  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.7'
+  spec.add_development_dependency 'rspec', '~> 3.1.0'
+end

data/spec/rencoder/decoder_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe Rencoder::Decoder do
+  include_context 'serialization_values'
+
+  subject { Rencoder::Coder.new }
+
+  describe '#decode' do
+    describe 'string' do
+      it 'decode string' do
+        expect(subject.decode(serialized_string)).to eq('Test')
+      end
+
+      it 'decode long string' do
+        expect(subject.decode(serialized_long_string)).to eq('a' * 100)
+      end
+    end
+
+    describe 'integer' do
+      it 'decode positive small integer' do
+        expect(subject.decode(serialized_positive_integer)).to eq(10)
+      end
+
+      it 'decode negative small integer' do
+        expect(subject.decode(serialized_negative_integer)).to eq(-10)
+      end
+
+      it 'decode 8-bit integer' do
+        expect(subject.decode(serialized_8bit_integer)).to eq(100)
+      end
+
+      it 'decode 16-bit integer' do
+        expect(subject.decode(serialized_16bit_integer)).to eq(5000)
+      end
+
+      it 'decode 32-bit integer' do
+        expect(subject.decode(serialized_32bit_integer)).to eq(50000)
+      end
+
+      it 'decode 64-bit integer' do
+        expect(subject.decode(serialized_64bit_integer)).to eq(5000000000)
+      end
+
+      it 'decode big ascii integer' do
+        expect(subject.decode(serialized_big_integer)).to eq(50000000000000000000)
+      end
+    end
+
+    describe 'float' do
+      it 'decode 32-bit float' do
+        expect(subject.decode(serialized_32bit_float)).to eq(100.0)
+      end
+
+      it 'decode 64-bit float' do
+        expect(subject.decode(serialized_float)).to eq(100.0001)
+      end
+    end
+
+    describe 'boolean' do
+      it 'decode true boolean' do
+        expect(subject.decode(serialized_true)).to eq(true)
+      end
+
+      it 'decode false boolean' do
+        expect(subject.decode(serialized_false)).to eq(false)
+      end
+    end
+
+    describe 'nil' do
+      it 'decode nil' do
+        expect(subject.decode(serialized_nil)).to eq(nil)
+      end
+    end
+
+    describe 'array' do
+      it 'decode small array' do
+        expect(subject.decode(serialized_array)).to eq(['Test', 100, 100.0001, nil])
+      end
+
+      it 'decode big array' do
+        expect(subject.decode(serialized_big_array)).to eq(100.times.to_a)
+      end
+    end
+
+    describe 'hash' do
+      it 'decode small hash' do
+        expect(subject.decode(serialized_hash)).to eq({ 'test' => 123, 'hello' => 'world' })
+      end
+
+      it 'decode big hash' do
+        expect(subject.decode(serialized_big_hash)).to eq(Hash[100.times.map { |i| [i, i.chr] }])
+      end
+    end
+  end
+end

data/spec/rencoder/encoder_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+describe Rencoder::Encoder do
+  include_context 'serialization_values'
+
+  subject { Rencoder::Coder.new }
+
+  describe '#encode' do
+    it 'encode string' do
+      expect(subject.encode('Test')).to eq(serialized_string)
+    end
+
+    it 'encode symbol' do
+      expect(subject.encode(:test)).to eq(serialized_symbol)
+    end
+
+    it 'encode integer' do
+      expect(subject.encode(100)).to eq(serialized_integer)
+    end
+
+    it 'encode float' do
+      expect(subject.encode(100.0001)).to eq(serialized_float)
+    end
+
+    it 'encode boolean' do
+      expect(subject.encode(false)).to eq(serialized_false)
+    end
+
+    it 'encode nil' do
+      expect(subject.encode(nil)).to eq(serialized_nil)
+    end
+
+    it 'encode array' do
+      expect(subject.encode(["Test", 100, 100.0001, nil])).to eq(serialized_array)
+    end
+
+    it 'encode hash' do
+      expect(subject.encode({ test: 123, hello: 'world' })).to eq(serialized_hash)
+    end
+
+    it 'raise exception for non-serializable object' do
+      expect { subject.encode(Object.new) }.to raise_error(Rencoder::Encoder::EncodingError)
+    end
+  end
+
+  describe '#encode_string' do
+    it 'encode small strings' do
+      expect(subject.encode_string('Test')).to eq(serialized_string)
+    end
+
+    it 'encode big strings' do
+      expect(subject.encode_string('a' * 100)).to eq(serialized_long_string)
+    end
+  end
+
+  describe '#encode_integer' do
+    it 'encode small positive number' do
+      expect(subject.encode_integer(10)).to eq(serialized_positive_integer)
+    end
+
+    it 'encode small negative number' do
+      expect(subject.encode_integer(-10)).to eq(serialized_negative_integer)
+    end
+
+    it 'encode 8-bit integer' do
+      expect(subject.encode_integer(100)).to eq(serialized_8bit_integer)
+    end
+
+    it 'encode 16-bit integer' do
+      expect(subject.encode_integer(5000)).to eq(serialized_16bit_integer)
+    end
+
+    it 'encode 32-bit integer' do
+      expect(subject.encode_integer(50000)).to eq(serialized_32bit_integer)
+    end
+
+    it 'encode 64-bit integer' do
+      expect(subject.encode_integer(5000000000)).to eq(serialized_64bit_integer)
+    end
+
+    it 'encode big integer as ascii' do
+      expect(subject.encode_integer(50000000000000000000)).to eq(serialized_big_integer)
+    end
+
+    it 'raise error for super-big integers' do
+      expect do
+        subject.encode_integer(128.times.map { '9' }.join.to_i)
+      end.to raise_error(Rencoder::Encoder::EncodingError)
+    end
+  end
+
+  describe '#encode_float' do
+    it 'encode 64-bit float' do
+      expect(subject.encode_float(100.0001)).to eq(serialized_float)
+    end
+  end
+
+  describe '#encode_boolean' do
+    it 'encode true boolean' do
+      expect(subject.encode_boolean(true)).to eq(serialized_true)
+    end
+
+    it 'encode false boolean' do
+      expect(subject.encode_boolean(false)).to eq(serialized_false)
+    end
+  end
+
+  describe '#encode_nil' do
+    it 'encode nil' do
+      expect(subject.encode_nil(nil)).to eq(serialized_nil)
+    end
+  end
+
+  describe '#encode_array' do
+    it 'encode small-sized array' do
+      expect(subject.encode_array(["Test", 100, 100.0001, nil])).to eq(serialized_array)
+    end
+
+    it 'encode big-sized array' do
+      expect(subject.encode_array(100.times.to_a)).to eq(serialized_big_array)
+    end
+  end
+
+  describe '#encode_hash' do
+    it 'encode small-sized hash' do
+      expect(subject.encode_hash({ test: 123, hello: 'world' })).to eq(serialized_hash)
+    end
+
+    it 'encode big-sized hash' do
+      hash = Hash[100.times.map { |i| [i, i.chr] }]
+
+      expect(subject.encode_hash(hash)).to eq(serialized_big_hash)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,80 @@
+$:.unshift(File.expand_path('../../lib', __FILE__))
+
+require 'rspec'
+require 'rencoder'
+
+require 'base64'
+
+shared_context 'serialization_values' do
+
+  # Values encoded using original Python code
+
+  # Integers
+  # 100
+  let(:serialized_integer) { '>d' }
+
+  # 10
+  let(:serialized_positive_integer) { "\n" }
+
+  # -10
+  let(:serialized_negative_integer) { 'O' }
+
+  # 100
+  let(:serialized_8bit_integer) { serialized_integer }
+
+  # 5000
+  let(:serialized_16bit_integer) { Base64.decode64('PxOI') }
+
+  # 50000
+  let(:serialized_32bit_integer) { Base64.decode64('QAAAw1A=') }
+
+  # 5000000000
+  let(:serialized_64bit_integer) { Base64.decode64('QQAAAAEqBfIA') }
+
+  # 50000000000000000000
+  let(:serialized_big_integer) { "=50000000000000000000\x7f" }
+
+  # Strings
+  # 'Test'
+  let(:serialized_string) { Base64.decode64('hFRlc3Q=') }
+
+  # :test (symbol)
+  let(:serialized_symbol) { Base64.decode64('hHRlc3Q=') }
+
+  # 'a' * 100
+  let(:serialized_long_string) { '100:' + 'a' * 100 }
+
+  # Booleans
+  # true
+  let(:serialized_true) { 67.chr }
+
+  let(:serialized_false) { 68.chr }
+
+  # Floats
+  # 100.0001
+  let(:serialized_float) { Base64.decode64('LEBZAAGjbi6y') }
+
+  # 100.0001 (single-precision)
+  let(:serialized_32bit_float) { Base64.decode64('QkLIAAA=') }
+
+  # NULL
+  let(:serialized_nil) { 69.chr }
+
+  # Array
+  # ["Test", 100, 100.0001, nil]
+  let(:serialized_array) { Base64.decode64('xIRUZXN0PmQsQFkAAaNuLrJF') }
+
+  # big array (100.times.to_a)
+  let(:serialized_big_array) do
+    Base64.decode64('OwABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoKSorPiw+LT4uPi8+MD4xPjI+Mz40PjU+Nj43Pjg+OT46Pjs+PD49Pj4+Pz5APkE+Qj5DPkQ+RT5GPkc+SD5JPko+Sz5MPk0+Tj5PPlA+UT5SPlM+VD5VPlY+Vz5YPlk+Wj5bPlw+XT5ePl8+YD5hPmI+Y38=')
+  end
+
+  # Hash
+  # { test: 123, hello: "world" }
+  let(:serialized_hash) { Base64.decode64('aIR0ZXN0PnuFaGVsbG+Fd29ybGQ=') }
+
+  # big hash (Hash[100.times.map { |i| [i, i.chr] }])
+  let(:serialized_big_hash) do
+    Base64.decode64('PACBAAGBAQKBAgOBAwSBBAWBBQaBBgeBBwiBCAmBCQqBCguBCwyBDA2BDQ6BDg+BDxCBEBGBERKBEhOBExSBFBWBFRaBFheBFxiBGBmBGRqBGhuBGxyBHB2BHR6BHh+BHyCBICGBISKBIiOBIySBJCWBJSaBJieBJyiBKCmBKSqBKiuBKz4sgSw+LYEtPi6BLj4vgS8+MIEwPjGBMT4ygTI+M4EzPjSBND41gTU+NoE2PjeBNz44gTg+OYE5PjqBOj47gTs+PIE8Pj2BPT4+gT4+P4E/PkCBQD5BgUE+QoFCPkOBQz5EgUQ+RYFFPkaBRj5HgUc+SIFIPkmBST5KgUo+S4FLPkyBTD5NgU0+ToFOPk+BTz5QgVA+UYFRPlKBUj5TgVM+VIFUPlWBVT5WgVY+V4FXPliBWD5ZgVk+WoFaPluBWz5cgVw+XYFdPl6BXj5fgV8+YIFgPmGBYT5igWI+Y4Fjfw==')
+  end
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: rencoder
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Igor Yamolov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+description: Rencoder is implementation of Rencoder encoding/decoding.
+email:
+- clouster@yandex.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-version"
+- Gemfile
+- LICENSE.txt
+- README.md
+- lib/rencoder.rb
+- lib/rencoder/coder.rb
+- lib/rencoder/decoder.rb
+- lib/rencoder/encoder.rb
+- lib/rencoder/version.rb
+- rencoder.gemspec
+- spec/rencoder/decoder_spec.rb
+- spec/rencoder/encoder_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/t3hk0d3/rencoder
+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: Rencoder is pure Ruby implementation of Rencoder serialization format encoding/decoding.
+test_files:
+- spec/rencoder/decoder_spec.rb
+- spec/rencoder/encoder_spec.rb
+- spec/spec_helper.rb
+has_rdoc: