rlp-lite 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b94a62e8d77c1f5752f02e1088db2394fb281800a444fc744bcb17e2c8bb1d3f
-  data.tar.gz: 4708183e54acac23ef32ebd0f74c2b78cdced4778752dbe6b2d51260363dd6b8
+  metadata.gz: 1ebdf026e59948e13d720bef7940d7b7235cd9f03ae9e8327431c0cbb71cf041
+  data.tar.gz: 49f5ea7e8a42793686d997919dd546f91578be192da69c85ac57558591309997
 SHA512:
-  metadata.gz: 5fadf8e0fe94f689ba0ee198bd7e2d94c5bd6d606261d26c2308a2a676fe9ddb9e5489ec00ff31b2e592987727982b02bdeb48dea3ee105c8ab8ca1fa8b9988a
-  data.tar.gz: 390a76f7d97500ee445e653a98eb250ff254f0936167e6900444f5e3540439453023f463c7272ed5d453416d2f2d2a46cd884736dc9399f26b6b1eb95c1c1f0a
+  metadata.gz: 56e0042122a25d23770570cb7837d67d31acc511957bd8c8e42e6b3d9e491dc52e7691909cc50d1d286118080b8429ab933f966ca8cb49116a2f9bce7070d9cd
+  data.tar.gz: 42f3bb460973d8cb111f1bcb3d7b10a36eb5ca1921a8eebbf575f90c3ed4f6c66d82146887675c81f09e1a292ff98657389d2db966ac770b38032f9d8221a225

data/README.md

@@ -1,7 +1,7 @@
 #  Recursive Length Prefix (RLP) Lite
 
 
-rlp-lite - light-weight machinery to serialize / deserialze via rlp
+rlp-lite - light-weight machinery to serialize / deserialze via rlp (recursive length prefix)
 
 
 
@@ -15,9 +15,67 @@ rlp-lite - light-weight machinery to serialize / deserialze via rlp
 
 ## Usage
 
-to be done
 
+``` ruby
+require 'rlp-lite'
 
+######
+## encode
+
+list =  ['ruby', 'rlp', 255]
+
+encoded = Rlp.encode( list )
+#=> "\xCB\x84ruby\x83rlp\x81\xFF".b
+
+#######
+## decode
+
+decoded = Rlp.decode( "\xCB\x84ruby\x83rlp\x81\xFF".b )
+#=> ["ruby", "rlp", "\xFF".b]
+```
+
+
+
+Note:  All integers get returned (decoded) as big integers in binary buffers (that is, string with binary "ASCII-8BIT" encoding)
+e.g. `"\xFF".b` and not `255`.
+
+
+
+More examples from the official ethereum rlp tests,
+see [test/data/rlptest.json](test/data/rlptest.json).
+
+
+``` ruby
+######
+# lists of lists
+obj = [ [ [], [] ], [] ]
+encoded = Rlp.encode( obj )
+#=> "\xC4\xC2\xC0\xC0\xC0".b
+
+decoded =  Rlp.decode( "\xC4\xC2\xC0\xC0\xC0".b )
+#=> [[[], []], []]
+
+# or using a hex string (not a binary buffer)
+decoded =  Rlp.decode( "0xc4c2c0c0c0" )
+#=> [[[], []], []]
+
+
+#####
+# dict(onary)
+obj = [["key1", "val1"],
+       ["key2", "val2"],
+       ["key3", "val3"],
+       ["key4", "val4"]]
+encoded = Rlp.encode( obj )
+#=> "\xEC\xCA\x84key1\x84val1\xCA\x84key2\x84val2\xCA\x84key3\x84val3\xCA\x84key4\x84val4".b
+
+decoded = Rlp.decode( "\xEC\xCA\x84key1\x84val1\xCA\x84key2\x84val2\xCA\x84key3\x84val3\xCA\x84key4\x84val4".b )
+#=> [["key1", "val1"], ["key2", "val2"], ["key3", "val3"], ["key4", "val4"]]
+
+# or using a hex string (not a binary buffer)
+decoded = Rlp.decode( "0xecca846b6579318476616c31ca846b6579328476616c32ca846b6579338476616c33ca846b6579348476616c34" )
+#=> [["key1", "val1"], ["key2", "val2"], ["key3", "val3"], ["key4", "val4"]]
+```
 
 
 ## License

data/Rakefile

@@ -2,6 +2,14 @@ require 'hoe'
 require './lib/rlp-lite/version.rb'
 
 
+###
+# hack/ quick fix for broken intuit_values - overwrite with dummy
+class Hoe
+  def intuit_values( input ); end
+end
+
+
+
 Hoe.spec 'rlp-lite' do
 
   self.version = Rlp::VERSION

data/lib/rlp-lite/decoder.rb

@@ -1,17 +1,17 @@
   module Rlp
 
+
     # Provides an RLP-decoder.
-    module Decoder
-      extend self
+    class Decoder
 
       # Decodes an RLP-encoded object.
       #
       # @param rlp [String] an RLP-encoded object.
       # @return [Object] the decoded and maybe deserialized object.
-      # @raise [Eth::Rlp::DecodingError] if the input string does not end after
+      # @raise [Rlp::DecodingError] if the input string does not end after
       #     the root item.
-      def perform(rlp)
-        rlp = Util.hex_to_bin( rlp ) if Util.is_hex?( rlp )
+      def perform( rlp )
+        rlp = Util.hex_to_bin( rlp )    if Util.is_hex?( rlp )
         rlp = Util.str_to_bytes( rlp )
         begin
           item, next_start = consume_item( rlp, 0 )
@@ -23,6 +23,7 @@
       end
 
 
+
       private
 
       # Consume an RLP-encoded item from the given start.

data/lib/rlp-lite/encoder.rb

@@ -1,33 +1,40 @@
 
-  # Provides an recursive-length prefix (RLP) encoder and decoder.
   module Rlp
 
+
     # Provides an RLP-encoder.
-    module Encoder
-      extend self
+    class Encoder
+
 
       # Encodes a Ruby object in RLP format.
       #
       # @param obj [Object] a Ruby object.
       # @return [String] the RLP encoded item.
-      # @raise [Eth::Rlp::EncodingError] in the rather unlikely case that the item
+      # @raise [Rlp::EncodingError] in the rather unlikely case that the item
       #     is too big to encode (will not happen).
-      # @raise [Eth::Rlp::SerializationError] if the serialization fails.
-      def perform(obj)
+      # @raise [Rlp::SerializationError] if the serialization fails.
+      def perform( obj )
         item = Sedes.infer(obj).serialize(obj)
         result = encode_raw( item )
       end
 
-      private
+
+    private
 
       # Encodes the raw item.
-      def encode_raw(item)
-        return item    if item.instance_of? Rlp::Data
-        return encode_primitive item if Sedes.is_primitive? item
-        return encode_list item if Sedes.is_list? item
-        raise EncodingError "Cannot encode object of type #{item.class.name}"
+      def encode_raw( item )
+        if item.instance_of?( Rlp::Data )
+          item
+        elsif Util.is_primitive?( item )
+          encode_primitive item
+        elsif Util.is_list?( item )
+          encode_list item
+        else
+          raise EncodingError "Cannot encode object of type #{item.class.name}"
+        end
       end
 
+
       # Encodes a single primitive.
       def encode_primitive(item)
         return Util.str_to_bytes item if item.size == 1 && item.ord < PRIMITIVE_PREFIX_OFFSET
@@ -56,4 +63,4 @@
         end
       end
     end
-  end   # module Rlp
+end   # module Rlp

data/lib/rlp-lite/sedes/big_endian_int.rb

@@ -24,7 +24,7 @@
           raise SerializationError, "Can only serialize integers" unless obj.is_a?(Integer)
           raise SerializationError, "Cannot serialize negative integers" if obj < 0
           raise SerializationError, "Integer too large (does not fit in #{@size} bytes)" if @size && obj >= 256 ** @size
-          s = obj == 0 ? BYTE_EMPTY : _int_to_big_endian(obj)
+          s = obj == 0 ? BYTE_EMPTY : _int_to_big_endian( obj )
           @size ? "#{BYTE_ZERO * [0, @size - s.size].max}#{s}" : s
         end
 
@@ -38,7 +38,7 @@
           raise DeserializationError, "Invalid serialization (wrong size)" if @size && serial.size != @size
           raise DeserializationError, "Invalid serialization (not minimal length)" if !@size && serial.size > 0 && serial[0] == BYTE_ZERO
           serial = serial || BYTE_ZERO
-          _big_endian_to_int(serial)
+          _big_endian_to_int( serial )
         end
 
 

data/lib/rlp-lite/sedes/binary.rb

@@ -9,16 +9,18 @@
           # @param l [Integer] the fixed size of the binary.
           # @param allow_empty [Boolean] indicator wether empty binaries should be allowed.
           # @return [Eth::Rlp::Sedes::Binary] a serializable binary of fixed size.
-          def self.fixed_length(l, allow_empty: false)
-            new(min_length: l, max_length: l, allow_empty: allow_empty)
+          def self.fixed_length( l, allow_empty: false )
+            new( min_length: l,
+                 max_length: l,
+                 allow_empty: allow_empty )
           end
 
           # Checks wether the given object is of a valid binary type.
           #
           # @param obj [Object] the supposed binary item to check.
           # @return [Boolean] true if valid.
-          def self.valid_type?(obj)
-            obj.instance_of? String
+          def self.valid_type?( obj )
+            obj.instance_of?( String )
           end
 
 
@@ -27,7 +29,7 @@
         # @param min_length [Integer] the minimum size of the binary.
         # @param max_length [Integer] the maximum size of the binary.
         # @param allow_empty [Boolean] indicator wether empty binaries should be allowed.
-        def initialize(min_length: 0, max_length: INFINITY, allow_empty: false)
+        def initialize( min_length: 0, max_length: INFINITY, allow_empty: false )
           @min_length = min_length
           @max_length = max_length
           @allow_empty = allow_empty
@@ -39,13 +41,17 @@
         # @return [Object] a serialized binary.
         # @raise [SerializationError] if provided object is of invalid type.
         # @raise [SerializationError] if provided binary is of invalid length.
-        def serialize(obj)
-          raise SerializationError, "Object is not a serializable (#{obj.class})" unless self.class.valid_type? obj
-          serial = _str_to_bytes( obj )
-          raise SerializationError, "Object has invalid length" unless valid_length? serial.size
+        def serialize( obj )
+          raise SerializationError, "Object is not a serializable (#{obj.class})" unless self.class.valid_type?( obj )
+
+          ##  make sure string is with binary encoding (ASCII-8BIT)
+          ##    note: was Util.str_to_bytes( obj )
+          serial =  obj.encoding.name == 'ASCII-8BIT' ? obj : obj.b
+          raise SerializationError, "Object has invalid length" unless valid_length?( serial.size )
           serial
         end
 
+
         # Deserializes a binary.
         #
         # @param serial [Object] the serialized binary.
@@ -53,8 +59,8 @@
         # @raise [DeserializationError] if provided serial is of wrong type.
         # @raise [DeserializationError] if provided serial is of wrong length.
         def deserialize(serial)
-          raise DeserializationError, "Objects of type #{serial.class} cannot be deserialized" unless _is_primitive? serial
-          raise DeserializationError, "#{serial.class} has invalid length" unless valid_length? serial.size
+          raise DeserializationError, "Objects of type #{serial.class} cannot be deserialized" unless serial.instance_of?(String)
+          raise DeserializationError, "#{serial.class} has invalid length" unless valid_length?( serial.size )
           serial
         end
 
@@ -63,39 +69,11 @@
         #
         # @param length [Integer] the supposed length of the binary item.
         # @return [Boolean] true if valid.
-        def valid_length?(length)
+        def valid_length?( length )
           (@min_length <= length && length <= @max_length) ||
           (@allow_empty && length == 0)
         end
 
-#######
-#  private helpers
-
- # Converts a binary string to bytes.
-    #
-    # @param str [String] binary string to be converted.
-    # @return [Object] the string bytes.
-    def _str_to_bytes(str)
-      _is_bytes?(str) ? str : str.b
-    end
-
-      # Checks if a string is a byte-string.
-    #
-    # @param str [String] a string to check.
-    # @return [Boolean] true if it's an ASCII-8bit encoded byte-string.
-    def _is_bytes?(str)
-      str && str.instance_of?(String) && str.encoding.name == 'ASCII-8BIT'
-    end
-
-    # Checks if the given item is a string primitive.
-    #
-    # @param item [Object] the item to check.
-    # @return [Boolean] true if it's a string primitive.
-    def _is_primitive?(item)
-      item.instance_of?(String)
-    end
-
-
 end  # class Binary
 
 

data/lib/rlp-lite/sedes/list.rb

@@ -9,14 +9,14 @@
         #
         # @param elements [Array] an array indicating the structure of the list.
         # @param strict [Boolean] an option to enforce the given structure.
-        def initialize(elements: [], strict: true)
+        def initialize( elements: [], strict: true )
           super()
 
           @strict = strict
           elements.each do |e|
             if Sedes.is_sedes?(e)
               push e
-            elsif Sedes.is_list?(e)
+            elsif Util.is_list?(e)
               push List.new(elements: e)
             else
               raise TypeError, "Instances of List must only contain sedes objects or nested sequences thereof."
@@ -30,8 +30,8 @@
         # @return [Array] a serialized list.
         # @raise [SerializationError] if provided array is not a sequence.
         # @raise [SerializationError] if provided array is of wrong length.
-        def serialize(obj)
-          raise SerializationError, "Can only serialize sequences" unless Sedes.is_list?(obj)
+        def serialize( obj )
+          raise SerializationError, "Can only serialize sequences" unless Util.is_list?(obj)
           raise SerializationError, "List has wrong length" if (@strict && self.size != obj.size) || self.size < obj.size
           result = []
           obj.zip(self).each_with_index do |(element, sedes), i|
@@ -47,7 +47,7 @@
         # @raise [DeserializationError] if provided serial is not a sequence.
         # @raise [DeserializationError] if provided serial is of wrong length.
         def deserialize(serial)
-          raise DeserializationError, "Can only deserialize sequences" unless Sedes.is_list?(serial)
+          raise DeserializationError, "Can only deserialize sequences" unless Util.is_list?(serial)
           raise DeserializationError, "List has wrong length" if @strict && serial.size != self.size
           result = []
           len = [serial.size, self.size].min

data/lib/rlp-lite/sedes.rb

@@ -3,8 +3,7 @@
   module Rlp
     module Sedes
 
-      # Provides a singleton {Rlp::Sedes} class to infer objects and types.
-      class << self
+      # Provides a {Rlp::Sedes} module to infer objects and types.
 
         # Tries to find a sedes objects suitable for a given Ruby object.
         #
@@ -14,12 +13,18 @@
         #
         # @param obj [Object] the Ruby object for which to find a sedes object.
         # @raise [TypeError] if no appropriate sedes could be found.
-        def infer(obj)
-          return obj.class      if is_sedes?( obj.class )
-          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 is_list?( obj )
-          raise TypeError, "Did not find sedes handling type #{obj.class.name}"
+        def self.infer( obj )
+          if is_sedes?( obj.class )
+            obj.class
+          elsif obj.is_a?(Integer) && obj >= 0
+            big_endian_int
+          elsif Binary.valid_type?( obj )    ## note: same as obj.is_a?( String )
+            binary
+          elsif Util.is_list?( obj )
+            List.new( elements: obj.map { |item| infer( item ) } )
+          else
+            raise TypeError, "Did not find sedes handling type #{obj.class.name}"
+          end
         end
 
 
@@ -27,7 +32,7 @@
         #
         # @param obj [Object] the object to check.
         # @return [Boolean] true if it's serializable and deserializable.
-        def is_sedes?(obj)
+        def self.is_sedes?(obj)
           obj.respond_to?(:serialize) && obj.respond_to?(:deserialize)
         end
 
@@ -35,39 +40,19 @@
         # unspecified length.
         #
         # @return [Rlp::Sedes::BigEndianInt] a big-endian, unsigned integer sedes.
-        def big_endian_int
+        def self.big_endian_int
           @big_endian_int ||= BigEndianInt.new
         end
 
         # A utility to use a binary sedes type.
         #
         # @return [Rlp::Sedes::Binary] a binary sedes.
-        def binary
+        def self.binary
           @binary ||= Binary.new
         end
 
-        ##############################
-        ### more helpers
 
-    # Checks if the given item is a string primitive.
-    #
-    # @param item [Object] the item to check.
-    # @return [Boolean] true if it's a string primitive.
-    def is_primitive?(item)
-      item.instance_of?(String)
-    end
 
-    # Checks if the given item is a list.
-    #
-    # @param item [Object] the item to check.
-    # @return [Boolean] true if it's a list.
-    def is_list?(item)
-      !is_primitive?(item) && item.respond_to?(:each)
-    end
 
-
-
-
-      end
-    end
-  end  #  module Rlp
+end   # module Sedes
+end  #  module Rlp

data/lib/rlp-lite/util.rb

@@ -11,8 +11,8 @@ module Util
     # @param str [String] a string to be checked.
     # @return [String] a match if true; `nil` if not.
     def is_hex?(str)
-      return false unless str.is_a? String
-      str = remove_hex_prefix str
+      return false unless str.is_a?( String )
+      str = remove_hex_prefix( str )
       str.match /\A[0-9a-fA-F]*\z/
     end
 
@@ -21,7 +21,7 @@ module Util
     # @param hex [String] a prefixed hex-string.
     # @return [String] an unprefixed hex-string.
     def remove_hex_prefix(hex)
-      return hex[2..-1] if is_prefixed? hex
+      return hex[2..-1] if is_prefixed?( hex )
       return hex
     end
 
@@ -39,9 +39,9 @@ module Util
     # @param hex [String] a hexa-decimal string to be packed.
     # @return [String] a packed binary string.
     # @raise [TypeError] if value is not a string or string is not hex.
-    def hex_to_bin(hex)
+    def hex_to_bin( hex )
       raise TypeError, "Value must be an instance of String" unless hex.instance_of? String
-      hex = remove_hex_prefix hex
+      hex = remove_hex_prefix( hex )
       raise TypeError, "Non-hexadecimal digit found" unless is_hex? hex
       [hex].pack("H*")
     end
@@ -104,5 +104,24 @@ module Util
     end
 
 
+     # Checks if the given item is a string primitive.
+    #
+    # @param item [Object] the item to check.
+    # @return [Boolean] true if it's a string primitive.
+    def is_primitive?( item )
+      item.instance_of?(String)
+    end
+
+    # Checks if the given item is a list.
+    #
+    # @param item [Object] the item to check.
+    # @return [Boolean] true if it's a list.
+    def is_list?( item )
+      !is_primitive?(item) && item.respond_to?(:each)
+    end
+
+
+
+
 end   # module Util
 end   # module Rlp

data/lib/rlp-lite/version.rb

@@ -1,5 +1,5 @@
 
 module Rlp
-  VERSION='0.0.1'
+  VERSION='0.1.0'
 end
 

data/lib/rlp-lite.rb

@@ -22,23 +22,14 @@ module Rlp
    ## todo/check   - use encoding -ascii-8bit for source file or ? - why? why not?
    ## use  #b/.b  to ensure binary encoding? - why? why not?
    BYTE_EMPTY = "".freeze   # The empty byte is defined as "".
-   BYTE_ZERO = "\x00".freeze   # The zero byte is 0x00.
-   BYTE_ONE = "\x01".freeze    # The byte one is 0x01.
+   BYTE_ZERO  = "\x00".freeze   # The zero byte is 0x00.
+   BYTE_ONE   = "\x01".freeze    # The byte one is 0x01.
 
 
-
-   # The RLP short length limit.
-   SHORT_LENGTH_LIMIT = 56
-
-   # The RLP long length limit.
-   LONG_LENGTH_LIMIT = (256 ** 8)
-
-   # The RLP primitive type offset.
-   PRIMITIVE_PREFIX_OFFSET = 0x80
-
-   # The RLP array type offset.
-   LIST_PREFIX_OFFSET = 0xc0
-
+   SHORT_LENGTH_LIMIT = 56           # The RLP short length limit.
+   LONG_LENGTH_LIMIT = (256 ** 8)    # The RLP long length limit.
+   PRIMITIVE_PREFIX_OFFSET = 0x80    # The RLP primitive type offset.
+   LIST_PREFIX_OFFSET = 0xc0         # The RLP array type offset.
 
    # Infinity as constant for convenience.
    INFINITY = (1.0 / 0.0)
@@ -63,18 +54,24 @@ module Rlp
  class Data < String; end
 
 
+    def self.encoder() @encoder ||= Encoder.new; end
+    def self.decoder() @decoder ||= Decoder.new; end
+
+
     # Performes an {Rlp::Encoder} on any ruby object.
     #
     # @param obj [Object] any ruby object.
     # @return [String] a packed, RLP-encoded item.
-    def self.encode(obj) Encoder.perform( obj ); end
+    def self.encode(obj) encoder.perform( obj ); end
 
 
     # Performes an {Rlp::Decoder} on any RLP-encoded item.
     #
     # @param rlp [String] a packed, RLP-encoded item.
     # @return [Object] a decoded ruby object.
-    def self.decode(rlp) Decoder.perform( rlp ); end
+    def self.decode(rlp) decoder.perform( rlp ); end
+
+
 end   # module Rlp
 
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rlp-lite
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Gerald Bauer