rlp 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6b6741d638fbdc0a96769c278107372a0b7a8fd7
+  data.tar.gz: 583c56e5f86fb18c21022ce5c9b12e42abd24b43
+SHA512:
+  metadata.gz: 28451e98078179c7b1290822cfbc83c28326f9b8a221973e2f24bfdbf839bd5d5eb3c6289231621c0c98e7928377d2bc5efdc9384493fe941e4168083c34a578
+  data.tar.gz: 537920b429404476ef93c663aec0cb91f961e152c2645c4b4d77a2fe8ae9c8b3a7b7da775da3e2f502308450fe670bc5b5cce674d53374341e0747901e3ea3e2

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Jan Xie
+
+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,3 @@
+# ruby-rlp
+
+A Ruby implementation of Ethereum's Recursive Length Prefix encoding (RLP). You can find the specification of the standard in the [Ethereum wiki](https://github.com/ethereum/wiki/wiki/RLP).

data/lib/rlp.rb

@@ -0,0 +1,67 @@
+require 'rlp/constant'
+require 'rlp/data'
+require 'rlp/error'
+require 'rlp/utils'
+require 'rlp/sedes'
+
+module RLP
+  include Constant
+  include Error
+  include Utils
+
+  extend self
+
+  def encode(obj, sedes: nil, infer_serializer: true, cache: false)
+    # TODO: cache flow
+
+    if sedes
+      # TODO: customize sedes flow
+      #item = sedes.serialize(obj)
+    elsif infer_serializer
+      item = Sedes.infer(obj).serialize(obj)
+    else
+      item = obj
+    end
+
+    result = encode_raw(item)
+    result
+  end
+
+  def encode_raw(item)
+    return item if item.instance_of?(RLP::Data)
+    return encode_primitive(item) if primitive?(item)
+    return encode_list(item) if list?(item)
+
+    msg = "Cannot encode object of type %s" % item.class.name
+    raise ArgumentError, msg
+  end
+
+  def encode_primitive(item)
+    return str_to_bytes(item) if item.size == 1 && item.ord < 0x80
+
+    payload = str_to_bytes item
+    prefix = length_prefix payload.size, PRIMITIVE_PREFIX_OFFSET
+
+    "#{prefix}#{payload}"
+  end
+
+  def encode_list(list)
+    payload = list.map {|item| encode_raw(item) }.join
+    prefix = length_prefix payload.size, LIST_PREFIX_OFFSET
+
+    "#{prefix}#{payload}"
+  end
+
+  def length_prefix(length, offset)
+    if length < SHORT_LENGTH_LIMIT
+      (offset+length).chr
+    elsif length < LONG_LENGTH_LIMIT
+      length_string = int_to_big_endian(length)
+      length_len = (offset + SHORT_LENGTH_LIMIT - 1 + length_string.size).chr
+      "#{length_len}#{length_string}"
+    else
+      raise ArgumentError, "Length greater than 256**8"
+    end
+  end
+
+end

data/lib/rlp/constant.rb

@@ -0,0 +1,9 @@
+module RLP
+  module Constant
+    SHORT_LENGTH_LIMIT = 56
+    LONG_LENGTH_LIMIT = 256**8
+
+    PRIMITIVE_PREFIX_OFFSET = 0x80
+    LIST_PREFIX_OFFSET = 0xc0
+  end
+end

data/lib/rlp/data.rb

@@ -0,0 +1,7 @@
+##
+# A wrapper to represent already RLP encoded data
+
+module RLP
+  class Data < String
+  end
+end

data/lib/rlp/error.rb

@@ -0,0 +1,67 @@
+module RLP
+  module Error
+
+    class RLPException < Exception; end
+
+    class EncodingError < RLPException
+      def initialize(message, obj)
+        super(message)
+
+        @obj = obj
+      end
+    end
+
+    class DecodingError < RLPException
+      def initialize(message, rlp)
+        super(message)
+
+        @rlp = rlp
+      end
+    end
+
+    class SerializationError < RLPException
+      def initialize(message, obj)
+        super(message)
+
+        @obj = obj
+      end
+    end
+
+    class DeserializationError < RLPException
+      def initialize(message, serial)
+        super(message)
+
+        @serial = serial
+      end
+    end
+
+    class ListSerializationError < SerializationError
+      def initialize(message: nil, obj: nil, element_exception: nil, index: nil)
+        if message.nil?
+          raise ArgumentError, "index and element_exception must be present" if index.nil? || element_exception.nil?
+          message = 'Serialization failed because of element at index %s ("%s")' % [index, element_exception]
+        end
+
+        super(message, obj)
+
+        @index = index
+        @element_exception = element_exception
+      end
+    end
+
+    class ListDeserializationError < DeserializationError
+      def initialize(message: nil, serial: nil, element_exception: nil, index: nil)
+        if message.nil?
+          raise ArgumentError, "index and element_exception must be present" if index.nil? || element_exception.nil?
+          message = 'Deserialization failed because of element at index %s ("%s")' % [index, element_exception]
+        end
+
+        super(message, serial)
+
+        @index = index
+        @element_exception = element_exception
+      end
+    end
+
+  end
+end

data/lib/rlp/sedes.rb

@@ -0,0 +1,33 @@
+require_relative 'sedes/big_endian_int'
+require_relative 'sedes/binary'
+require_relative 'sedes/list'
+
+module RLP
+  module Sedes
+
+    class <<self
+      def infer(obj)
+        return obj if sedes?(obj)
+        return big_endian_int if obj.is_a?(Integer) && obj >= 0
+        return binary if Binary.valid_type?(obj)
+        return List.new(elements: obj.map {|item| infer(item) }) if RLP.list?(obj)
+
+        msg = "Did not find sedes handling type %s" % obj.class.name
+        raise ArgumentError, msg
+      end
+
+      def sedes?(obj)
+        obj.respond_to?(:serialize) && obj.respond_to?(:deserialize)
+      end
+
+      def big_endian_int
+        @big_endian_int ||= BigEndianInt.new
+      end
+
+      def binary
+        @binary ||= Binary.new
+      end
+    end
+
+  end
+end

data/lib/rlp/sedes/big_endian_int.rb

@@ -0,0 +1,37 @@
+module RLP
+  module Sedes
+    class BigEndianInt
+      include RLP::Utils
+
+      ZERO = "\x00".force_encoding('ascii-8bit').freeze
+      EMPTY = ''.force_encoding('ascii-8bit').freeze
+
+      def initialize(size: nil)
+        @size = size
+      end
+
+      def serialize(obj)
+        raise ArgumentError, "Can only serialize integers" unless obj.is_a?(Integer)
+        raise ArgumentError, "Cannot serialize negative integers" if obj < 0
+
+        if @size && obj >= 256**@size
+          msg = "Integer too large (does not fit in %s bytes)" % @size
+          raise ArgumentError, msg
+        end
+
+        s = obj == 0 ? ZERO : int_to_big_endian(obj)
+
+        @size ? "#{ZERO * [0, @size-s.size].max}#{s}" : s
+      end
+
+      def deserialize(serial)
+        raise ArgumentError, "Invalid serialization (wrong size)" if @size && serial.size != @size
+        raise ArgumentError, "Invalid serialization (not minimal length)" if !@size && serial.size > 0 && serial[0] == ZERO
+
+        serial = serial || ZERO
+        big_endian_to_int(serial)
+      end
+
+    end
+  end
+end

data/lib/rlp/sedes/binary.rb

@@ -0,0 +1,45 @@
+module RLP
+  module Sedes
+    class Binary
+      include RLP::Utils
+
+      Infinity = 1.0 / 0.0
+
+      class <<self
+        def valid_type?(obj)
+          obj.instance_of?(String)
+        end
+      end
+
+      def initialize(min_length: 0, max_length: Infinity, allow_empty: false)
+        @min_length = min_length
+        @max_length = max_length
+        @allow_empty = allow_empty
+      end
+
+      def serialize(obj)
+        raise SerializationError.new("Object is not a serializable (%s)" % obj.class, obj) unless self.class.valid_type?(obj)
+
+        serial = str_to_bytes obj
+        raise SerializationError.new("Object has invalid length", serial) unless valid_length?(serial.size)
+
+        serial
+      end
+
+      def deserialize(serial)
+        raise DeserializationError.new("Objects of type %s cannot be deserialized" % serial.class, serial) unless primitive?(serial)
+        raise DeserializationError.new("%s has invalid length" % serial.class, serial) unless valid_length?(serial.size)
+
+        serial
+      end
+
+      private
+
+      def valid_length?(len)
+        (@min_length <= len && len <= @max_length) ||
+          (@allow_empty && len == 0)
+      end
+
+    end
+  end
+end

data/lib/rlp/sedes/list.rb

@@ -0,0 +1,63 @@
+module RLP
+  module Sedes
+    class List < Array
+      include RLP::Error
+      include RLP::Utils
+
+      def initialize(elements: [], strict: true)
+        super()
+
+        @strict = strict
+
+        elements.each do |e|
+          if Sedes.sedes?(e)
+            push e
+          elsif list?(e)
+            push List.new(elements: e)
+          else
+            raise TypeError, "Instances of List must only contain sedes objects or nested sequences thereof."
+          end
+        end
+      end
+
+      def serialize(obj)
+        raise ListSerializationError.new(message: "Can only serialize sequences", obj: obj) unless list?(obj)
+        raise ListSerializationError.new(message: "List has wrong length", obj: obj) if (@strict && self.size != obj.size) || self.size < obj.size
+
+        result = []
+        obj.zip(self).each_with_index do |(element, sedes), i|
+          begin
+            result.push sedes.serialize(element)
+          rescue SerializationError => e
+            raise ListSerializationError.new(obj: obj, element_exception: e, index: i)
+          end
+        end
+
+        result
+      end
+
+      def deserialize(serial)
+        raise ListDeserializationError.new(message: 'Can only deserialize sequences', serial: serial) unless list?(serial)
+        raise ListDeserializationError.new(message: 'List has wrong length', serial: serial) if @strict && serial.size != self.size
+
+        result = []
+
+        len = [serial.size, self.size].min
+        len.times do |i|
+          begin
+            sedes = self[i]
+            element = serial[i]
+            result.push sedes.deserialize(element)
+          rescue DeserializationError => e
+            raise ListDeserializationError.new(serial: serial, element_exception: e, index: i)
+          end
+        end
+
+        result
+      end
+    end
+
+#TODO: CountableList
+
+  end
+end

data/lib/rlp/utils.rb

@@ -0,0 +1,35 @@
+module RLP
+  module Utils
+    def primitive?(item)
+      item.instance_of?(String)
+    end
+
+    def list?(item)
+      item.respond_to?(:each)
+    end
+
+    def bytes_to_str(v)
+      v.unpack('U*').pack('U*')
+    end
+
+    def str_to_bytes(v)
+      v.dup.force_encoding('ascii-8bit')
+    end
+
+    def big_endian_to_int(v)
+      v.unpack('H*').first.to_i(16)
+    end
+
+    def int_to_big_endian(v)
+      hex = v.to_s(16)
+      hex = "0#{hex}" if hex.size.odd?
+      [hex].pack('H*')
+    end
+
+    def encode_hex(b)
+      raise ArgumentError, "Value must be an instance of String"  unless b.instance_of?(String)
+      b = str_to_bytes(b) unless b.encoding.name == 'ASCII-8BIT'
+      b.unpack("H*").first
+    end
+  end
+end

data/lib/rlp/version.rb

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

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: rlp
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jan Xie
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-01-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.5.0
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 5.8.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 5.8.3
+description: A Ruby implementation of Ethereum's Recursive Length Prefix encoding
+  (RLP).
+email:
+- jan.h.xie@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/rlp.rb
+- lib/rlp/constant.rb
+- lib/rlp/data.rb
+- lib/rlp/error.rb
+- lib/rlp/sedes.rb
+- lib/rlp/sedes/big_endian_int.rb
+- lib/rlp/sedes/binary.rb
+- lib/rlp/sedes/list.rb
+- lib/rlp/utils.rb
+- lib/rlp/version.rb
+homepage: https://github.com/janx/ruby-rlp
+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.4.5
+signing_key: 
+specification_version: 4
+summary: The ruby RLP serialization library.
+test_files: []
+has_rdoc: