scale.rb 0.2.19 → 0.3.0

data/lib/scale/base.rb

@@ -1,7 +1,7 @@
 module Scale
   module Types
 
-    module SingleValue
+    module Base
       attr_reader :value
 
       def initialize(value)
@@ -9,26 +9,28 @@ module Scale
       end
 
       def ==(other)
-        value == other.value
+        self.class == other.class && self.value == other.value
       end
 
       def to_human
         if @value.class == ::Hash
           @value.transform_values do |v|
-            if v.class.included_modules.include?(SingleValue)
+            if v.class.included_modules.include?(Base)
               v.to_human
             else
               v
             end
-          end
+          end.transform_keys(&:to_sym)
         elsif @value.class == ::Array
           @value.map do |v|
-            if v.class.included_modules.include?(SingleValue)
+            if v.class.included_modules.include?(Base)
               v.to_human
             else
               v
             end
           end
+        elsif @value.class.include?(Base)
+          @value.to_human
         else
           @value
         end
@@ -46,9 +48,9 @@ module Scale
       end
     end
 
-    # value: one of nil, false, true, scale object
+    # if value is bool, see type `OptionBool` in types.rb
     module Option
-      include SingleValue
+      include Base
 
       module ClassMethods
         def decode(scale_bytes)
@@ -58,29 +60,23 @@ module Scale
             puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
             new(nil)
           elsif byte == [1]
-            if self::INNER_TYPE_STR == "boolean"
-              puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
-              new(false)
-            else
-              # big process
-              value = Scale::Types.get(self::INNER_TYPE_STR).decode(scale_bytes)
-              puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
-              new(value)
-            end
-          elsif byte == [2]
-            if self::INNER_TYPE_STR == "boolean"
-              puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
-              new(true)
-            else
-              raise "bad data"
-            end
+            # big process
+            type = 
+              if self::INNER_TYPE.class == ::String
+                Scale::Types.get(self::INNER_TYPE)
+              else
+                self::INNER_TYPE
+              end
+            value = type.decode(scale_bytes)
+            puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
+            new(value)
           else
-            raise "bad data"
+            raise BadDataError.new("Bad scale data for #{self::TYPE_NAME}")
           end
         end
 
-        def inner_type(type_str)
-          const_set(:INNER_TYPE_STR, type_str)
+        def inner_type(type)
+          const_set(:INNER_TYPE, type)
         end
       end
 
@@ -93,15 +89,13 @@ module Scale
         if value.nil?
           "00"
         else
-          return "02" if value.class == TrueClass && value === true
-          return "01" if value.class == FalseClass && value === false
           "01" + value.encode
         end
       end
     end
 
     module FixedWidthInt
-      include SingleValue
+      include Base
 
       module ClassMethods
         def decode(scale_bytes)
@@ -129,7 +123,7 @@ module Scale
     end
 
     module FixedWidthUInt
-      include SingleValue
+      include Base
 
       module ClassMethods
         attr_accessor :byte_length
@@ -162,7 +156,7 @@ module Scale
     end
 
     module Struct
-      include SingleValue
+      include Base
       # new(1.to_u32, U32(69))
       module ClassMethods
         def inherited(child)
@@ -171,36 +165,40 @@ module Scale
 
         def decode(scale_bytes)
           puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
-          item_values = self::ITEM_TYPE_STRS.map do |item_type_str|
-            type = Scale::Types.get(item_type_str)
-            type.decode(scale_bytes)
-          end
 
-          value = {}
-          self::ITEM_NAMES.zip(item_values) do |attr, val|
-            value[attr] = val
+          # item_values: 
+          # {
+          #   a: ...,
+          #   b: ...
+          # }
+          item_values = {}
+          self::ITEMS.each_pair do |item_name, item_type|
+            if item_type.class == ::String
+              item_type = Scale::Types.get(item_type)
+            end
+            item_values[item_name] = item_type.decode(scale_bytes)
           end
 
-          result = new(value)
-          value.each_pair do |attr, val|
-            result.send "#{attr}=", val
-          end
-          puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
-          result
-        end
+          # value = {}
+          # self::ITEM_NAMES.zip(item_values) do |attr, val|
+          #   value[attr] = val
+          # end
 
-        def items(items)
-          attr_names = []
-          attr_type_strs = []
+          puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
 
-          items.each_pair do |attr_name, attr_type_str|
-            attr_names << attr_name.to_s.gsub("-", "")
-            attr_type_strs << attr_type_str
+          result = new(item_values)
+          item_values.each_pair do |item_name, item_value|
+            result.send "#{item_name.to_s}=", item_value
           end
 
-          const_set(:ITEM_NAMES, attr_names)
-          const_set(:ITEM_TYPE_STRS, attr_type_strs)
-          attr_accessor *attr_names
+          result
+        end
+
+        # items(a: Scale::Types::Type1, b: "Type2")
+        def items(**items)
+          const_set(:ITEMS, items)
+          item_names = items.keys
+          attr_accessor *item_names
         end
       end
 
@@ -210,29 +208,33 @@ module Scale
       end
 
       def encode
-        [].tap do |result|
-          value.each_pair do |attr_name, attr_value|
-            result << attr_value.encode
-          end
+        value.values.map do |item_value|
+          item_value.encode
         end.join
       end
     end
 
     module Tuple
-      include SingleValue
+      include Base
 
       module ClassMethods
         def decode(scale_bytes)
           puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
-          values = self::TYPE_STRS.map do |type_str|
-            Scale::Types.get(type_str).decode(scale_bytes)
+
+          values = self::INNER_TYPES.map do |type|
+            if type.class == ::String
+              type = Scale::Types.get(type)
+            end
+            type.decode(scale_bytes)
           end
+
           puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
           new(values)
         end
 
-        def inner_types(*type_strs)
-          const_set(:TYPE_STRS, type_strs)
+        # inner_types Scale::Types::U8, "U8"
+        def inner_types(*inner_types)
+          const_set(:INNER_TYPES, inner_types)
         end
       end
 
@@ -246,41 +248,46 @@ module Scale
     end
 
     module Enum
-      include SingleValue
+      include Base
+
+      attr_accessor :index
 
       module ClassMethods
         def decode(scale_bytes)
           puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
           index = scale_bytes.get_next_bytes(1)[0]
-          if const_defined? "ITEM_TYPE_STRS"
-            item_type_str = self::ITEM_TYPE_STRS[index]
-            raise "There is no such member with index #{index} for enum #{self}" if item_type_str.nil?
-            value = Scale::Types.get(item_type_str).decode(scale_bytes)
-          else
+          if const_defined? "ITEMS"
+            type = self::ITEMS.values[index]
+            if type.class == ::String
+              type = Scale::Types.get(type)
+            end
+            value = type.decode(scale_bytes)
+          elsif const_defined? "INNER_TYPES"
+            type = self::INNER_TYPES[index]
+            if type.class == ::String
+              type = Scale::Types.get(type)
+            end
+            value = type.decode(scale_bytes)
+          else # VALUES
             value = self::VALUES[index]
           end
-          result = new(value)
           puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
+          result = new(value)
+          result.index = index
           result
         end
 
-        def items(items)
-          if items.class == ::Hash
-            attr_names = []
-            attr_type_strs = []
-
-            items.each_pair do |attr_name, attr_type_str|
-              attr_names << attr_name
-              attr_type_strs << attr_type_str
-            end
+        # inner_types(Scale::Types::Compact, "Hex")
+        def inner_types(*inner_types)
+          const_set(:INNER_TYPES, inner_types)
+        end
 
-            const_set(:ITEM_NAMES, attr_names)
-            const_set(:ITEM_TYPE_STRS, attr_type_strs)
-          elsif items.class == ::Array
-            const_set(:ITEM_TYPE_STRS, items)
-          end
+        # items(Item1: Scale::Types::Compact, Item2: "Hex")
+        def items(**items)
+          const_set(:ITEMS, items)
         end
 
+        # [1, "hello"]
         def values(*values)
           const_set(:VALUES, values)
         end
@@ -291,17 +298,17 @@ module Scale
       end
 
       def encode
-        if self.class.const_defined? "ITEM_NAMES"
-          value_type_str = value.class.to_s.split("::").last.to_s
-          index = self.class::ITEM_TYPE_STRS.index(value_type_str).to_s(16).rjust(2, "0")
-          index + value.encode
+        if self.class.const_defined? "ITEMS"
+          index.to_s(16).rjust(2, "0") + value.encode
         else
           self.class::VALUES.index(value).to_s(16).rjust(2, "0")
         end
       end
 
       def to_human
-        if self.class.const_defined? "ITEM_TYPE_STRS"
+        if self.class.const_defined? "ITEMS"
+          @value.to_human
+        elsif self.class.const_defined? "INNER_TYPES"
           @value.to_human
         else
           @value
@@ -310,7 +317,7 @@ module Scale
     end
 
     module Vec
-      include SingleValue # value is an array
+      include Base # value is an array
 
       module ClassMethods
         def decode(scale_bytes, raw = false)
@@ -318,16 +325,15 @@ module Scale
           number = Scale::Types::Compact.decode(scale_bytes).value
           items = []
           number.times do
-            type = Scale::Types.get(self::INNER_TYPE_STR)
-            item = type.decode(scale_bytes)
+            item = self::INNER_TYPE.decode(scale_bytes)
             items << item
           end
           puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
           raw ? items : new(items)
         end
 
-        def inner_type(type_str)
-          const_set(:INNER_TYPE_STR, type_str)
+        def inner_type(type)
+          const_set(:INNER_TYPE, type)
         end
       end
 
@@ -346,7 +352,7 @@ module Scale
     end
 
     module Set
-      include SingleValue
+      include Base
 
       module ClassMethods
         def decode(scale_bytes)
@@ -384,7 +390,7 @@ module Scale
     end
 
     module VecU8FixedLength
-      include SingleValue
+      include Base
 
       module ClassMethods
         def decode(scale_bytes)
@@ -421,5 +427,39 @@ module Scale
       end
     end
 
+    module Array
+      include Base
+
+      module ClassMethods
+        def decode(scale_bytes)
+          puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
+          items = (0 ... self::LENGTH).map do |_|
+            self::INNER_TYPE.decode(scale_bytes)
+          end
+          puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
+          new(items)
+        end
+
+        def inner_type(type)
+          const_set(:INNER_TYPE, type)
+        end
+
+        def length(len)
+          const_set(:LENGTH, len)
+        end
+      end
+
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      def encode
+        self.value.map do |item|
+          item.encode
+        end.join
+      end
+    end
+
+
   end
 end

data/lib/scale/block.rb

@@ -2,7 +2,7 @@ module Scale
   module Types
 
     class Extrinsic
-      include SingleValue
+      include Base
       # attr_accessor :address, :signature, :nonce, :era, :extrinsic_hash, :call_index, :params_raw, :params
 
       def self.generate_hash(bytes)
@@ -116,7 +116,7 @@ module Scale
     end
 
     class EventRecords
-      include SingleValue
+      include Base
       
       def self.decode(scale_bytes)
 
@@ -129,7 +129,7 @@ module Scale
     end
 
     class EventRecord
-      include SingleValue
+      include Base
 
       def self.decode(scale_bytes)
         metadata = Scale::TypeRegistry.instance.metadata.value
@@ -211,7 +211,7 @@ module Scale
 
     class LogDigest
       include Enum
-      items %w[Other AuthoritiesChange ChangesTrieRoot SealV0 Consensus Seal PreRuntime]
+      inner_types *%w[Other AuthoritiesChange ChangesTrieRoot SealV0 Consensus Seal PreRuntime]
     end
 
   end

data/lib/scale/trie.rb

@@ -2,7 +2,7 @@ module Scale
   module Types
     
     class TrieNode
-      include SingleValue
+      include Base
       EMPTY = 0
       NIBBLE_PER_BYTE = 2
       BITMAP_LENGTH = 2