rlp 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6b6741d638fbdc0a96769c278107372a0b7a8fd7
-  data.tar.gz: 583c56e5f86fb18c21022ce5c9b12e42abd24b43
+  metadata.gz: 32e4d13b19619a0c3f381595d5942f9e915ee837
+  data.tar.gz: 3968b3f4dd481c15a878465214e1db635d42b616
 SHA512:
-  metadata.gz: 28451e98078179c7b1290822cfbc83c28326f9b8a221973e2f24bfdbf839bd5d5eb3c6289231621c0c98e7928377d2bc5efdc9384493fe941e4168083c34a578
-  data.tar.gz: 537920b429404476ef93c663aec0cb91f961e152c2645c4b4d77a2fe8ae9c8b3a7b7da775da3e2f502308450fe670bc5b5cce674d53374341e0747901e3ea3e2
+  metadata.gz: e0c09429505321937097e3dc71bbb1c4d3029ddffd9b9dfdbfaf1bdbdf9133b929b44141558ba435d720ae4f318e15615b5f41de41ebbea9963370fe2a9f9111
+  data.tar.gz: 9be9e4d4bb3d9f246f32440e1eb97f4a5d12c0de700007f21c6f0e41ab9546f54237e7aa756ee96e435de54f8892f10599a34d3059c4c74b0e9e21c762292781

data/lib/rlp.rb

@@ -4,64 +4,12 @@ require 'rlp/error'
 require 'rlp/utils'
 require 'rlp/sedes'
 
+require 'rlp/encode'
+require 'rlp/decode'
+
 module RLP
-  include Constant
-  include Error
-  include Utils
+  include Encode
+  include Decode
 
   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

@@ -5,5 +5,8 @@ module RLP
 
     PRIMITIVE_PREFIX_OFFSET = 0x80
     LIST_PREFIX_OFFSET = 0xc0
+
+    BYTE_ZERO = "\x00".force_encoding('ascii-8bit').freeze
+    BYTE_EMPTY = ''.force_encoding('ascii-8bit').freeze
   end
 end

data/lib/rlp/decode.rb

@@ -0,0 +1,119 @@
+module RLP
+  module Decode
+    include Constant
+    include Error
+    include Utils
+
+    def decode(rlp, options={})
+      sedes = options.delete(:sedes)
+      strict = options.delete(:strict) {|k| true }
+
+      rlp = str_to_bytes(rlp)
+
+      begin
+        item, next_start = consume_item(rlp, 0)
+      rescue Exception => e
+        raise DecodingError.new("Cannot decode rlp string: #{e}", rlp)
+      end
+
+      raise DecodingError.new("RLP string ends with #{rlp.size - next_start} superfluous bytes", rlp) if next_start != rlp.size && strict
+
+      if sedes
+        obj = sedes.deserialize(item) # TODO: (options)
+        #TODO: cache flow
+        obj
+      else
+        item
+      end
+    end
+
+    private
+
+    ##
+    # Read an item from an RLP string.
+    #
+    # * `rlp` - the string to read from
+    # * `start` - the position at which to start reading`
+    #
+    # Returns a pair `[item, end]` where `item` is the read item and `end` is
+    # the position of the first unprocessed byte.
+    #
+    def consume_item(rlp, start)
+      t, l, s = consume_length_prefix(rlp, start)
+      consume_payload(rlp, s, t, l)
+    end
+
+    ##
+    # Read a length prefix from an RLP string.
+    #
+    # * `rlp` - the rlp string to read from
+    # * `start` - the position at which to start reading
+    #
+    # Returns an array `[type, length, end]`, where `type` is either `:str`
+    # or `:list` depending on the type of the following payload, `length` is
+    # the length of the payload in bytes, and `end` is the position of the
+    # first payload byte in the rlp string (thus the end of length prefix).
+    #
+    def consume_length_prefix(rlp, start)
+      b0 = rlp[start].ord
+
+      if b0 < PRIMITIVE_PREFIX_OFFSET # single byte
+        [:str, 1, start]
+      elsif b0 < PRIMITIVE_PREFIX_OFFSET + SHORT_LENGTH_LIMIT # short string
+        raise DecodingError.new("Encoded as short string although single byte was possible", rlp) if (b0 - PRIMITIVE_PREFIX_OFFSET == 1) && rlp[start+1].ord < PRIMITIVE_PREFIX_OFFSET
+
+        [:str, b0 - PRIMITIVE_PREFIX_OFFSET, start + 1]
+      elsif b0 < LIST_PREFIX_OFFSET # long string
+        raise DecodingError.new("Length starts with zero bytes", rlp) if rlp.slice(start+1) == BYTE_ZERO
+
+        ll = b0 - PRIMITIVE_PREFIX_OFFSET - SHORT_LENGTH_LIMIT + 1
+        l = big_endian_to_int rlp[(start+1)...(start+1+ll)]
+
+        [:str, l, start+1+ll]
+      elsif b0 < LIST_PREFIX_OFFSET + SHORT_LENGTH_LIMIT # short list
+        [:list, b0 - LIST_PREFIX_OFFSET, start + 1]
+      else # long list
+        raise DecodingError.new('Length starts with zero bytes", rlp') if rlp.slice(start+1) == BYTE_ZERO
+
+        ll = b0 - LIST_PREFIX_OFFSET - SHORT_LENGTH_LIMIT + 1
+        l = big_endian_to_int rlp[(start+1)...(start+1+ll)]
+        raise DecodingError.new('Long list prefix used for short list', rlp) if l < 56
+
+        [:list, l, start+1+ll]
+      end
+    end
+
+    ##
+    # Read the payload of an item from an RLP string.
+    #
+    # * `rlp` - the rlp string to read from
+    # * `type` - the type of the payload (`:str` or `:list`)
+    # * `start` - the position at which to start reading
+    # * `length` - the length of the payload in bytes
+    #
+    # Returns a pair `[item, end]`, where `item` is the read item and `end` is
+    # the position of the first unprocessed byte.
+    #
+    def consume_payload(rlp, start, type, length)
+      case type
+      when :str
+        [rlp[start...(start+length)], start+length]
+      when :list
+        items = []
+        next_item_start = start
+        payload_end = next_item_start + length
+
+        while next_item_start < payload_end
+          item, next_item_start = consume_item rlp, next_item_start
+          items.push item
+        end
+
+        raise DecodingError.new('List length prefix announced a too small length', rlp) if next_item_start > payload_end
+
+        [items, next_item_start]
+      else
+        raise TypeError, 'Type must be either :str or :list'
+      end
+    end
+  end
+end

data/lib/rlp/encode.rb

@@ -0,0 +1,61 @@
+module RLP
+  module Encode
+    include Constant
+    include Error
+    include Utils
+
+    def encode(obj, sedes: nil, infer_serializer: true, cache: false)
+      # TODO: cache flow
+
+      if sedes
+        item = sedes.serialize(obj)
+      elsif infer_serializer
+        item = Sedes.infer(obj).serialize(obj)
+      else
+        item = obj
+      end
+
+      result = encode_raw(item)
+      result
+    end
+
+    private
+
+    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 #{item.class.name}"
+      raise EncodingError.new(msg, item)
+    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
+end

data/lib/rlp/error.rb

@@ -39,7 +39,7 @@ module RLP
       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]
+          message = "Serialization failed because of element at index #{index} ('#{element_exception}')"
         end
 
         super(message, obj)
@@ -53,7 +53,7 @@ module RLP
       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]
+          message = "Deserialization failed because of element at index #{index} ('#{element_exception}')"
         end
 
         super(message, serial)

data/lib/rlp/sedes.rb

@@ -1,6 +1,8 @@
 require_relative 'sedes/big_endian_int'
 require_relative 'sedes/binary'
 require_relative 'sedes/list'
+require_relative 'sedes/countable_list'
+require_relative 'sedes/raw'
 
 module RLP
   module Sedes
@@ -12,8 +14,7 @@ module RLP
         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
+        raise TypeError, "Did not find sedes handling type #{obj.class.name}"
       end
 
       def sedes?(obj)
@@ -27,6 +28,10 @@ module RLP
       def binary
         @binary ||= Binary.new
       end
+
+      def raw
+        @raw ||= Raw.new
+      end
     end
 
   end

data/lib/rlp/sedes/big_endian_int.rb

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

data/lib/rlp/sedes/binary.rb

@@ -18,7 +18,7 @@ module RLP
       end
 
       def serialize(obj)
-        raise SerializationError.new("Object is not a serializable (%s)" % obj.class, obj) unless self.class.valid_type?(obj)
+        raise SerializationError.new("Object is not a serializable (#{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)
@@ -27,8 +27,8 @@ module RLP
       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)
+        raise DeserializationError.new("Objects of type #{serial.class} cannot be deserialized", serial) unless primitive?(serial)
+        raise DeserializationError.new("#{serial.class} has invalid length", serial) unless valid_length?(serial.size)
 
         serial
       end

data/lib/rlp/sedes/countable_list.rb

@@ -0,0 +1,57 @@
+module RLP
+  module Sedes
+    ##
+    # A sedes for lists of arbitrary length.
+    #
+    class CountableList
+      include Error
+      include Utils
+
+      def initialize(element_sedes, max_length: nil)
+        @element_sedes = element_sedes
+        @max_length = max_length
+      end
+
+      def serialize(obj)
+        raise ListSerializationError.new(message: "Can only serialize sequences", obj: obj) unless list?(obj)
+
+        result = []
+        obj.each_with_index do |e, i|
+          begin
+            result.push @element_sedes.serialize(e)
+          rescue SerializationError => e
+            raise ListSerializationError.new(obj: obj, element_exception: e, index: i)
+          end
+
+          if @max_length && result.size > @max_length
+            msg = "Too many elements (#{result.size}, allowed #{@max_length})"
+            raise ListSerializationError.new(message: msg, obj: obj)
+          end
+        end
+
+        result
+      end
+
+      def deserialize(serial)
+        raise ListDeserializationError.new(message: 'Can only deserialize sequences', serial: serial) unless list?(serial)
+
+        result = []
+        serial.each_with_index do |e, i|
+          begin
+            result.push @element_sedes.deserialize(e)
+          rescue DeserializationError => e
+            raise ListDeserializationError.new(serial: serial, element_exception: e, index: i)
+          end
+
+          if @max_length && result.size > @max_length
+            msg = "Too many elements (#{result.size}, allowed #{@max_length})"
+            raise ListDeserializationError.new(message: msg, serial: serial)
+          end
+        end
+
+        result.freeze
+      end
+
+    end
+  end
+end

data/lib/rlp/sedes/list.rb

@@ -1,8 +1,11 @@
 module RLP
   module Sedes
+    ##
+    # A sedes for lists of fixed length
+    #
     class List < Array
-      include RLP::Error
-      include RLP::Utils
+      include Error
+      include Utils
 
       def initialize(elements: [], strict: true)
         super()
@@ -53,11 +56,8 @@ module RLP
           end
         end
 
-        result
+        result.freeze
       end
     end
-
-#TODO: CountableList
-
   end
 end

data/lib/rlp/sedes/raw.rb

@@ -0,0 +1,31 @@
+module RLP
+  module Sedes
+    ##
+    # A sedes that does nothing. Thus, everything that can be directly encoded
+    # by RLP is serializable. This sedes can be used as a placeholder when
+    # deserializing larger structures.
+    #
+    class Raw
+      include Error
+      include Utils
+
+      def serialize(obj)
+        raise SerializationError.new("Can only serialize nested lists of strings", obj) unless serializable?(obj)
+        obj
+      end
+
+      def deserialize(serial)
+        serial
+      end
+
+      private
+
+      def serializable?(obj)
+        return true if primitive?(obj)
+        return obj.all? {|item| serializable?(item) } if list?(obj)
+        false
+      end
+
+    end
+  end
+end

data/lib/rlp/utils.rb

@@ -27,7 +27,7 @@ module RLP
     end
 
     def encode_hex(b)
-      raise ArgumentError, "Value must be an instance of String"  unless b.instance_of?(String)
+      raise TypeError, "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

data/lib/rlp/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rlp
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Jan Xie
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-23 00:00:00.000000000 Z
+date: 2016-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -51,11 +51,15 @@ files:
 - lib/rlp.rb
 - lib/rlp/constant.rb
 - lib/rlp/data.rb
+- lib/rlp/decode.rb
+- lib/rlp/encode.rb
 - lib/rlp/error.rb
 - lib/rlp/sedes.rb
 - lib/rlp/sedes/big_endian_int.rb
 - lib/rlp/sedes/binary.rb
+- lib/rlp/sedes/countable_list.rb
 - lib/rlp/sedes/list.rb
+- lib/rlp/sedes/raw.rb
 - lib/rlp/utils.rb
 - lib/rlp/version.rb
 homepage: https://github.com/janx/ruby-rlp