scale_rb 0.1.15 → 0.2.0

data/lib/metadata/metadata_v9.rb

@@ -1,100 +1,103 @@
 # frozen_string_literal: true
 
-module Metadata
-  module MetadataV9
-    class << self
-      def get_module(module_name, metadata)
-        metadata._get(:metadata)._get(:v9)._get(:modules).find do |m|
-          m._get(:name) == module_name
+module ScaleRb
+  module Metadata
+    module MetadataV9
+      class << self
+        def get_module(module_name, metadata)
+          metadata._get(:metadata)._get(:v9)._get(:modules).find do |m|
+            m._get(:name) == module_name
+          end
         end
-      end
 
-      def get_storage_item(module_name, item_name, metadata)
-        modula = get_module(module_name, metadata)
-        raise "Module `#{module_name}` not found" if modula.nil?
-        modula._get(:storage)._get(:items).find do |item|
-          item._get(:name) == item_name
+        def get_storage_item(module_name, item_name, metadata)
+          modula = get_module(module_name, metadata)
+          raise "Module `#{module_name}` not found" if modula.nil?
+
+          modula._get(:storage)._get(:items).find do |item|
+            item._get(:name) == item_name
+          end
         end
       end
-    end
 
-    TYPES = {
-      ErrorMetadataV9: {
-        name: 'Text',
-        docs: 'Vec<Text>'
-      },
-      EventMetadataV9: {
-        name: 'Text',
-        args: 'Vec<Type>',
-        docs: 'Vec<Text>'
-      },
-      FunctionArgumentMetadataV9: {
-        name: 'Text',
-        type: 'Type'
-      },
-      FunctionMetadataV9: {
-        name: 'Text',
-        args: 'Vec<FunctionArgumentMetadataV9>',
-        docs: 'Vec<Text>'
-      },
-      MetadataV9: {
-        modules: 'Vec<ModuleMetadataV9>'
-      },
-      ModuleConstantMetadataV9: {
-        name: 'Text',
-        type: 'Type',
-        value: 'Bytes',
-        docs: 'Vec<Text>'
-      },
-      ModuleMetadataV9: {
-        name: 'Text',
-        storage: 'Option<StorageMetadataV9>',
-        calls: 'Option<Vec<FunctionMetadataV9>>',
-        events: 'Option<Vec<EventMetadataV9>>',
-        constants: 'Vec<ModuleConstantMetadataV9>',
-        errors: 'Vec<ErrorMetadataV9>'
-      },
-      StorageEntryMetadataV9: {
-        name: 'Text',
-        modifier: 'StorageEntryModifierV9',
-        type: 'StorageEntryTypeV9',
-        fallback: 'Bytes',
-        docs: 'Vec<Text>'
-      },
-      StorageEntryModifierV9: {
-        _enum: %w[Optional Default Required]
-      },
-      StorageEntryTypeV9: {
-        _enum: {
-          Plain: 'Type',
-          Map: {
-            hasher: 'StorageHasherV9',
-            key: 'Type',
-            value: 'Type',
-            linked: 'bool'
-          },
-          DoubleMap: {
-            hasher: 'StorageHasherV9',
-            key1: 'Type',
-            key2: 'Type',
-            value: 'Type',
-            key2Hasher: 'StorageHasherV9'
+      TYPES = {
+        ErrorMetadataV9: {
+          name: 'Text',
+          docs: 'Vec<Text>'
+        },
+        EventMetadataV9: {
+          name: 'Text',
+          args: 'Vec<Type>',
+          docs: 'Vec<Text>'
+        },
+        FunctionArgumentMetadataV9: {
+          name: 'Text',
+          type: 'Type'
+        },
+        FunctionMetadataV9: {
+          name: 'Text',
+          args: 'Vec<FunctionArgumentMetadataV9>',
+          docs: 'Vec<Text>'
+        },
+        MetadataV9: {
+          modules: 'Vec<ModuleMetadataV9>'
+        },
+        ModuleConstantMetadataV9: {
+          name: 'Text',
+          type: 'Type',
+          value: 'Bytes',
+          docs: 'Vec<Text>'
+        },
+        ModuleMetadataV9: {
+          name: 'Text',
+          storage: 'Option<StorageMetadataV9>',
+          calls: 'Option<Vec<FunctionMetadataV9>>',
+          events: 'Option<Vec<EventMetadataV9>>',
+          constants: 'Vec<ModuleConstantMetadataV9>',
+          errors: 'Vec<ErrorMetadataV9>'
+        },
+        StorageEntryMetadataV9: {
+          name: 'Text',
+          modifier: 'StorageEntryModifierV9',
+          type: 'StorageEntryTypeV9',
+          fallback: 'Bytes',
+          docs: 'Vec<Text>'
+        },
+        StorageEntryModifierV9: {
+          _enum: %w[Optional Default Required]
+        },
+        StorageEntryTypeV9: {
+          _enum: {
+            Plain: 'Type',
+            Map: {
+              hasher: 'StorageHasherV9',
+              key: 'Type',
+              value: 'Type',
+              linked: 'bool'
+            },
+            DoubleMap: {
+              hasher: 'StorageHasherV9',
+              key1: 'Type',
+              key2: 'Type',
+              value: 'Type',
+              key2Hasher: 'StorageHasherV9'
+            }
           }
+        },
+        StorageHasherV9: {
+          _enum: %w[
+            Blake2_128
+            Blake2_256
+            Twox128
+            Twox256
+            Twox64Concat
+          ]
+        },
+        StorageMetadataV9: {
+          prefix: 'Text',
+          items: 'Vec<StorageEntryMetadataV9>'
         }
-      },
-      StorageHasherV9: {
-        _enum: %w[
-          Blake2_128
-          Blake2_256
-          Twox128
-          Twox256
-          Twox64Concat
-        ]
-      },
-      StorageMetadataV9: {
-        prefix: 'Text',
-        items: 'Vec<StorageEntryMetadataV9>'
-      }
-    }.freeze
+      }.freeze
+    end
   end
 end

data/lib/monkey_patching.rb

@@ -2,7 +2,7 @@
 
 # https://www.rubyguides.com/2017/01/read-binary-data/
 class String
-  def to_bytes
+  def _to_bytes
     data = start_with?('0x') ? self[2..] : self
     raise 'Not valid hex string' if data =~ /[^\da-f]+/i
 
@@ -10,11 +10,11 @@ class String
     data.scan(/../).map(&:hex)
   end
 
-  def to_camel
+  def _to_camel
     split('_').collect(&:capitalize).join
   end
 
-  def underscore
+  def _underscore
     gsub(/::/, '/')
       .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
       .gsub(/([a-z\d])([A-Z])/, '\1_\2')
@@ -24,22 +24,22 @@ class String
 end
 
 class Integer
-  def to_bytes(bit_length = nil)
-    return to_s(16).to_bytes unless bit_length
+  def _to_bytes(bit_length = nil)
+    return to_s(16)._to_bytes unless bit_length
 
     hex = to_s(16).rjust(bit_length / 4, '0')
-    hex.to_bytes
+    hex._to_bytes
   end
 
   # unsigned to signed
-  def to_signed(bit_length)
+  def _to_signed(bit_length)
     unsigned_mid = 2**(bit_length - 1)
     unsigned_ceiling = 2**bit_length
     self >= unsigned_mid ? self - unsigned_ceiling : self
   end
 
   # signed to unsigned
-  def to_unsigned(bit_length)
+  def _to_unsigned(bit_length)
     unsigned_mid = 2**(bit_length - 1)
     unsigned_ceiling = 2**bit_length
     raise 'out of scope' if self >= unsigned_mid || self <= -unsigned_mid
@@ -48,48 +48,48 @@ class Integer
   end
 
   # unix timestamp to utc
-  def to_utc
+  def _to_utc
     Time.at(self).utc.asctime
   end
 
   # utc to unix timestamp
-  def from_utc(utc_asctime)
+  def _from_utc(utc_asctime)
     Time.parse(utc_asctime)
   end
 end
 
 class Array
-  def to_hex
-    raise 'Not a byte array' unless byte_array?
+  def _to_hex
+    raise 'Not a byte array' unless _byte_array?
 
     reduce('0x') { |hex, byte| hex + byte.to_s(16).rjust(2, '0') }
   end
 
-  def to_bin
-    raise 'Not a byte array' unless byte_array?
+  def _to_bin
+    raise 'Not a byte array' unless _byte_array?
 
     reduce('0b') { |bin, byte| bin + byte.to_s(2).rjust(8, '0') }
   end
 
-  def to_utf8
-    raise 'Not a byte array' unless byte_array?
+  def _to_utf8
+    raise 'Not a byte array' unless _byte_array?
 
     pack('C*').force_encoding('utf-8')
   end
 
-  def to_uint
-    to_hex.to_i(16)
+  def _to_uint
+    _to_hex.to_i(16)
   end
 
-  def to_int(bit_length)
-    to_uint.to_signed(bit_length)
+  def _to_int(bit_length)
+    _to_uint._to_signed(bit_length)
   end
 
-  def flip
+  def _flip
     reverse
   end
 
-  def byte_array?
+  def _byte_array?
     all? { |e| e >= 0 and e <= 255 }
   end
 end