rencode-ruby 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8e4c4b66f1318baa3a826c3b91341e007b045d9d
+  data.tar.gz: 41eeecc0d02e829840468a7804c9295a8fa59454
+SHA512:
+  metadata.gz: 991793a070c073d1264d86022262743b6ed3e791fb7e4760f32d5f9052a3696aabf8d4c92c62188ff7a3a75c4cbe79cae74c1aa0fc1f14b21fb4f67c251ef25c
+  data.tar.gz: baa80ff4cf7dd37f5a5bd70189968fa5fae6dfcf85cea391e34eb3541b7e76e2b32c1c02999505060553077778eb0a3a784776dda5cbc7932ca0347d4cfd01e8

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gem 'turn'
+gem 'shoulda'
+gem 'rake'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,39 @@
+PATH
+  remote: .
+  specs:
+    rencode (1.0.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (4.0.5)
+      i18n (~> 0.6, >= 0.6.9)
+      minitest (~> 4.2)
+      multi_json (~> 1.3)
+      thread_safe (~> 0.1)
+      tzinfo (~> 0.3.37)
+    ansi (1.4.3)
+    i18n (0.6.9)
+    minitest (4.7.5)
+    multi_json (1.10.0)
+    rake (10.3.1)
+    shoulda (3.5.0)
+      shoulda-context (~> 1.0, >= 1.0.1)
+      shoulda-matchers (>= 1.4.1, < 3.0)
+    shoulda-context (1.2.1)
+    shoulda-matchers (2.6.1)
+      activesupport (>= 3.0.0)
+    thread_safe (0.3.3)
+    turn (0.9.7)
+      ansi
+      minitest (~> 4)
+    tzinfo (0.3.39)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rake
+  rencode!
+  shoulda
+  turn

data/LICENSE.txt

@@ -0,0 +1,21 @@
+"Copyright (C) 2014 Mikael Wikman
+
+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,22 @@
+# REncode -- Web safe object serialization
+
+REncode was based on the BitTorrent BEncode module by Petru Paler, et al.
+Licensed by Bram Cohen, 2001-2002, modified by Connelly Barnes 2006-2007.
+
+This module for Ruby was written by Mikael Wikman, 2014, and aims to be 
+complient with the Connelly Barnes version 1.0.2
+
+## Usage
+
+This implementation creates byte arrays, and expects byte arrays as argument. If you have a string, you could simply use str.bytes, or if you want to convert to string do arr.pack("C\*")
+
+```ruby
+require 'rencode'
+
+REncode.dump({ 'awesome' => 'It works!' })
+# => [CHR_DICT, '7'.ord, ':'.ord, 'awesome'.bytes, '9'.ord, ':'.ord, 'It works!'.bytes, CHR_TERM].flatten
+
+REncode.parse([CHR_INT, '123'.bytes, CHR_TERM].flatten)
+# => 123
+
+```

data/app.gemspec

@@ -0,0 +1,15 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |gem|
+  gem.authors       = ['Mikael Wikman']
+  gem.email         = ['mikael@wikman.me']
+  gem.description   = %q{This implementation aims to be complient with the Connelly Barnes implementation of rencode, version 1.0.2}
+  gem.summary       = %q{Web safe object serialization}
+  gem.files         = `git ls-files`.split($\)
+  gem.homepage      = 'https://github.com/mikaelwikman/rencode'
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|features)/})
+  gem.name          = "rencode-ruby"
+  gem.require_paths = ["lib"]
+  gem.version       = '1.0.0'
+end

data/lib/rencode.rb

@@ -0,0 +1,105 @@
+# REncode -- Web safe object serialization
+#
+# REncode was based on the BitTorrent BEncode module by Petru Paler, et al.
+# Licensed by Bram Cohen, 2001-2002, modified by Connelly Barnes 2006-2007.
+#
+#
+# This module for Ruby was written by Mikael Wikman, 2014, and aims to be 
+# complient with the Connelly Barnes version 1.0.2
+#
+#  "Copyright (C) 2014 Mikael Wikman
+#
+#  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."
+# 
+
+require 'rencode/decoder'
+require 'rencode/encoder'
+
+class REncode
+
+  def self.parse data
+    REncode::Decoder.new(data).parse
+  end
+
+  def self.dump obj
+    REncode::Encoder.new.dump(obj)
+  end
+
+#  def self.test
+#    f1 = 25.5
+#    f2 = 29.3
+#    f3 = -0.6
+#    L = [
+#      [
+#        ['a',10**20],
+#        [-100000..100000],
+#        'b'*31,
+#        'b'*62,
+#        'b'*64,
+#        2**30,
+#        2**33,
+#        2**62,
+#        2**64,
+#        2**30,
+#        2**33,
+#        2**62,
+#        2**64,
+#        false,
+#        false,
+#        true,
+#        -1,
+#        2,
+#        0
+#      ],
+#    ]
+#    test1 = {
+#      'a':15, 
+#      'bb':25.5, 
+#      'ccc':29.3, 
+#      '':[ -0.6, [], false, true,'']
+#    },
+#    raise "Mismatch!" unless parse(dump(test1)) == test1
+#    assert loads(dumps(L)) == L
+#    d = dict(zip(range(-100000,100000),range(-100000,100000)))
+#    d.update({'a':20, 20:40, 40:41, f1:f2, f2:f3, f3:False, False:True, True:False})
+#    L = (d, {}, {5:6}, {7:7,True:8}, {9:10, 22:39, 49:50, 44: ''})
+#    assert loads(dumps(L)) == L
+#    L = ('', 'a'*10, 'a'*100, 'a'*1000, 'a'*10000, 'a'*100000, 'a'*1000000, 'a'*10000000)
+#    assert loads(dumps(L)) == L
+#    L = tuple([dict(zip(range(n),range(n))) for n in range(100)]) + ('b',)
+#    assert loads(dumps(L)) == L
+#    L = tuple([dict(zip(range(n),range(-n,0))) for n in range(100)]) + ('b',)
+#    assert loads(dumps(L)) == L
+#    L = tuple([tuple(range(n)) for n in range(100)]) + ('b',)
+#    assert loads(dumps(L)) == L
+#    L = tuple(['a'*n for n in range(1000)]) + ('b',)
+#    assert loads(dumps(L)) == L
+#    L = tuple(['a'*n for n in range(1000)]) + (None,True,None)
+#    assert loads(dumps(L)) == L
+#    assert loads(dumps(None)) == None
+#    assert loads(dumps({None:None})) == {None:None}
+#    assert 1e-10<abs(loads(dumps(1.1))-1.1)<1e-6
+#    assert 1e-10<abs(loads(dumps(1.1,32))-1.1)<1e-6
+#    assert abs(loads(dumps(1.1,64))-1.1)<1e-12
+#    assert loads(dumps(u"Hello World!!"))
+#  end
+
+end

data/lib/rencode/constants.rb

@@ -0,0 +1,47 @@
+module REncodeConstants
+  # Default number of bits for serialized floats, either 32 or 64 (also a parameter for dumps()).
+  DEFAULT_FLOAT_BITS = 32
+
+  # Maximum length of integer when written as base 10 string.
+  # Ruby has no max integer length
+  MAX_INT_LENGTH = 64
+
+  # The bencode 'typecodes' such as i, d, etc have been extended and
+  # relocated on the base-256 character set.
+  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
+
+  # Positive integers with value embedded in typecode.
+  INT_POS_FIXED_START = 0
+  INT_POS_FIXED_COUNT = 44
+
+  # Negative integers with value embedded in typecode.
+  INT_NEG_FIXED_START = 70
+  INT_NEG_FIXED_COUNT = 32
+
+  # Strings with length embedded in typecode.
+  STR_FIXED_START = 128
+  STR_FIXED_COUNT = 64
+
+  # Lists with length embedded in typecode.
+  LIST_FIXED_START = STR_FIXED_START+STR_FIXED_COUNT
+  LIST_FIXED_COUNT = 64
+
+  VERSION = '1.0.2'
+  ALL = ['dumps', 'loads']
+end

data/lib/rencode/decoder.rb

@@ -0,0 +1,162 @@
+require 'rencode/constants'
+
+## a little monkey-patching to add enumerator next-N, where N is a number
+class Enumerator
+  def nextn num
+    [].tap {|a| num.times {|i| a << send('next') } }
+  end
+end
+
+class REncode
+
+  class Decoder
+    include REncodeConstants
+
+    ## 
+    # Prepare the mapping table
+    #
+    
+    
+    @@mapping_table = Array.new(255)
+
+    (48..57).each do |i| # '0' to '9'
+      @@mapping_table[i] = Proc.new do
+        length_str = i.chr
+        while (chr=@data.next) != ':'.ord
+          length_str << chr.chr
+        end
+
+        if length_str[0] == '0' and length_str.length > 1
+          raise "Non-zero string length supplied with initial zero"
+        end
+
+        n = length_str.to_i
+        data = @data.nextn(n)
+        data.pack('C*')
+      end
+    end
+
+    STR_FIXED_COUNT.times do |i|
+      @@mapping_table[STR_FIXED_START+i] = Proc.new { @data.nextn(i).pack('C*') } # only ascii for now 
+    end
+
+    LIST_FIXED_COUNT.times do |i|
+      @@mapping_table[LIST_FIXED_START+i] = Proc.new { Array.new(i) { _parse } }
+    end
+
+    INT_POS_FIXED_COUNT.times do |i|
+      @@mapping_table[INT_POS_FIXED_START+i] = Proc.new { i }
+    end
+
+    INT_NEG_FIXED_COUNT.times do |i|
+      @@mapping_table[INT_NEG_FIXED_START+i] = Proc.new { -1-i }
+    end
+
+    DICT_FIXED_COUNT.times do |i|
+      @@mapping_table[DICT_FIXED_START+i] = Proc.new { {}.tap {|r| i.times {|j| r[_parse] = _parse } } }
+    end
+
+    @@mapping_table[CHR_LIST] = Proc.new do
+      r = []
+
+      while @data.peek != CHR_TERM
+        r << _parse
+      end
+
+      @data.next
+      r
+    end
+
+    @@mapping_table[CHR_DICT] = Proc.new do
+      r = {}
+
+      while @data.peek != CHR_TERM
+        r[_parse] = _parse
+      end
+
+      @data.next
+      r
+    end
+
+    @@mapping_table[CHR_INT] = Proc.new do
+      num_str = ""
+
+      while (chr=@data.next) != CHR_TERM
+        num_str << chr.chr
+      end
+
+      n = num_str.to_i
+
+      if num_str[0] == '-'
+        if num_str[1] == '0'
+          raise "a zero after minus?!"
+        end
+      elsif num_str[0] == '0' and num_str.length > 1
+        raise "A non-zero number started by zero"
+      end
+
+      n
+    end
+
+    @@mapping_table[CHR_INT1] = Proc.new do
+      #  return (struct.unpack('!b', x[f:f+1])[0], f+1)
+      @data.next # python "!b" means 8bit integer, big endian, but what does endianess matter since it's a single byte
+    end
+
+    @@mapping_table[CHR_INT2] = Proc.new do
+      # return (struct.unpack('!h', x[f:f+2])[0], f+2)
+      @data.nextn(2).pack('C*').unpack('s>')[0]
+    end
+
+    @@mapping_table[CHR_INT4] = Proc.new do
+      # return (struct.unpack('!l', x[f:f+4])[0], f+4)
+      @data.nextn(4).pack('C*').unpack('l>')[0]
+    end
+
+    @@mapping_table[CHR_INT8] = Proc.new do
+      #return (struct.unpack('!q', x[f:f+8])[0], f+8)
+      @data.nextn(8).pack('C*').unpack('q>')[0]
+    end
+
+    @@mapping_table[CHR_FLOAT32] = Proc.new do
+      #n = struct.unpack('!f', x[f:f+4])[0]
+      @data.nextn(4).pack('C*').unpack('g')[0]
+    end
+
+    @@mapping_table[CHR_FLOAT64] = Proc.new do
+      #n = struct.unpack('!d', x[f:f+8])[0]
+      @data.nextn(8).pack('C*').unpack('G')[0]
+    end
+
+    @@mapping_table[CHR_TRUE] = Proc.new { true}
+    @@mapping_table[CHR_FALSE] = Proc.new { false}
+    @@mapping_table[CHR_NONE] = Proc.new { nil}
+
+    #
+    # End mapping table
+    ##
+
+    def initialize data, decode_utf8=false
+      if data.kind_of?(Array)
+        @data = data.each
+      elsif data.kind_of?(String)
+        @data = data.each_byte
+      else
+        raise "Bad input argument for data #{data.class}"
+      end
+      @decode_utf8 = decode_utf8
+    end
+
+    def parse
+      _parse
+    end
+
+    private
+
+    def _parse
+      c = @data.next.ord
+      instance_eval &@@mapping_table[c]
+    end
+
+  end
+end

data/lib/rencode/encoder.rb

@@ -0,0 +1,57 @@
+require 'rencode/constants'
+
+class REncode
+
+  class Encoder
+    include REncodeConstants
+
+    def initialize
+      @out = []
+    end
+
+    def dump(obj)
+      @out = []
+      d(obj)
+      @out
+    end
+
+    private 
+
+    # NOTE: Performance-wise, this is a rather lousy implementation. It uses none of the 
+    # size-optimizations offered by the protocol. Also, doesn't use variable-length numbers, 
+    # so we're limited to maximum 64bit.
+
+    def d o
+      case o.class.name
+      when 'Hash'
+        @out << CHR_DICT
+        o.each { |k,v| d(k) ; d(v) }
+        @out << CHR_TERM
+      when 'Fixnum'
+        raise "implementation doesn't support such large numbers" if o > 2**31 || o < -1*2**31
+        @out << CHR_INT8
+        @out.concat [o].pack('q>').bytes
+      when 'Float'
+        @out << CHR_FLOAT64
+        @out.concat [o].pack('G').bytes
+      when 'TrueClass'
+        @out << CHR_TRUE
+      when 'FalseClass'
+        @out << CHR_FALSE
+      when 'NilClass'
+        @out << CHR_NONE
+      when 'String'
+        bytes = o.bytes
+        @out.concat bytes.length.to_s.bytes
+        @out << ':'.ord 
+        @out.concat bytes
+      when 'Array'
+        @out << CHR_LIST
+        o.each { |oo| d(oo) }
+        @out << CHR_TERM
+      else
+        raise "Cannot serialize type #{o.class}"
+      end
+    end
+  end
+end

data/test/rencode_test.rb

@@ -0,0 +1,154 @@
+require 'test_helper'
+require 'rencode'
+require 'rencode/constants'
+
+class REncodeTest < TestCase
+  include REncodeConstants
+
+  context 'rencode' do
+
+    setup do
+      @it = REncode
+    end
+
+    context 'encode' do
+      should 'handle dictionaries' do
+        source = { 'a' => 'b' }
+        expected = [CHR_DICT, '1'.ord, ':'.ord, 'a'.ord, '1'.ord, ':'.ord, 'b'.ord, CHR_TERM]
+
+        assert_equal expected, @it.dump(source)
+      end
+
+      should 'handle numbers' do
+        assert_equal [CHR_INT8, 0, 0, 0, 0, 0, 0, 0, 0], @it.dump(0)
+        assert_equal [CHR_INT8, 0, 0, 0, 0, 0, 0, 0, 1], @it.dump(1)
+        assert_equal [CHR_INT8, 255, 255, 255, 255, 255, 255, 255, 255], @it.dump(-1)
+        assert_equal [CHR_INT8, 0,0,0,0,0,0,1,0], @it.dump(256)
+        @it.dump 2**31
+      end
+
+      should 'fail on too big number' do
+        assert_raises RuntimeError do
+          @it.dump 2**32
+        end
+      end
+
+      should 'handle floats' do
+        assert_equal [CHR_FLOAT64, 63,240,0,0,0,0,0,0], @it.dump(1.0)
+      end
+
+      should 'handle boolean' do
+        assert_equal [CHR_TRUE], @it.dump(true)
+        assert_equal [CHR_FALSE], @it.dump(false)
+      end
+
+      should 'handle nil' do
+        assert_equal [CHR_NONE], @it.dump(nil)
+      end
+
+      should 'handle string' do
+        assert_equal ['2'.ord, ':'.ord, 'm'.ord, 'e'.ord], @it.dump('me')
+      end
+
+      should 'handle array' do
+        assert_equal [CHR_LIST, CHR_TRUE, CHR_TRUE, CHR_TERM], @it.dump([true,true])
+      end
+
+      should 'fail on unrecognized type' do
+        assert_raises RuntimeError do
+          @it.dump(Object.new)
+        end
+      end
+    end
+
+    context 'decode' do
+      should 'handle dictionaries' do
+        source = [CHR_DICT, '1'.ord, ':'.ord, 'a'.ord, '1'.ord, ':'.ord, 'b'.ord, CHR_TERM]
+        expected = { 'a' => 'b' }
+
+        assert_equal expected, @it.parse(source)
+      end
+
+      should 'handle fixed size dictionaries' do
+        source = [DICT_FIXED_START+1, '1'.ord, ':'.ord, 'a'.ord, '1'.ord, ':'.ord, 'b'.ord]
+        expected = { 'a' => 'b' }
+        assert_equal expected, @it.parse(source)
+
+        assert_equal({}, @it.parse([DICT_FIXED_START+0]))
+      end
+
+      should 'handle int' do
+        assert_equal 432678, @it.parse([CHR_INT, '432678'.bytes, CHR_TERM].flatten)
+      end
+
+      should 'handle int1' do
+        assert_equal 45, @it.parse([CHR_INT1, 45])
+      end
+
+      should 'handle int2' do
+        assert_equal 272, @it.parse([CHR_INT2, 1, 16])
+      end
+
+      should 'handle int4' do
+        assert_equal 272, @it.parse([CHR_INT4, 0, 0, 1, 16])
+      end
+
+      should 'handle int8' do
+        assert_equal 0, @it.parse([CHR_INT8, 0, 0, 0, 0, 0, 0, 0, 0])
+        assert_equal 1, @it.parse([CHR_INT8, 0, 0, 0, 0, 0, 0, 0, 1])
+        assert_equal -1, @it.parse([CHR_INT8, 255, 255, 255, 255, 255, 255, 255, 255])
+        assert_equal 256, @it.parse([CHR_INT8, 0,0,0,0,0,0,1,0])
+      end
+
+      should 'handle fixed address int' do
+        assert_equal 0, @it.parse([INT_POS_FIXED_START+0])
+        assert_equal 5, @it.parse([INT_POS_FIXED_START+5])
+        assert_equal INT_POS_FIXED_COUNT-1, @it.parse([INT_POS_FIXED_START+INT_POS_FIXED_COUNT-1])
+      end
+
+      should 'handle fixed address negative int' do
+        assert_equal -1, @it.parse([INT_NEG_FIXED_START+0])
+        assert_equal -7, @it.parse([INT_NEG_FIXED_START+6])
+        assert_equal -1-INT_NEG_FIXED_COUNT+1, @it.parse([INT_NEG_FIXED_START+INT_NEG_FIXED_COUNT-1])
+      end
+
+      should 'handle floats' do
+        assert_equal 1.0, @it.parse([CHR_FLOAT64, 63,240,0,0,0,0,0,0])
+        assert_equal 1.0, @it.parse([CHR_FLOAT32, 63,128,0,0])
+      end
+
+      should 'handle boolean' do
+        assert_equal true, @it.parse([CHR_TRUE])
+        assert_equal false, @it.parse([CHR_FALSE])
+      end
+
+      should 'handle nil' do
+        assert_equal nil, @it.parse([CHR_NONE])
+      end
+
+      should 'handle string' do
+        assert_equal 'me', @it.parse(['2'.ord, ':'.ord, 'm'.ord, 'e'.ord])
+      end
+
+      should 'handle fixed-size strings' do
+        assert_equal '', @it.parse([STR_FIXED_START+0])
+        assert_equal 'a', @it.parse([STR_FIXED_START+1, 'a'.ord])
+
+        str= 'a'*(STR_FIXED_COUNT-1)
+        assert_equal str, @it.parse([STR_FIXED_START+STR_FIXED_COUNT-1].concat(str.bytes))
+      end
+
+      should 'handle array' do
+        assert_equal [true, true], @it.parse([CHR_LIST, CHR_TRUE, CHR_TRUE, CHR_TERM])
+      end
+
+      should 'handle fixed-size arrays' do
+        assert_equal [], @it.parse([LIST_FIXED_START+0])
+        assert_equal [true], @it.parse([LIST_FIXED_START+1, CHR_TRUE])
+
+        arr = Array.new(LIST_FIXED_COUNT-1, true)
+        assert_equal arr, @it.parse([LIST_FIXED_START+LIST_FIXED_COUNT-1].concat(Array.new(LIST_FIXED_COUNT-1, CHR_TRUE)))
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+require 'bundler/setup'
+require 'test/unit'
+require 'turn/autorun'
+require 'shoulda'
+
+$LOAD_PATH << 'lib'
+
+class TestCase < Test::Unit::TestCase
+end
+

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: rencode-ruby
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Mikael Wikman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-10 00:00:00.000000000 Z
+dependencies: []
+description: This implementation aims to be complient with the Connelly Barnes implementation
+  of rencode, version 1.0.2
+email:
+- mikael@wikman.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- app.gemspec
+- lib/rencode.rb
+- lib/rencode/constants.rb
+- lib/rencode/decoder.rb
+- lib/rencode/encoder.rb
+- test/rencode_test.rb
+- test/test_helper.rb
+homepage: https://github.com/mikaelwikman/rencode
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Web safe object serialization
+test_files:
+- test/rencode_test.rb
+- test/test_helper.rb