rencoder 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: a0a89dc8e168dfd539d8c8c6e2280f84d44fbf46
-  data.tar.gz: 4f32d7cd11b02e312fce9ea333fb98f247e251c4
+SHA256:
+  metadata.gz: f87f5dfd83820c67adf886b6b38ecc9ee5aa57da16e545c9f2698f7d94d8c1b2
+  data.tar.gz: 188690f46aff4d973bb593b83bdf775eb784a6608942d7af08bb3eb6ebb59432
 SHA512:
-  metadata.gz: b2325cff13c80b3b2ef4961c117f574904ee468ff1f04cceb3a47ea10edad9a0d2460065c5934fa4458ab38ed1b82d27e78dbb4f7f129e278413f167e9385146
-  data.tar.gz: 21fe2903654904c946c2e422637bfe959fbb37c2fc0114acb25ab4ab78f7cfe32685895f44f882162e3e551b6ae19ccbb5b8970bcd1444c58e57ba38ec72f252
+  metadata.gz: 51cf0155f687f6687112a9e8953df56441847f7ca43c64c17eab7ca5db5f293febe61da70c8681a579d0265eeb0ca1d567baf10aff0ef33799dd2fde626e5a37
+  data.tar.gz: 8b36e60bc122a7e8a7b17d9b0ec829f55f0c5896d17815813a1654e13217b33086ea626426846ef9d9143ca3b83f7f60002432fcdd1a60ce70cf3880fe7abd96

data/.github/workflows/gem-push.yml

@@ -0,0 +1,30 @@
+name: Publish Ruby Gem
+
+on:
+  push:
+    tags:
+      - v0.*
+  release:
+    types: [published]
+jobs:
+  build:
+    name: Build + Publish
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby 2.7
+      uses: actions/setup-ruby@v1
+      with:
+        ruby-version: 2.7.x
+
+    - name: Publish to RubyGems
+      run: |
+        mkdir -p $HOME/.gem
+        touch $HOME/.gem/credentials
+        chmod 0600 $HOME/.gem/credentials
+        printf -- "---\n:rubygems_api_key: ${GEM_HOST_API_KEY}\n" > $HOME/.gem/credentials
+        gem build *.gemspec
+        gem push *.gem
+      env:
+        GEM_HOST_API_KEY: "Bearer ${{secrets.RUBYGEMS_AUTH_TOKEN}}"

data/.github/workflows/on_push.yml

@@ -0,0 +1,33 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+# This workflow will download a prebuilt Ruby version, install dependencies and run tests with Rake
+# For more information see: https://github.com/marketplace/actions/setup-ruby-jruby-and-truffleruby
+
+name: On Push
+
+on: [push, pull_request]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      max-parallel: 4
+      matrix:
+        ruby-version: [2.4, 2.7]
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby ${{ matrix.ruby-version }}
+    # To automatically get bug fixes and new Ruby versions for ruby/setup-ruby,
+    # change this to (see https://github.com/ruby/setup-ruby#versioning):
+    # uses: ruby/setup-ruby@v1
+      uses: ruby/setup-ruby@ec106b438a1ff6ff109590de34ddc62c540232e0
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+    - name: Install dependencies
+      run: bundle install
+    - name: Run RuboCop
+      run: bundle exec rubocop
+    - name: Run RSpec
+      run: bundle exec rspec spec

data/.rubocop.yml

@@ -0,0 +1,27 @@
+# The behavior of RuboCop can be controlled via the .rubocop.yml
+# configuration file. It makes it possible to enable/disable
+# certain cops (checks) and to alter their behavior if they accept
+# any parameters. The file can be placed either in your home
+# directory or in some project directory.
+#
+# RuboCop will start looking for the configuration file in the directory
+# where the inspected file is and continue its way up to the root directory.
+#
+# See https://docs.rubocop.org/rubocop/configuration
+
+require: rubocop-rspec
+
+
+AllCops:
+  NewCops: enable
+
+Metrics/BlockLength:
+  Exclude:
+    - spec/**/*.rb
+
+
+Metrics/MethodLength:
+  Max: 30
+
+Metrics/CyclomaticComplexity:
+  Max: 10

data/.ruby-version

@@ -1 +1 @@
-2.1.4
+2.7

data/Gemfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in rencoder.gemspec

data/README.md

@@ -1,10 +1,10 @@
 # Rencoder
 
-Rencoder is pure Ruby implementation of Rencode serialization format encoding/decoding.
+Rencoder is a pure Ruby implementation of Rencode 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.
+Rencoder is a *FULLY* compliant with Python implementation, and uses all optimizations (by-type-offset integers, strings, arrays, hashes) both for encoding and decoding.
 
-Rencoder has no runtime dependencies. Everything done in a pure Ruby.
+Rencoder have no runtime dependencies. Everything done in a pure Ruby.
 
 More about Rencode format:
 - <https://github.com/aresch/rencode>
@@ -30,15 +30,15 @@ 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``:
+Rencoder uses a 64-bit precision by default.
+It's recommended to stay this way.
+If there is a strong reason to use 32-bit precision, then please specify
+``float32: true`` option in a ``Rencoder.dump`` call:
 
 ```ruby
 Rencoder.dump(1.000001, float32: true)
 ```
-***Using 32-bit precision is highly NOT recommended***
+***Using 32-bit precision is NOT recommended***
 
 ### Deserialization
 
@@ -52,7 +52,7 @@ Rencoder.load(string_data)
 # => "Hello World"
 ```
 
-**Rencoder can read data from any IO object directly without using any buffers**
+**Rencoder can read data from any IO object directly, without using any buffers**
 ```ruby
 socket = TCPSocket.new('example.com', 8814)
 Rendcoder.load(socket)
@@ -61,7 +61,7 @@ Rendcoder.load(socket)
 
 ### ActiveRecord
 
-Rencoder is compliant with ActiveSupport ``serialize`` interface:
+Rencoder is compliant with the ActiveSupport's ``serialize`` interface:
 
 ```ruby
 class MyModel < ActiveRecord::Base

data/lib/rencoder.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 require 'rencoder/version'
 
+# Rencode format encoder/decoder
 module Rencoder
   # Rencoder Constants
   MAX_INT_LENGTH = 64
@@ -22,30 +25,30 @@ module Rencoder
   # 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)
+  DICT_FIXED = (DICT_FIXED_START...DICT_FIXED_START + DICT_FIXED_COUNT).freeze
 
   # 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)
+  INT_POS_FIXED = (INT_POS_FIXED_START...INT_POS_FIXED_START + INT_POS_FIXED_COUNT).freeze
 
   # 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)
+  INT_NEG_FIXED = (INT_NEG_FIXED_START...INT_NEG_FIXED_START + INT_NEG_FIXED_COUNT).freeze
 
   # String length header
-  STR_HEADER = ('0'.ord..'9'.ord)
+  STR_HEADER = ('0'.ord..'9'.ord).freeze
 
   # 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)
+  STR_FIXED = (STR_FIXED_START...STR_FIXED_START + STR_FIXED_COUNT).freeze
 
   # Lists with length embedded in typecode.
-  LIST_FIXED_START = STR_FIXED_START+STR_FIXED_COUNT
+  LIST_FIXED_START = STR_FIXED_START + STR_FIXED_COUNT
   LIST_FIXED_COUNT = 64
-  LIST_FIXED = (LIST_FIXED_START..LIST_FIXED_START + LIST_FIXED_COUNT)
+  LIST_FIXED = (LIST_FIXED_START...LIST_FIXED_START + LIST_FIXED_COUNT).freeze
 
   require_relative 'rencoder/encoder'
   require_relative 'rencoder/decoder'

data/lib/rencoder/coder.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 module Rencoder
+  # Rencode format encoder/decoder class
   class Coder
     attr_reader :options
 

data/lib/rencoder/decoder.rb

@@ -1,11 +1,14 @@
+# frozen_string_literal: true
+
 module Rencoder
+  # Rencode format decoder module
   module Decoder
     INTEGER_DECODING_MAP = {
       CHR_INT1 => [1, 'c'],
       CHR_INT2 => [2, 's>'],
       CHR_INT4 => [4, 'l>'],
       CHR_INT8 => [8, 'q>']
-    }
+    }.freeze
 
     def decode(buffer)
       buffer = StringIO.new(buffer) unless buffer.respond_to?(:read) # IO object
@@ -43,11 +46,11 @@ module Rencoder
       when CHR_INT1, CHR_INT2, CHR_INT4, CHR_INT8
         size, template = INTEGER_DECODING_MAP[type]
 
-        buffer.read(size).unpack(template).first
+        buffer.read(size).unpack1(template)
       when INT_POS_FIXED
         type - INT_POS_FIXED_START
       when INT_NEG_FIXED
-        -1-(type - INT_NEG_FIXED_START)
+        -1 - (type - INT_NEG_FIXED_START)
       end
     end
 
@@ -71,7 +74,7 @@ module Rencoder
       end
     end
 
-    def decode_boolean(buffer, type)
+    def decode_boolean(_buffer, type)
       type == CHR_TRUE
     end
 
@@ -88,7 +91,7 @@ module Rencoder
       when LIST_FIXED
         size = type - LIST_FIXED_START
 
-        size.times.map do |i|
+        size.times.map do |_i|
           decode(buffer)
         end
       end
@@ -111,7 +114,7 @@ module Rencoder
       end
     end
 
-    def decode_nil(buffer, type)
+    def decode_nil(_buffer, _type)
       nil
     end
 

data/lib/rencoder/encoder.rb

@@ -1,11 +1,14 @@
+# frozen_string_literal: true
+
 module Rencoder
+  # Rencode format encoder module
   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 Integer then encode_integer(object)
       when Float then encode_float(object)
       when TrueClass, FalseClass then encode_boolean(object)
       when NilClass then encode_nil(object)
@@ -16,26 +19,24 @@ module Rencoder
       end
     end
 
-    def encode_integer(object)
+    def encode_integer(object) # rubocop:disable Metrics/AbcSize
       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')
+        [INT_NEG_FIXED_START - 1 - object].pack('C')
       when (-128...128)
         [CHR_INT1, object].pack('Cc') # 8-bit signed
-      when (-32768...32768)
+      when (-32_768...32_768)
         [CHR_INT2, object].pack('Cs>') # 16-bit signed
-      when (-2147483648...2147483648)
+      when (-2_147_483_648...2_147_483_648)
         [CHR_INT4, object].pack('Cl>') # 32-bit signed
-      when (-9223372036854775808...9223372036854775808)
+      when (-9_223_372_036_854_775_808...9_223_372_036_854_775_808)
         [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
+        raise EncodingError, "Unable to serialize Integer #{object} due to overflow" if bytes.size >= MAX_INT_LENGTH
 
         [CHR_INT, *bytes, CHR_TERM].pack('C*')
       end
@@ -61,7 +62,7 @@ module Rencoder
       if bytes.size < STR_FIXED_COUNT
         (STR_FIXED_START + bytes.size).chr + bytes
       else
-        "#{bytes.bytesize.to_s}:#{bytes}"
+        "#{bytes.bytesize}:#{bytes}"
       end
     end
 
@@ -89,7 +90,7 @@ module Rencoder
       end
     end
 
-    def encode_nil(object)
+    def encode_nil(_object)
       [CHR_NONE].pack('C')
     end
   end

data/lib/rencoder/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rencoder
-  VERSION = '0.1.1'
+  VERSION = '0.2.0'
 end

data/rencoder.gemspec

@@ -1,5 +1,6 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'rencoder/version'
 
@@ -8,16 +9,18 @@ Gem::Specification.new do |spec|
   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.summary       = 'Rencoder is pure Ruby implementation of Rencoder serialization format encoding/decoding.'
+  spec.description   = 'Rencoder is implementation of Rencoder encoding/decoding.'
   spec.homepage      = 'https://github.com/t3hk0d3/rencoder'
   spec.license       = 'MIT'
+  spec.required_ruby_version = '>= 2.2' # rubocop:disable Gemspec/RequiredRubyVersion
 
   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.require_paths = ['lib']
 
-  spec.add_development_dependency 'bundler', '~> 1.7'
   spec.add_development_dependency 'rspec', '~> 3.1.0'
+  spec.add_development_dependency 'rubocop', '~> 0.90'
+  spec.add_development_dependency 'rubocop-rspec', '~> 1.43'
 end

data/spec/rencoder/decoder_spec.rb

@@ -1,100 +1,118 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Rencoder::Decoder do
-  include_context 'serialization_values'
+  subject(:decoder) { Rencoder::Coder.new }
 
-  subject { Rencoder::Coder.new }
+  include_context 'with serialization_values'
 
   describe '#decode' do
     it 'raises EOFError on EOF' do
-      expect {
-        subject.decode(StringIO.new)
-      }.to raise_error(EOFError)
+      expect do
+        decoder.decode(StringIO.new)
+      end.to raise_error(EOFError)
     end
 
     describe 'string' do
       it 'decode string' do
-        expect(subject.decode(serialized_string)).to eq('Test')
+        expect(decoder.decode(serialized_string)).to eq('Test')
+      end
+
+      it 'decode empty string' do
+        expect(decoder.decode(serialized_empty_string)).to eq('')
+      end
+
+      it 'decode maximum embedded-length type string' do
+        expect(decoder.decode(serialized_63byte_string)).to eq('a' * 63)
       end
 
       it 'decode long string' do
-        expect(subject.decode(serialized_long_string)).to eq('a' * 100)
+        expect(decoder.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)
+        expect(decoder.decode(serialized_positive_integer)).to eq(10)
       end
 
       it 'decode negative small integer' do
-        expect(subject.decode(serialized_negative_integer)).to eq(-10)
+        expect(decoder.decode(serialized_negative_integer)).to eq(-10)
       end
 
       it 'decode 8-bit integer' do
-        expect(subject.decode(serialized_8bit_integer)).to eq(100)
+        expect(decoder.decode(serialized_8bit_integer)).to eq(100)
       end
 
       it 'decode 16-bit integer' do
-        expect(subject.decode(serialized_16bit_integer)).to eq(5000)
+        expect(decoder.decode(serialized_16bit_integer)).to eq(5000)
       end
 
       it 'decode 32-bit integer' do
-        expect(subject.decode(serialized_32bit_integer)).to eq(50000)
+        expect(decoder.decode(serialized_32bit_integer)).to eq(50_000)
       end
 
       it 'decode 64-bit integer' do
-        expect(subject.decode(serialized_64bit_integer)).to eq(5000000000)
+        expect(decoder.decode(serialized_64bit_integer)).to eq(5_000_000_000)
       end
 
       it 'decode big ascii integer' do
-        expect(subject.decode(serialized_big_integer)).to eq(50000000000000000000)
+        expect(decoder.decode(serialized_big_integer)).to eq(50_000_000_000_000_000_000)
       end
     end
 
     describe 'float' do
       it 'decode 32-bit float' do
-        expect(subject.decode(serialized_32bit_float)).to eq(100.0)
+        expect(decoder.decode(serialized_32bit_float)).to eq(100.0)
       end
 
       it 'decode 64-bit float' do
-        expect(subject.decode(serialized_float)).to eq(100.0001)
+        expect(decoder.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)
+        expect(decoder.decode(serialized_true)).to eq(true)
       end
 
       it 'decode false boolean' do
-        expect(subject.decode(serialized_false)).to eq(false)
+        expect(decoder.decode(serialized_false)).to eq(false)
       end
     end
 
     describe 'nil' do
       it 'decode nil' do
-        expect(subject.decode(serialized_nil)).to eq(nil)
+        expect(decoder.decode(serialized_nil)).to eq(nil)
       end
     end
 
     describe 'array' do
+      it 'decode empty array' do
+        expect(decoder.decode(serialized_empty_array)).to eq([])
+      end
+
       it 'decode small array' do
-        expect(subject.decode(serialized_array)).to eq(['Test', 100, 100.0001, nil])
+        expect(decoder.decode(serialized_array)).to eq(['Test', 100, 100.0001, nil])
+      end
+
+      it 'decode maximum embedded length type array' do
+        expect(decoder.decode(serialized_63_element_array)).to eq(63.times.to_a)
       end
 
       it 'decode big array' do
-        expect(subject.decode(serialized_big_array)).to eq(100.times.to_a)
+        expect(decoder.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' })
+        expect(decoder.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] }])
+        expect(decoder.decode(serialized_big_hash)).to eq(Hash[100.times.map { |i| [i, i.chr] }])
       end
     end
   end

data/spec/rencoder/encoder_spec.rb

@@ -1,135 +1,137 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Rencoder::Encoder do
-  include_context 'serialization_values'
+  subject(:encoder) { Rencoder::Coder.new }
 
-  subject { Rencoder::Coder.new }
+  include_context 'with serialization_values'
 
   describe '#encode' do
     it 'encode string' do
-      expect(subject.encode('Test')).to eq(serialized_string)
+      expect(encoder.encode('Test')).to eq(serialized_string)
     end
 
     it 'encode symbol' do
-      expect(subject.encode(:test)).to eq(serialized_symbol)
+      expect(encoder.encode(:test)).to eq(serialized_symbol)
     end
 
     it 'encode integer' do
-      expect(subject.encode(100)).to eq(serialized_integer)
+      expect(encoder.encode(100)).to eq(serialized_integer)
     end
 
     it 'encode float' do
-      expect(subject.encode(100.0001)).to eq(serialized_float)
+      expect(encoder.encode(100.0001)).to eq(serialized_float)
     end
 
     it 'encode boolean' do
-      expect(subject.encode(false)).to eq(serialized_false)
+      expect(encoder.encode(false)).to eq(serialized_false)
     end
 
     it 'encode nil' do
-      expect(subject.encode(nil)).to eq(serialized_nil)
+      expect(encoder.encode(nil)).to eq(serialized_nil)
     end
 
     it 'encode array' do
-      expect(subject.encode(["Test", 100, 100.0001, nil])).to eq(serialized_array)
+      expect(encoder.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)
+      expect(encoder.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)
+      expect { encoder.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)
+      expect(encoder.encode_string('Test')).to eq(serialized_string)
     end
 
     it 'encode big strings' do
-      expect(subject.encode_string('a' * 100)).to eq(serialized_long_string)
+      expect(encoder.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)
+      expect(encoder.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)
+      expect(encoder.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)
+      expect(encoder.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)
+      expect(encoder.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)
+      expect(encoder.encode_integer(50_000)).to eq(serialized_32bit_integer)
     end
 
     it 'encode 64-bit integer' do
-      expect(subject.encode_integer(5000000000)).to eq(serialized_64bit_integer)
+      expect(encoder.encode_integer(5_000_000_000)).to eq(serialized_64bit_integer)
     end
 
     it 'encode big integer as ascii' do
-      expect(subject.encode_integer(50000000000000000000)).to eq(serialized_big_integer)
+      expect(encoder.encode_integer(50_000_000_000_000_000_000)).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)
+        encoder.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)
+      expect(encoder.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)
+      expect(encoder.encode_boolean(true)).to eq(serialized_true)
     end
 
     it 'encode false boolean' do
-      expect(subject.encode_boolean(false)).to eq(serialized_false)
+      expect(encoder.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)
+      expect(encoder.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)
+      expect(encoder.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)
+      expect(encoder.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)
+      expect(encoder.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)
+      expect(encoder.encode_hash(hash)).to eq(serialized_big_hash)
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,12 +1,13 @@
-$:.unshift(File.expand_path('../../lib', __FILE__))
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
 
 require 'rspec'
 require 'rencoder'
 
 require 'base64'
 
-shared_context 'serialization_values' do
-
+shared_context 'with serialization_values' do # rubocop:disable RSpec/MultipleMemoizedHelpers
   # Values encoded using original Python code
 
   # Integers
@@ -41,8 +42,14 @@ shared_context 'serialization_values' do
   # :test (symbol)
   let(:serialized_symbol) { Base64.decode64('hHRlc3Q=') }
 
+  # ''
+  let(:serialized_empty_string) { Base64.decode64("gA==\n") }
+
+  # maximum embedded-length string type ('a' * 63)
+  let(:serialized_63byte_string) { "\xBF#{'a' * 63}" }
+
   # 'a' * 100
-  let(:serialized_long_string) { '100:' + 'a' * 100 }
+  let(:serialized_long_string) { "100:#{'a' * 100}" }
 
   # Booleans
   # true
@@ -61,12 +68,20 @@ shared_context 'serialization_values' do
   let(:serialized_nil) { 69.chr }
 
   # Array
+  # []
+  let(:serialized_empty_array) { "\xC0" }
+
   # ["Test", 100, 100.0001, nil]
   let(:serialized_array) { Base64.decode64('xIRUZXN0PmQsQFkAAaNuLrJF') }
 
+  # maximum embedded-length array type (63.times.to_a)
+  let(:serialized_63_element_array) do
+    Base64.decode64("/z4APgE+Aj4DPgQ+BT4GPgc+CD4JPgo+Cz4MPg0+Dj4PPhA+ET4SPhM+FD4V\nPhY+Fz4YPhk+Gj4bPhw+HT4ePh8+ID4hPiI+Iz4kPiU+Jj4nPig+KT4qPis+\nLD4tPi4+Lz4wPjE+Mj4zPjQ+NT42Pjc+OD45Pjo+Oz48Pj0+Pg==\n") # rubocop:disable Layout/LineLength
+  end
+
   # 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=')
+    Base64.decode64('OwABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoKSorPiw+LT4uPi8+MD4xPjI+Mz40PjU+Nj43Pjg+OT46Pjs+PD49Pj4+Pz5APkE+Qj5DPkQ+RT5GPkc+SD5JPko+Sz5MPk0+Tj5PPlA+UT5SPlM+VD5VPlY+Vz5YPlk+Wj5bPlw+XT5ePl8+YD5hPmI+Y38=') # rubocop:disable Layout/LineLength
   end
 
   # Hash
@@ -75,6 +90,6 @@ shared_context 'serialization_values' do
 
   # 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==')
+    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==') # rubocop:disable Layout/LineLength
   end
 end

metadata

@@ -1,43 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: rencoder
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Igor Yamolov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-13 00:00:00.000000000 Z
+date: 2020-09-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: 3.1.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: 3.1.0
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.1.0
+        version: '0.90'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.1.0
+        version: '0.90'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.43'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.43'
 description: Rencoder is implementation of Rencoder encoding/decoding.
 email:
 - clouster@yandex.ru
@@ -45,7 +59,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/gem-push.yml"
+- ".github/workflows/on_push.yml"
 - ".gitignore"
+- ".rubocop.yml"
 - ".ruby-version"
 - Gemfile
 - LICENSE.txt
@@ -71,15 +88,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Rencoder is pure Ruby implementation of Rencoder serialization format encoding/decoding.
@@ -87,4 +103,3 @@ test_files:
 - spec/rencoder/decoder_spec.rb
 - spec/rencoder/encoder_spec.rb
 - spec/spec_helper.rb
-has_rdoc: