bytepack 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5638d36e9962d27928e960c35999f7f7bea8d7b76b9cbe73258be0051c21b782
+  data.tar.gz: 2c03181ab1a272ac8caf74f1866673759948744dc3c29147ff4b5c426f145f1f
+SHA512:
+  metadata.gz: 34bd43f7e60a131d50b3e883acfdd1d7dab5c931b8ee1d1723dba21848e86d61e11006126fa1cf54fed3c856aeeae45c48e0920cda12c54868c8d9ef61bacca0
+  data.tar.gz: 03055a552a8240b5a837db21e55db3aa0249293ad08b4dc48a3545288ed194cf0c42206b3a03a2088f9003482a3e70454885ba33449b90482fd875ec6fe9eb28

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## [0.0.1] - 2019-05-16
+### Initial release
+- See docs and just try it!

data/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+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,344 @@
+# Bytepack
+
+### Tool for byte-serialization of various Ruby data structures
+
+#### Packing & unpacking various Ruby data to/from a byte string, incl. arrays, hashes and custom data structures
+
+## Compatibility
+
+Compatible with Ruby **MRI 2.4**> & **JRuby 9.2**>
+
+## Installation
+
+    $ gem install bytepack
+
+## Basic usage
+
+Require Gem
+
+    require 'bytepack'
+    
+Packing specific datatype returns a byteset:
+    
+    Bytepack::String.pack("test") # One argument as source value
+    => "\x03\x04test"
+     
+Unpacking specific datatype returns an Array consists of Ruby object and resulted bytes offset as integer:
+
+    bytes = Bytepack::String.pack("test")
+    => "\x03\x04test"
+    Bytepack::String.unpack(bytes) # Two arguments: byteset & offset as integer (optional)
+    => ["test", 6]
+    
+Testing unpacking authenticity *(pack & unpack)*:
+
+    Bytepack::String.testpacking("test")
+    => ["test", 6]
+
+## Ruby Standard Library basic datatypes
+
+### Byte Integer
+
+8-bit Integer in range [-127..127]
+
+    Bytepack::Byte.pack(34)
+    => "\""
+    
+    Bytepack::Byte.unpack("\"".b)
+    => [34, 1]
+    
+8-bit Unsigned Integer in range [1..127]
+
+    Bytepack::UByte.pack(34)
+    => "\""
+
+    Bytepack::UByte.unpack("\"".b)
+    => [34, 1]
+    
+### Short Integer
+
+16-bit Integer in range [-32767..32767]
+
+    Bytepack::Short.pack(23423)
+    => "[\x7F"
+    
+    Bytepack::Short.unpack("[\x7F".b)
+    => [23423, 2]
+
+16-bit Unsigned Integer in range [1..32767]
+
+    Bytepack::UShort.pack(23423)
+    => "[\x7F"
+    
+    Bytepack::UShort.unpack("[\x7F".b)
+    => [23423, 2]       
+
+### Integer
+
+32-bit Integer in range [-2147483647..2147483647]
+
+    Bytepack::Integer.pack(12323423)
+    => "\x00\xBC\n_"
+    
+    Bytepack::Integer.unpack("\x00\xBC\n_".b)
+    => [12323423, 4]
+    
+32-bit Unsigned Integer in range [1..2147483647]
+
+    Bytepack::UInteger.pack(12323423)
+    => "\x00\xBC\n_"
+    
+    Bytepack::UInteger.unpack("\x00\xBC\n_".b)
+    => [12323423, 4]
+    
+### Long Integer
+
+64-bit Integer in range [-9223372036854775807..9223372036854775807]
+
+    Bytepack::Long.pack(98712323423)
+    => "\x00\x00\x00\x16\xFB\xB6\x85_"
+    
+    Bytepack::Long.unpack("\x00\x00\x00\x16\xFB\xB6\x85_".b)
+    => [98712323423, 8]
+    
+64-bit Unsigned Integer in range [1..9223372036854775807]
+
+    Bytepack::ULong.pack(98712323423)
+    => "\x00\x00\x00\x16\xFB\xB6\x85_"
+    
+    Bytepack::ULong.unpack("\x00\x00\x00\x16\xFB\xB6\x85_".b)
+    => [98712323423, 8] 
+
+### Various length Integer
+
+128-bit Long Long signed Integer
+
+    Bytepack::Basic.intToBytes(16, 2345980343453498712323423) # Two arguments: bytesize & value
+    => "\x00\x00\x00\x00\x00\x01\xF0\xC7\xD9hbd>\f\xF5_"
+    
+    Bytepack::Basic.bytesToInt(16, "\x00\x00\x00\x00\x00\x01\xF0\xC7\xD9hbd>\f\xF5_".b) # Three arguments: bytesize, byteset, offset as integer (optional)
+    => [2345980343453498712323423, 8]
+
+### The shortest length Integer
+
+Use universal **Bytepack::AnyType** class for that
+
+    Bytepack::AnyType.pack(8934)
+    => "\x04\"\xE6" # Packed as 1 meta-byte & 16-bit short Integer (total 3 bytes)
+    
+    Bytepack::AnyType.unpack("\x04\"\xE6".b)
+    => [8934, 3]
+    
+### Float
+
+    Bytepack::Float.pack(3.1415926)
+    => "@\t!\xFBM\x12\xD8J"
+    
+    Bytepack::Float.unpack("@\t!\xFBM\x12\xD8J".b)
+    => [3.1415926, 8]
+  
+### BigDecimal
+
+    value = BigDecimal('3.1415926')
+    => 0.31415926e1
+
+    Bytepack::Decimal.pack(value)
+    => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\xDBu\x82\xCD\xC0"
+    
+    Bytepack::Decimal.unpack("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\xDBu\x82\xCD\xC0".b)
+    => [0.31415926e1, 16]
+
+### NilClass
+
+    Bytepack::Null.pack(nil)
+    => "\x80"
+    
+    Bytepack::Null.unpack("\x80".b)
+    => [nil, 1]
+
+### String ASCII-8BIT encoded (Binary data)
+
+Pack ASCII-8BIT encoded string:
+
+    value = "\x04v\x1A\xE8wev\xD6".b
+
+    Bytepack::Varbinary.pack(value)
+    => "\x03\b\x04v\x1A\xE8wev\xD6" # includes 1 meta-byte, 1-8 bytes of value's length integer and a byteset of value
+    
+    Bytepack::Varbinary.unpack("\x03\b\x04v\x1A\xE8wev\xD6".b)
+    => ["\x04v\x1A\xE8wev\xD6", 10]
+
+By default, value's length serialized by *Byteset::AnyType* as a shortest integer possible (Byte, Short, Int or Long) and allways 2 bytes or more. You can override length datatype globally and make it static:
+
+    Bytepack::Varbinary.config(:LENGTH_TYPE, Bytepack::Integer)
+    value = "\x04v\x1A\xE8wev\xD6".b
+    Bytepack::Varbinary.pack(value)
+    => "\x00\x00\x00\b\x04v\x1A\xE8wev\xD6" # includes 1 meta-byte, 4 bytes of value's length and a byteset of value
+    
+Byteset size now is *2 bytes more*, but allways **4 bytes (32-bit)**. That's useful in cases where byteset length make sense in the current project.
+
+### String UTF-8 encoded (Regular string)
+
+Pack UTF-8 encoded string:
+
+    Bytepack::String.pack("Words like violence")
+    => "\x03\x13Words like violence" # includes 1 meta-byte, 1-8 bytes of value's length integer and a byteset of value
+    
+    Bytepack::String.unpack("\x03\x13Words like violence".b)
+    => ["Words like violence", 21]
+
+By default, value's length serialized the same way as *Bytepack::Varbinary*, but you can specify length datatype and make it static:
+
+    Bytepack::String.config(:LENGTH_TYPE, Bytepack::Integer)
+    Bytepack::String.pack("Words like violence")
+    => "\x00\x00\x00\x13Words like violence" # includes 1 meta-byte, 4 bytes of value's length and a byteset of value
+
+### Symbol
+
+Works almost the same way as String serialization do:
+
+    Bytepack::Symbol.pack(:key_this_value)
+    => "\x03\x0Ekey_this_value" # includes 1 meta-byte, 1-8 bytes of value's length integer and a byteset of value
+    
+    Bytepack::Symbol.unpack("\x03\x0Ekey_this_value".b)
+    => [:key_this_value, 18]
+
+By default, value's length serialized the same way as *Bytepack::Varbinary*, but you can specify length datatype and make it static:
+
+    Bytepack::Symbol.config(:LENGTH_TYPE, Bytepack::Integer)
+    Bytepack::Symbol.pack(:key_this_value)
+    => "\x00\x00\x00\x0Ekey_this_value" # includes 1 meta-byte, 4 bytes of value's length and a byteset of value
+
+### Time
+
+All objects are represented as *Bytepack::Long* values (64-bit). The signed integer represents the number of microseconds before or after Unix epoch (Jan. 1 1970 00:00:00 GMT).
+
+    Bytepack::Timestamp.pack(Time.now)
+    => "\x00\x05\x89\x02H\xF8\xDA\x9B"
+    
+    Bytepack::Timestamp.unpack("\x00\x05\x89\x02H\xF8\xDA\x9B".b)
+    => [2019-05-16 17:43:10 +0300, 8]
+
+## Arrays and hashes
+
+Arrays can be serialized in two modes:
+
+### Single Type Array
+
+Arrays consists of elements belongs to one datatype:
+
+    array = [1,2,3,4,5,6,4,3,2,123,3223,-23,0,12,89,100] # All elements are integers
+    
+You can pass specific datatype as the first array's element:
+
+    byteset = Bytepack::SingleTypeArray.pack([Bytepack::Short, *array])
+    => "\x04\x03\x10\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x04\x00\x03\x00\x02\x00{\f\x97\xFF\xE9\x00\x00\x00\f\x00Y\x00d"
+    
+    Bytepack::SingleTypeArray.unpack(byteset)
+    => [[1, 2, 3, 4, 5, 6, 4, 3, 2, 123, 3223, -23, 0, 12, 89, 100], 35]
+    
+Or you wouldn't do it, it recognizes automatically by the longest integer:
+
+    byteset = Bytepack::SingleTypeArray.pack(array)
+    => "\x04\x03\x10\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x04\x00\x03\x00\x02\x00{\f\x97\xFF\xE9\x00\x00\x00\f\x00Y\x00d"
+    
+    Bytepack::SingleTypeArray.unpack(byteset)
+    => [[1, 2, 3, 4, 5, 6, 4, 3, 2, 123, 3223, -23, 0, 12, 89, 100], 35]
+  
+By default, array's size serialized by *Byteset::AnyType* as a shortest integer possible (Byte, Short, Int or Long), you can override length datatype globally and make it static:
+
+    Bytepack::SingleTypeArray.config(:LENGTH_TYPE, Bytepack::Byte)
+    byteset = Bytepack::SingleTypeArray.pack(array)
+    Bytepack::SingleTypeArray.unpack(byteset)
+    => [[1, 2, 3, 4, 5, 6, 4, 3, 2, 123, 3223, -23, 0, 12, 89, 100], 34]
+
+Byteset size now is **34** instead of **35**. Why, because in previous example length packed as *2-bytes Byteset::AnyType, including 1 meta-byte and 1 byte integer itself*. Setting explicitly the length type as *Byteset::Byte*, it just 1 byte. That's useful in cases where byteset length make sense in the current project.
+
+### Various Type Array (Regular array)
+
+Arrays consists of elements belongs to different datatypes:
+
+    array = [1,2,"3",4,:"five",6,[7,8,9],10,123,3223,-23,0,12,89,100] # Chaos array
+    
+    byteset = Bytepack::Array.pack(array)
+    => "\x03\x0F\x03\x01\x03\x02\t\x03\x013\x03\x04\n\x03\x04five\x03\x06\x9E\x03\x03\a\b\t\x03\n\x03{\x04\f\x97\x03\xE9\x03\x00\x03\f\x03Y\x03d"
+    
+    Bytepack::Array.unpack(byteset)
+    => [[1, 2, "3", 4, :five, 6, [7, 8, 9], 10, 123, 3223, -23, 0, 12, 89, 100], 44]
+  
+By default, array's size serialized by *Byteset::AnyType* as a shortest integer possible (Byte, Short, Int or Long), you can override length datatype globally and make it static:
+
+    Bytepack::Array.config(:LENGTH_TYPE, Bytepack::Byte)
+    byteset = Bytepack::Array.pack(array)
+    Bytepack::Array.unpack(byteset)
+    => [[1, 2, "3", 4, :five, 6, [7, 8, 9], 10, 123, 3223, -23, 0, 12, 89, 100], 43]
+
+Byteset size now is **43** instead of **44**.
+
+### Hash
+
+Technically Hash serialized as two arrays: keys and values. Serialization uses length types of current *Array and SingleTypeArray* settings. Let's say we have mashed hash.
+
+    hash = {:key1 => 1, :key2 => "2", "key3" => "key3", :key4 => 4, :key5 => :key5, :array => [1,2,3,"text",:sym, {:nil => nil, :foo => "bar"}]}
+    byteset = Bytepack::Hash.pack(hash)
+    => "\x9D\x06\n\x03\x04key1\n\x03\x04key2\t\x03\x04key3\n\x03\x04key4\n\x03\x04key5\n\x03\x05array\x9D\x06\x03\x01\t\x03\x012\t\x03\x04key3\x03\x04\n\x03\x04key5\x9D\x06\x03\x01\x03\x02\x03\x03\t\x03\x04text\n\x03\x03sym\xA7\x9E\n\x02\x03\x03nil\x03\x03foo\x9D\x02\x01\x80\t\x03\x03bar"
+
+Hash serialized into 114 bytes. Not, recover it:
+    
+    Bytepack::Hash.unpack(byteset)
+    => [{:key1=>1, :key2=>"2", "key3"=>"key3", :key4=>4, :key5=>:key5, :array=>[1, 2, 3, "text", :sym, {:nil=>nil, :foo=>"bar"}]}, 114]
+
+## Custom datatypes
+
+Of course, not all available data structures are implemented out of the box. You can serialize any type of data and do it in a shorter way than *Marshal* does. For these purposes, use **Bytepack::CustomData**.
+
+1) Create class inherited from **Bytepack::CustomData** class.
+2) Class must include constant **TYPE_CODE** as a Byte integer [-127..127]. Value must be unique and not in the list of *Bytepack::TypeInfo.codes.keys* (reserved by Gem itselt)
+3) Class must include constant **RUBY_TYPE** as a class in available namespace.
+4) Like all OOB structures class must include the class method **pack()** which accepts one required argument as input value. Method returns the byteset as a result of serialization.
+5) Like all OOB structures class must include the class method **unpack()** which accepts one required and one optional arguments:
+- byteset as a *String* object;
+- offset as an *Integer* object (optional, default=0).
+The **unpack()** method returns two element array, where the first element is deserialized Ruby object and the second one is resulted offset. The return offset must be correct! For what every Gem's structures returns the same dataset when unpacking.
+
+Example of serialization of **ActiveSupport::Duration** objects:
+
+    class DurationBytePack < Bytepack::CustomData
+      TYPE_CODE = 26
+      RUBY_TYPE = ActiveSupport::Duration
+      
+      DIRECTIVE = 'cl>'  
+      DURATION_PARTS = [:years, :months, :weeks, :days, :hours, :minutes, :seconds] # see ActiveSupport::Duration
+
+      class << self
+        def pack(val)
+          parts = val.parts
+          format = DIRECTIVE * parts.size
+          Bytepack::Byte.pack(parts.size) + parts.map {|part| [DURATION_PARTS.find_index(part[0]), part[1]]}.flatten.pack(format)
+        end
+    
+        def unpack(bytes, offset = 0)
+          length, offset = *Bytepack::Byte.unpack(bytes, offset)
+          unpacked = bytes.unpack("@#{offset}#{"cl>"*length}").each_slice(2).sum do |idx, value|
+            offset += 5
+            value.send(DURATION_PARTS[idx])
+          end
+          [unpacked, offset]
+        end
+
+      end
+    end
+    
+Try it now in the Rails console:
+
+    DurationBytePack.pack(3.days)
+    => "\x01\x03\x00\x00\x00\x03"
+    
+    DurationBytePack.unpack("\x01\x03\x00\x00\x00\x03".b)
+    => [3 days, 6]
+    
+    Bytepack::Array.pack([1,2,3,4,5.days])
+    => "\x00\x05\x03\x01\x03\x02\x03\x03\x03\x04\x1A\x01\x03\x00\x00\x00\x05"
+    
+    Bytepack::Array.unpack("\x00\x05\x03\x01\x03\x02\x03\x03\x03\x04\x1A\x01\x03\x00\x00\x00\x05".b)
+    => [[1, 2, 3, 4, 5 days], 17]

data/lib/bytepack.rb

@@ -0,0 +1,75 @@
+module Bytepack
+  
+  class Struct
+    class << self
+      def config(const, value)
+        begin
+          remove_const(const) if const_defined?(const)
+        rescue NameError
+        end
+        const_set(const, value)
+      end
+
+      def packingDataType(val) # Ruby data type conversion
+        case val
+        when ::Array then single_type_array?(val) ? SingleTypeArray : Array
+        when ::Hash then Hash
+        when ::NilClass then Null # Byte::NULL_INDICATOR
+        when ::Integer then
+          case val.bit_length
+          when (0..7) then Byte
+          when (8..15) then Short
+          when (16..31) then Integer
+          else
+            Long if val.bit_length >= 32
+          end
+        when ::Float then Float
+        when ::String then
+          val.encoding.name == "UTF-8" ? String : Varbinary # See "sometext".encoding
+        when ::Symbol then Symbol
+        when ::Time then Timestamp
+        when ::BigDecimal then Decimal
+        else # CustomData
+          CustomData.struct_by_ruby_type(val)
+        end
+      end
+  
+      def single_type_array?(array)
+        first_type = array[0].class
+        begin
+          array.each {|e| raise(Exception) unless e.is_a?(first_type)}
+        rescue Exception
+          false
+        else
+          true
+        end
+      end
+  
+      def classifyDataType(val)
+        case val
+        when Class then val if val < Struct
+        when ::String, ::Symbol then
+          begin
+            Bytepack.const_get("#{val}")
+          rescue
+            nil
+          end
+        end
+      end
+    
+      def testpacking(val)
+        unpack(pack(val))
+      end
+    
+    end
+  end
+  
+end
+
+require 'bytepack/any_type'
+require 'bytepack/basic'
+require 'bytepack/complex'
+require 'bytepack/compound'
+require 'bytepack/custom_data'
+require 'bytepack/extensions'
+require 'bytepack/type_info'

data/lib/bytepack/any_type.rb

@@ -0,0 +1,21 @@
+module Bytepack
+  class AnyType < Struct
+    
+    class << self
+      def pack(val)
+        dataType = packingDataType(val)
+        TypeInfo.pack(dataType) + dataType.pack(val)
+      end
+    
+      def unpack(bytes, offset = 0)
+        dataType, offset = *TypeInfo.unpack(bytes, offset)
+        if dataType.nil?
+          [nil, offset]
+        else
+          dataType.unpack(bytes, offset)
+        end
+      end
+    end
+    
+  end
+end

data/lib/bytepack/basic.rb

@@ -0,0 +1,43 @@
+module Bytepack
+  class Basic < Struct
+    
+    class << self
+      def preprocess(bytes, offset, format, length = 0)
+        format += length.to_s if !(self <= FixedSize) && length > 1
+        format = offset > 0 ? "@#{offset}#{format}" : format
+        offset += length
+        [offset, format]
+      end
+      
+      def intToBytes(length, value)
+        bitlength = length*8
+        div = nil
+        x = [[32, 'N'], [16, 'n'], [8, 'C']].find {|a| (div = bitlength.divmod(a[0])) && div[0] != 0 && div[1] == 0}
+        b = (2**x[0])-1
+        ([value & b] + (2..div[0]).map {|i| (value >> x[0]*(i-1)) & b}).reverse.pack(x[1]*div[0])
+      end
+    
+      def bytesToInt(length, bytes, offset = 0) # bytes = array of 8-bit unsigned
+        format = "C#{length}"
+        format.prepend("@#{offset}") if offset > 0
+        bytes = bytes.unpack(format)
+        most_significant_bit = 1 << 7
+        negative = (bytes[0] & most_significant_bit) != 0
+        unscaled_value = -(bytes[0] & most_significant_bit) << length*8-8
+        # Clear the highest bit
+        # Unleash the powers of the butterfly
+        bytes[0] &= ~most_significant_bit
+        # Get the 2's complement
+        (0..length-1).each {|i| unscaled_value += bytes[i] << ((length-1 - i) * 8)}
+        unscaled_value * -1 if negative
+        unscaled_value
+      end
+    end
+    
+  end
+end
+
+require 'bytepack/basic/fixed_size'
+require 'bytepack/basic/varbinary'
+require 'bytepack/basic/string'
+require 'bytepack/basic/symbol'

data/lib/bytepack/basic/fixed_size.rb

@@ -0,0 +1,28 @@
+module Bytepack
+  class FixedSize < Basic
+    
+    class << self
+      def pack(val)
+        val ||= self::NULL_INDICATOR
+        [val].pack(self::DIRECTIVE)
+      end
+  
+      def unpack(bytes, offset = 0)
+        offset, format = *preprocess(bytes, offset, self::DIRECTIVE, self::LENGTH)
+        unpacked = bytes.unpack1(format)
+        if unpacked == self::NULL_INDICATOR
+          [nil, offset]
+        else
+          [unpacked, offset]
+        end
+      end
+    end
+    
+  end
+end
+
+require 'bytepack/basic/fixed_size/integer_type'
+require 'bytepack/basic/fixed_size/float'
+require 'bytepack/basic/fixed_size/timestamp' # Date
+require 'bytepack/basic/fixed_size/decimal'
+require 'bytepack/basic/fixed_size/null'

data/lib/bytepack/basic/fixed_size/decimal.rb

@@ -0,0 +1,48 @@
+require 'bigdecimal'
+require 'bigdecimal/util'
+
+module Bytepack
+  class Decimal < FixedSize
+    DIRECTIVE = 'C16'
+    NULL_INDICATOR = -170141183460469231731687303715884105728 # NULL indicator for object type serializations
+    LENGTH = 16
+    PRECISION = 38
+    SCALE = 12
+    
+    class << self
+      def pack(val)
+        (val == self::NULL_INDICATOR || val.nil?) ? intToBytes(self::LENGTH, self::NULL_INDICATOR) : serialize(val)
+      end
+
+      def unpack(bytes, offset = 0)
+        [deserialize(bytes, offset), offset + self::LENGTH]
+      end
+
+      def serialize(val)
+        num = case val
+        when BigDecimal then val
+        else val.to_d
+        end
+        sign, digits, base, exponent = *num.split
+        scale = digits.size - exponent
+        precision = digits.size
+        raise(::ArgumentError, "Scale of this decimal is #{scale} and the max is #{self::SCALE}") if scale > self::SCALE
+        rest = precision - scale
+        raise(::ArgumentError, "Precision to the left of the decimal point is #{rest} and the max is #{self::PRECISION-self::SCALE}") if rest > 26
+        scale_factor = self::SCALE - scale
+        unscaled_int = sign * digits.to_i * base ** scale_factor # Unscaled integer
+        intToBytes(self::LENGTH, unscaled_int)
+      end
+
+      def deserialize(val, offset = 0)
+        unscaled = bytesToInt(self::LENGTH, val, offset)
+        if unscaled != self::NULL_INDICATOR
+          unscaled = unscaled.to_s
+          scaled = unscaled.insert(unscaled.size - self::SCALE, ".")
+          BigDecimal(scaled)
+        end
+      end
+    end
+    
+  end
+end

data/lib/bytepack/basic/fixed_size/float.rb

@@ -0,0 +1,7 @@
+module Bytepack
+  class Float < FixedSize
+    DIRECTIVE = 'G'
+    LENGTH = 8
+    NULL_INDICATOR = -1.7E308 # NULL indicator for object type serializations
+  end
+end

data/lib/bytepack/basic/fixed_size/integer_type.rb

@@ -0,0 +1,18 @@
+module Bytepack
+  class IntegerType < FixedSize
+    # Reserved class
+    
+    class << self
+    end
+    
+  end
+end
+
+require 'bytepack/basic/fixed_size/integer_type/byte'
+require 'bytepack/basic/fixed_size/integer_type/u_byte'
+require 'bytepack/basic/fixed_size/integer_type/short'
+require 'bytepack/basic/fixed_size/integer_type/u_short'
+require 'bytepack/basic/fixed_size/integer_type/integer'
+require 'bytepack/basic/fixed_size/integer_type/u_integer'
+require 'bytepack/basic/fixed_size/integer_type/long'
+require 'bytepack/basic/fixed_size/integer_type/u_long'

data/lib/bytepack/basic/fixed_size/integer_type/byte.rb

@@ -0,0 +1,7 @@
+module Bytepack
+  class Byte < IntegerType
+    DIRECTIVE = 'c'
+    LENGTH = 1
+    NULL_INDICATOR = -128 # NULL indicator for object type serializations
+  end
+end

data/lib/bytepack/basic/fixed_size/integer_type/integer.rb

@@ -0,0 +1,7 @@
+module Bytepack
+  class Integer < IntegerType
+    DIRECTIVE = 'l>'
+    LENGTH = 4
+    NULL_INDICATOR = -2147483648 # NULL indicator for object type serializations
+  end
+end

data/lib/bytepack/basic/fixed_size/integer_type/long.rb

@@ -0,0 +1,7 @@
+module Bytepack
+  class Long < IntegerType
+    DIRECTIVE = 'q>'
+    LENGTH = 8
+    NULL_INDICATOR = -9223372036854775808 # NULL indicator for object type serializations
+  end
+end

data/lib/bytepack/basic/fixed_size/integer_type/short.rb

@@ -0,0 +1,7 @@
+module Bytepack
+  class Short < IntegerType
+    DIRECTIVE = 's>'
+    LENGTH = 2
+    NULL_INDICATOR = -32768 # NULL indicator for object type serializations
+  end
+end

data/lib/bytepack/basic/fixed_size/integer_type/u_byte.rb

@@ -0,0 +1,7 @@
+module Bytepack
+  class UByte < IntegerType # Unsigned
+    DIRECTIVE = 'C'
+    LENGTH = 1
+    NULL_INDICATOR = 0 # NULL indicator for object type serializations
+  end
+end

data/lib/bytepack/basic/fixed_size/integer_type/u_integer.rb

@@ -0,0 +1,7 @@
+module Bytepack
+  class UInteger < IntegerType # Unsigned
+    DIRECTIVE = 'L>'
+    LENGTH = 4
+    NULL_INDICATOR = 0 # NULL indicator for object type serializations
+  end
+end

data/lib/bytepack/basic/fixed_size/integer_type/u_long.rb

@@ -0,0 +1,7 @@
+module Bytepack
+  class ULong < IntegerType # Unsigned
+    DIRECTIVE = 'Q>'
+    LENGTH = 8
+    NULL_INDICATOR = 0 # NULL indicator for object type serializations
+  end
+end

data/lib/bytepack/basic/fixed_size/integer_type/u_short.rb

@@ -0,0 +1,7 @@
+module Bytepack
+  class UShort < IntegerType # Unsigned
+    DIRECTIVE = 'S>'
+    LENGTH = 2
+    NULL_INDICATOR = 0 # NULL indicator for object type serializations
+  end
+end

data/lib/bytepack/basic/fixed_size/null.rb

@@ -0,0 +1,11 @@
+module Bytepack
+  class Null < Byte
+    
+    class << self
+      def pack(*)
+        super(Byte::NULL_INDICATOR)
+      end
+    end
+    
+  end
+end

data/lib/bytepack/basic/fixed_size/timestamp.rb

@@ -0,0 +1,22 @@
+module Bytepack
+  class Timestamp < Long
+    
+    class << self
+      def pack(val)
+        # All dates are represented as Long values. This signed number represents the number of microseconds before or after Jan. 1 1970 00:00:00 GMT, the Unix epoch. Note that the units are microseconds, not milliseconds.
+        val = case val
+        when ::Integer then val
+        when ::Time then val.to_i*1000000 + val.usec # Microseconds
+        end
+        super(val)
+      end
+    
+      def unpack(bytes, offset = 0)
+        unpacked = super(bytes, offset)
+        unpacked[0] = Time.at(unpacked[0]/1000000.to_f) if unpacked[0] # Microseconds
+        unpacked
+      end
+    end
+    
+  end
+end

data/lib/bytepack/basic/string.rb

@@ -0,0 +1,17 @@
+module Bytepack
+  class String < Varbinary
+
+    class << self
+      def unpack(bytes, offset = 0)
+        vb = super(bytes, offset)
+        vb[0] = vb[0].force_encoding("utf-8") unless vb[0].nil?
+        vb
+      end
+    
+      def convert_input(val)
+        val.to_s.encode("utf-8")
+      end
+    end
+  
+  end
+end

data/lib/bytepack/basic/symbol.rb

@@ -0,0 +1,13 @@
+module Bytepack
+  class Symbol < Varbinary
+    
+    class << self
+      def unpack(bytes, offset = 0)
+        vb = super(bytes, offset)
+        vb[0] = vb[0].to_sym unless vb[0].nil?
+        vb
+      end
+    end
+  
+  end
+end

data/lib/bytepack/basic/varbinary.rb

@@ -0,0 +1,34 @@
+module Bytepack
+  class Varbinary < Basic
+    DIRECTIVE = 'a'
+    NULL_INDICATOR = -1 # NULL indicator for object type serializations
+    LENGTH_TYPE = AnyType
+
+    class << self
+      def pack(val)
+        if val.nil?
+          AnyType.pack(self::NULL_INDICATOR)
+        else
+          val = convert_input(val)
+          self::LENGTH_TYPE.pack(val.bytesize) + val
+        end
+      end
+      
+      def unpack(bytes, offset = 0)
+        length, offset = *self::LENGTH_TYPE.unpack(bytes, offset)
+        case length
+        when self::NULL_INDICATOR then [nil, offset]
+        when 0 then ["", offset]
+        else
+          offset, format = *preprocess(bytes, offset, self::DIRECTIVE, length)
+          [bytes.unpack1(format), offset]
+        end
+      end
+        
+      def convert_input(val)
+        val.to_s.encode("ascii-8bit")
+      end
+    end
+    
+  end
+end

data/lib/bytepack/complex.rb

@@ -0,0 +1,9 @@
+module Bytepack
+  class Complex < Struct
+    class << self
+    end
+  end
+end
+
+require 'bytepack/complex/array'
+require 'bytepack/complex/hash'

data/lib/bytepack/complex/array.rb

@@ -0,0 +1,22 @@
+module Bytepack
+  class Array < Complex
+    LENGTH_TYPE = AnyType
+    
+    class << self
+      def pack(array = [])
+        elements_count = array.size
+        self::LENGTH_TYPE.pack(elements_count) + array.map {|val| AnyType.pack(val)}.join
+      end
+    
+      def unpack(bytes, offset = 0)
+        elements_count, offset = *self::LENGTH_TYPE.unpack(bytes, offset)
+        elements = elements_count.times.map do
+          element, offset = *AnyType.unpack(bytes, offset)
+          element
+        end
+        [elements, offset]
+      end
+    end
+    
+  end
+end

data/lib/bytepack/complex/hash.rb

@@ -0,0 +1,17 @@
+module Bytepack
+  class Hash < Complex
+    
+    class << self
+      def pack(hash = {})
+        AnyType.pack(hash.keys) + AnyType.pack(hash.values)
+      end
+    
+      def unpack(bytes, offset = 0)
+        keys, offset = *AnyType.unpack(bytes, offset)
+        values, offset = *AnyType.unpack(bytes, offset)
+        [::Hash[keys.map.with_index {|key, index| [key, values[index]]}], offset]
+      end
+    end
+    
+  end
+end

data/lib/bytepack/compound.rb

@@ -0,0 +1,8 @@
+module Bytepack
+  class Compound < Struct
+    class << self
+    end
+  end
+end
+
+require 'bytepack/compound/single_type_array'

data/lib/bytepack/compound/single_type_array.rb

@@ -0,0 +1,41 @@
+module Bytepack
+  class SingleTypeArray < Compound
+    LENGTH_TYPE = AnyType
+    
+    class << self
+      def pack(val = []) # First element is a data type indicator (Integer, Struct, String/Symbol)
+        array = val[1..-1]
+        dataType = classifyDataType(val[0])
+        unless dataType  # No indicator recognized
+          array = val
+          dataType = autodetect_dataType(array)
+        end
+        TypeInfo.pack(dataType) + self::LENGTH_TYPE.pack(array.size) + array.map {|e| dataType.pack(e)}.join
+      end
+
+      def unpack(bytes, offset = 0)
+        dataType, offset = *TypeInfo.unpack(bytes, offset)
+        if dataType.nil?
+          array = nil
+        else
+          array_size, offset = *self::LENGTH_TYPE.unpack(bytes, offset)
+          array = array_size.times.map do
+            element, offset = *dataType.unpack(bytes, offset)
+            element
+          end
+        end
+        [array, offset]
+      end
+
+      def autodetect_dataType(array)
+        if array[0].is_a?(::Integer)
+          max_int = array.select {|e| e.is_a?(::Integer)}.max
+          packingDataType(max_int)
+        else
+          packingDataType(array[0])
+        end
+      end
+    end
+    
+  end
+end

data/lib/bytepack/custom_data.rb

@@ -0,0 +1,37 @@
+module Bytepack
+  class CustomData < Struct
+    
+    @subclasses = []
+    
+    class << self
+      def inherited(child)
+        @subclasses << child
+      end
+            
+      def subclasses(&block)
+        selected = nil
+        @subclasses.each do |child| # .find() is too slow
+          if yield(child)
+            selected = child
+            break
+          end
+        end
+        selected if block_given?
+      end
+      
+      def struct_by_ruby_type(val)
+        subclasses {|child| val.is_a?(child::RUBY_TYPE)}
+      end
+      
+      def code_by_struct(struct)
+        struct::TYPE_CODE if struct < Struct
+      end
+      
+      def struct_by_code(code)
+        subclasses {|child| child::TYPE_CODE == code}
+      end
+    end
+    
+  end
+  
+end

data/lib/bytepack/extensions.rb

@@ -0,0 +1,18 @@
+module Bytepack
+  module Extensions
+  
+    module CodeValuesHash
+      attr_reader :codes, :code_values
+
+      def inherited(child)
+        child.instance_variable_set(:@codes, Hash[@codes.map {|a| [a[0], a[1].dup]}]) if instance_variable_defined?("@codes")
+      end
+
+      def hash_codes(*arrays)
+        @codes ||= ::Hash[arrays]
+        @code_values ||= ::Hash[arrays.map(&:reverse)]
+      end
+    end
+    
+  end
+end

data/lib/bytepack/type_info.rb

@@ -0,0 +1,34 @@
+module Bytepack
+  class TypeInfo < Byte
+    extend Extensions::CodeValuesHash
+      
+    hash_codes [-99, Array], # ARRAY
+               [-98, SingleTypeArray], # SingleTypeArray
+               [-89, Hash], # Hash
+               [1, Null], # NULL
+               [3, Byte], # TINYINT
+               [4, Short], # SMALLINT
+               [5, Integer], # INTEGER
+               [6, Long], # BIGINT
+               [8, Float], # FLOAT
+               [9, String], # STRING
+               [10, Symbol], # Symbol
+               [11, Timestamp], # TIMESTAMP
+               [22, Decimal], # DECIMAL
+               [25, Varbinary] # VARBINARY
+    
+    class << self
+      def pack(val)
+        val = val.is_a?(::Integer) ? val : code_values[val]||CustomData.code_by_struct(val)
+        super(val)
+      end
+      
+      def unpack(bytes, offset = 0)
+        unpacked = super(bytes, offset)
+        unpacked[0] = codes[unpacked[0]]||CustomData.struct_by_code(unpacked[0]) if unpacked[0]
+        unpacked
+      end
+    end
+    
+  end
+end

data/lib/bytepack/version.rb

@@ -0,0 +1,3 @@
+module Bytepack
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: bytepack
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Valery Kvon
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-05-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.11'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.11'
+description: Packing & unpacking various Ruby data to/from a byte string, incl. arrays,
+  hashes and custom data structures
+email: addagger@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/bytepack.rb
+- lib/bytepack/any_type.rb
+- lib/bytepack/basic.rb
+- lib/bytepack/basic/fixed_size.rb
+- lib/bytepack/basic/fixed_size/decimal.rb
+- lib/bytepack/basic/fixed_size/float.rb
+- lib/bytepack/basic/fixed_size/integer_type.rb
+- lib/bytepack/basic/fixed_size/integer_type/byte.rb
+- lib/bytepack/basic/fixed_size/integer_type/integer.rb
+- lib/bytepack/basic/fixed_size/integer_type/long.rb
+- lib/bytepack/basic/fixed_size/integer_type/short.rb
+- lib/bytepack/basic/fixed_size/integer_type/u_byte.rb
+- lib/bytepack/basic/fixed_size/integer_type/u_integer.rb
+- lib/bytepack/basic/fixed_size/integer_type/u_long.rb
+- lib/bytepack/basic/fixed_size/integer_type/u_short.rb
+- lib/bytepack/basic/fixed_size/null.rb
+- lib/bytepack/basic/fixed_size/timestamp.rb
+- lib/bytepack/basic/string.rb
+- lib/bytepack/basic/symbol.rb
+- lib/bytepack/basic/varbinary.rb
+- lib/bytepack/complex.rb
+- lib/bytepack/complex/array.rb
+- lib/bytepack/complex/hash.rb
+- lib/bytepack/compound.rb
+- lib/bytepack/compound/single_type_array.rb
+- lib/bytepack/custom_data.rb
+- lib/bytepack/extensions.rb
+- lib/bytepack/type_info.rb
+- lib/bytepack/version.rb
+homepage: https://github.com/addagger/bytepack
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Tool for byte-serialization of various Ruby data structures
+test_files: []