scale.rb 0.2.16 → 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,62 +9,74 @@ 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
       end
+
+      module ClassMethods
+        def inherited(child)
+          child.const_set(:TYPE_NAME, child.name)
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.const_set(:TYPE_NAME, base.name)
+      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)
+          puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
           byte = scale_bytes.get_next_bytes(1)
           if byte == [0]
+            puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
             new(nil)
           elsif byte == [1]
-            if self::INNER_TYPE_STR == "boolean"
-              new(false)
-            else
-              # big process
-              value = Scale::Types.get(self::INNER_TYPE_STR).decode(scale_bytes)
-              new(value)
-            end
-          elsif byte == [2]
-            if self::INNER_TYPE_STR == "boolean"
-              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
 
@@ -77,21 +89,21 @@ 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)
+          puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
           bytes = scale_bytes.get_next_bytes self::BYTE_LENGTH
           bit_length = bytes.length.to_i * 8
           value = bytes.reverse.bytes_to_hex.to_i(16).to_signed(bit_length)
+          puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
           new(value)
         end
       end
@@ -111,16 +123,21 @@ module Scale
     end
 
     module FixedWidthUInt
-      include SingleValue
+      include Base
 
       module ClassMethods
         attr_accessor :byte_length
 
         def decode(scale_bytes)
+          puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
           bytes = scale_bytes.get_next_bytes self::BYTE_LENGTH
           bytes_reversed = bytes.reverse
           hex = bytes_reversed.reduce("0x") { |hex, byte| hex + byte.to_s(16).rjust(2, "0") }
-          new(hex.to_i(16))
+          result = new(hex.to_i(16))
+
+          puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
+
+          result
         end
       end
 
@@ -139,68 +156,85 @@ module Scale
     end
 
     module Struct
-      include SingleValue
+      include Base
       # new(1.to_u32, U32(69))
       module ClassMethods
+        def inherited(child)
+          child.const_set(:TYPE_NAME, child.name)
+        end
+
         def decode(scale_bytes)
-          item_values = self::ITEM_TYPE_STRS.map do |item_type_str|
-            type = Scale::TypeRegistry.instance.get(item_type_str)
-            type.decode(scale_bytes)
+          puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
+
+          # 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
 
-          value = {}
-          self::ITEM_NAMES.zip(item_values) do |attr, val|
-            value[attr] = val
-          end
+          # value = {}
+          # self::ITEM_NAMES.zip(item_values) do |attr, val|
+          #   value[attr] = val
+          # end
 
-          result = new(value)
-          value.each_pair do |attr, val|
-            result.send "#{attr}=", val
+          puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
+
+          result = new(item_values)
+          item_values.each_pair do |item_name, item_value|
+            result.send "#{item_name.to_s}=", item_value
           end
+
           result
         end
 
-        def items(items)
-          attr_names = []
-          attr_type_strs = []
-
-          items.each_pair do |attr_name, attr_type_str|
-            attr_names << attr_name.to_s.gsub("-", "")
-            attr_type_strs << attr_type_str
-          end
-
-          const_set(:ITEM_NAMES, attr_names)
-          const_set(:ITEM_TYPE_STRS, attr_type_strs)
-          attr_accessor *attr_names
+        # items(a: Scale::Types::Type1, b: "Type2")
+        def items(**items)
+          const_set(:ITEMS, items)
+          item_names = items.keys
+          attr_accessor *item_names
         end
       end
 
       def self.included(base)
         base.extend ClassMethods
+        base.const_set(:TYPE_NAME, base.name)
       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)
-          values = self::TYPE_STRS.map do |type_str|
-            Scale::Types.get(type_str).decode(scale_bytes)
+          puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
+
+          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
 
@@ -214,38 +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
-          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
@@ -256,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
@@ -275,22 +317,23 @@ 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)
+          puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
           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
 
@@ -309,14 +352,16 @@ module Scale
     end
 
     module Set
-      include SingleValue
+      include Base
 
       module ClassMethods
         def decode(scale_bytes)
-          value = "Scale::Types::U#{self::BYTE_LENGTH * 8}".constantize.decode(scale_bytes).value
+          puts "  BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
+          value = "Scale::Types::U#{self::BYTE_LENGTH * 8}".constantize2.decode(scale_bytes).value
           return new [] unless value || value <= 0
 
           result = self::ITEMS.select { |_, mask| value & mask > 0 }.keys
+          puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
           new result
         end
 
@@ -340,23 +385,26 @@ module Scale
 
       def encode
         value = self.class::ITEMS.select { |key, _| self.value.include?(key) }.values.sum
-        "Scale::Types::U#{self.class::BYTE_LENGTH * 8}".constantize.new(value).encode
+        "Scale::Types::U#{self.class::BYTE_LENGTH * 8}".constantize2.new(value).encode
       end
     end
 
     module VecU8FixedLength
-      include SingleValue
+      include Base
 
       module ClassMethods
         def decode(scale_bytes)
+          puts "  BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
           byte_length = self::BYTE_LENGTH
           raise "#{self.name} byte length is wrong: #{byte_length}" unless %w[2 3 4 8 16 20 32 64 128 256].include?(byte_length.to_s)
 
           bytes = scale_bytes.get_next_bytes(byte_length)
           str = bytes.pack("C*").force_encoding("utf-8")
           if str.valid_encoding?
+            puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
             new str
           else
+            puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
             new bytes.bytes_to_hex
           end
         end
@@ -379,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