solidity-typed 0.1.0

data/lib/solidity/typed/struct_builder.rb

@@ -0,0 +1,145 @@
+
+module Types
+class Struct
+
+  
+# todo/fix:  scope: keep empty by default
+
+def self.build_class( class_name, scope: Types, **attributes )
+
+ ## todo/fix:
+ ##    add  self.class.type  class method
+ ##                returns  TypedStruct<> instance with typedef info
+ ##
+ ##  add name & format
+ ##   e.g.  :struct (why? why not? or :tuple? if using abi names?)
+ ##              tuple( types,... ) - flattend (recursive)!!! - why? why not?
+
+
+ ## todo/fix:
+ ## check if valid class_name MUST start with uppercase letter etc.
+ ##  todo/fix: check if constant is undefined in scoped namespace!!!!
+
+   ## map type symbols (:uint, :address, etc.)
+   ##   to type for now "by hand" here
+
+   attributes = attributes.map do |key,type|
+  ##                t  =type 
+                  ## t = t.type             if t.is_a?( Class ) && t.ancestors.include?( Typed )
+                  [key, typeof( type )]
+                end.to_h
+
+
+  klass = Class.new( Struct ) do
+    attributes.each do |key,type|
+      define_method( key ) do
+        instance_variable_get( "@#{key}" )
+      end
+      ## note: for Bool auto-add getter with question mark (e.g. voted? etc.)
+      ##          why? why not?
+      if type == BoolType.instance  
+        define_method( "#{key}?" ) do
+          instance_variable_get( "@#{key}" )
+        end
+      end
+      define_method( "#{key}=" ) do |value|
+        ## todo/fix:
+        ## check if arg is typed && type match?
+        ##  if not (assume literal) try to convert to type!!!! 
+
+        value = if value.is_a?(Typed)
+                  ## fix-fix-fix - check type match here!!!
+                  value
+              else 
+                type.new( value )
+              end
+
+        instance_variable_set( "@#{key}", value )
+      end
+    end
+
+
+ 
+    
+    alias_method :old_freeze, :freeze   # note: store "old" orginal version of freeze
+    define_method( :freeze ) do
+      old_freeze    ## same as calling super
+      attributes.keys.each do |key|
+        instance_variable_get( "@#{key}" ).freeze
+      end
+      self   # return reference to self
+    end
+  end
+
+
+  type = StructType.new( class_name, klass )
+  klass.define_singleton_method( :type ) do
+    @type ||= type       
+  end
+
+  ## add attributes (with keys / types) class method 
+  klass.define_singleton_method( :attributes ) do
+     attributes 
+  end
+
+  ## add self.new too - note: call/forward to "old" orginal self.new of Event (base) class
+  klass.define_singleton_method( :new ) do |*args, **kwargs|
+    if kwargs.size > 0  ## assume kwargs 
+      ## -fix-fix-fix- check all keywords if part or struct here too!!!
+      old_new( **kwargs )    
+    else
+      if args.empty?  ## no args - use new_zero and set (initialize) all ivars to zero
+        new_zero
+      else
+        if args.size != attributes.size
+          ## check for required args/params - all MUST be passed in!!!
+          raise ArgumentError, "[Struct] wrong number of arguments for #{name}.new - #{args.size} for #{attributes.size}"
+        end
+        old_new( *args )
+      end
+    end
+  end
+
+
+  klass.define_singleton_method( :new_zero ) do
+    values = attributes.values.map do |type|
+      if type.respond_to?( :new_zero )
+        type.new_zero
+      else
+        raise ArgumentError, "[Struct] no new_zero support for type #{type}; sorry"
+      end
+    end
+    old_new( *values )
+  end
+
+
+=begin
+  ## note: use Kernel for "namespacing"
+  ##   make all enums convenience converters (always) global
+  ##     including uppercase methods (e.g. State(), Color(), etc.) does NOT work otherwise (with other module includes)
+
+  ## add global "Kernel" convenience converter function
+  ##  e.g. Vote(0) is same as Vote.convert(0)
+  Kernel.class_eval( <<RUBY )
+    def #{class_name}( arg )
+       #{class_name}.convert( arg )
+    end
+RUBY
+=end
+
+ ## note: use scoped (module) and NOT Object for namespacing
+ ##   use include Safe to make all structs global
+ ##  fix-fix-fix - make class_name unique across contracts (e.g. reuse same name in different contract)
+  scope.const_set( class_name, klass )   ## returns klass (plus sets global constant class name)
+end # method build_class
+
+
+
+class << self
+  alias_method :old_new, :new       # note: store "old" orginal version of new
+  alias_method :new,     :build_class    # replace original version with create
+end
+  
+
+end # class Struct
+end  # module Types

data/lib/solidity/typed/typed.rb

@@ -0,0 +1,114 @@
+
+=begin
+class Object   ### move to core_ext/object - why? why not?
+  ## check -  add scoped class here too - why? why not?
+  ##           e.g. is_a?( Typed ) || is_a?( ContractBase )
+  ##             or add a TypedContract delagate class or such - why? why not?
+  ##    fix - check for class has singelton method type - why? why not?
+  def typed?() is_a?( Typed ); end
+end
+=end
+
+
+
+module Types
+
+
+##
+# note:
+#  use class Typed as namespace  for metatypes e.g. Type, StringType, AddressType,
+#     the idea is to avoid confusion about metatypes and typed classes
+#           by "hiding" metatypes from top-level (inside typed)
+
+class Typed 
+
+
+  ### use like:
+  ##    Typed.serialize( obj ) or
+  ##    Typed.dump( obj )
+  ##  keep serialize/dump here in Typed - why? why not?
+  def self.serialize( obj )
+     obj.as_data
+  end
+  class << self
+      alias_method :dump, :serialize
+  end
+
+
+
+  def self.type      
+    raise "no required typed class accessor/ getter method defined for Typed subclass #{self.class.name}; sorry"
+  end
+  def type() self.class.type; end
+
+  def as_data   ## kind of like as_json (in rails/ActiveModel/Serializers/JSON/as_json)
+    raise "no required as_data method defined for Typed subclass #{self.class.name}; sorry"
+  end
+
+  
+  ## keep serialize and/or as_json - why? why not?
+  def serialize() as_data; end
+  def as_json()   as_data; end
+
+=begin
+  def as_json( args={} )  serialize; end
+  def serialize      
+    raise "no required serialize method defined for Typed subclass #{self.class.name}; sorry"
+  end  
+
+  def deserialize( serialized_value )  replace( serialized_value ); end
+  def replace( new_value )      
+    raise "no required replace method defined for Typed subclass #{self.class.name}; sorry"
+  end 
+=end 
+end  # class Typed
+
+
+## add value & reference type base - why? why not?
+class TypedValue < Typed
+    
+  ## todo/check: make "internal" value (string/integer) available? why? why not?
+  ##  attr_reader :value   
+
+  ## todo/check -- use self.zero or such - why? why not?
+  def as_data() @value; end  
+
+  def pretty_print( printer ) printer.text( "<val #{type}:#{@value.inspect}>" ); end
+
+  def to_s
+    if @value.is_a?(::String) || @value.is_a?(::Integer)
+      @value.to_s
+    else
+      raise "no string conversion of value possible; sorry"
+    end
+  end
+
+      def ==(other)
+        other.is_a?(self.class) &&
+        type   == other.type &&     ## note: type for no redundant (always the same if same class AND TypedValue)
+        @value == other.instance_variable_get( :@value )    ## compare value via as_data!!!
+      end
+      
+      def hash()       [@value, type].hash; end
+      ## todo/check - hash == other.hash is default any way??
+      def eql?(other)  hash == other.hash;  end
+end  # TypedValue
+
+
+
+class TypedReference < Typed
+
+  
+    def ==(other)
+        other.is_a?(self.class) &&
+        type  == other.type &&
+        @data == other.instance_variable_get( :@data ) 
+    end
+      
+    def hash()       [@data, type].hash; end
+    ## todo/check - hash == other.hash is default any way??
+    ##                 or is it object_id == other.object_id ????
+    def eql?(other)  hash == other.hash;  end
+end 
+
+end  # module Types  

data/lib/solidity/typed/values.rb

@@ -0,0 +1,113 @@
+module Types
+
+
+
+
+class String < TypedValue
+  def self.type() StringType.instance; end  
+  def self.zero() @zero ||= new; end
+  def zero?() @value.empty?; end
+
+
+  def initialize( initial_value = STRING_ZERO )
+    ## was: initial_value ||= type.zero
+    ##     check if nil gets passed in - default not used?  
+
+    raise ArgumentError, "expected literal of type #{type}; got typed #{initial_value.pretty_print_inspect}"    if initial_value.is_a?( Typed )
+    
+    @value = type.check_and_normalize_literal( initial_value )
+    @value.freeze  ## freeze here - why? why not?
+    @value
+  end
+
+
+  extend Forwardable   ## pulls in def_delegator
+  ## add more String forwards here!!!!
+  ##   fix!! - wrap returned values in typed value!!!
+  ##                use type_cast_to_literal or such - why? why not?
+  def_delegators :@value, :downcase, 
+                          :index, :include?,
+                          :+
+
+  def to_str() @value; end  ## "automagilally" support implicit string conversion - why? why not?
+end   # class String
+
+
+
+class Address < TypedValue
+  def self.type() AddressType.instance; end  
+  def self.zero() @zero ||= new; end
+  def zero?() @value == ADDRESS_ZERO; end
+
+  
+   def initialize( initial_value = ADDRESS_ZERO )
+      ## was: initial_value ||= type.zero
+      ##     check if nil gets passed in - default not used?  
+
+      raise ArgumentError, "expected literal of type #{type}; got typed #{initial_value.pretty_print_inspect}"    if initial_value.is_a?( Typed )
+      
+      @value = type.check_and_normalize_literal( initial_value )  
+      @value.freeze  ## freeze here - why? why not?
+      @value
+   end
+end  # class Address
+
+
+class InscriptionId < TypedValue
+    def self.type() InscriptionIdType.instance; end  
+    def self.zero() @zero ||= new; end
+    def zero?() @value == INSCRIPTION_ID_ZERO; end
+
+    def initialize( initial_value = INSCRIPTION_ID_ZERO )
+      ##  was: nitial_value ||= type.zero
+      ##     check if nil gets passed in - default not used?  
+
+      raise ArgumentError, "expected literal of type #{type}; got typed #{initial_value.pretty_print_inspect}"    if initial_value.is_a?( Typed )    
+      
+      @value = type.check_and_normalize_literal( initial_value ) 
+      @value.freeze  ## freeze here - why? why not?
+      @value   
+    end 
+end  # class InscriptionId
+
+
+
+class Bytes32 < TypedValue
+  def self.type() Bytes32Type.instance; end  
+  def self.zero() @zero ||= new; end
+  def zero?()  @value == BYTES32_ZERO; end
+
+  def initialize( initial_value = BYTES32_ZERO )
+     ## was: initial_value ||= type.zero
+     ##     check if nil gets passed in - default not used?  
+
+     raise ArgumentError, "expected literal of type #{type}; got typed #{initial_value.pretty_print_inspect}"    if initial_value.is_a?( Typed )    
+      
+     @value = type.check_and_normalize_literal( initial_value )
+     @value.freeze  ## freeze here - why? why not?
+     @value   
+  end
+end  # class Bytes32
+
+
+class Bytes < TypedValue
+  def self.type() BytesType.instance; end  
+  def self.zero()  @zero ||= new; end
+  def zero?()  @value == BYTES_ZERO; end
+
+  def initialize( initial_value = BYTES_ZERO )
+    ## was: initial_value ||= type.zero
+    ##     check if nil gets passed in - default not used?  
+
+    raise ArgumentError, "expected literal of type #{type}; got typed #{initial_value.pretty_print_inspect}"    if initial_value.is_a?( Typed )    
+      
+    @value = type.check_and_normalize_literal( initial_value )  
+    @value.freeze  ## freeze here - why? why not?
+    @value
+   end
+end  # class Bytes
+
+
+
+end  # module Types
+ 

data/lib/solidity/typed/version.rb

@@ -0,0 +1,23 @@
+module Solidity
+  module Module
+    module Typed
+      MAJOR = 0
+      MINOR = 1
+      PATCH = 0
+      VERSION = [MAJOR,MINOR,PATCH].join('.')
+    
+      def self.version
+        VERSION
+      end
+    
+      def self.banner
+        "solidity-typed/#{VERSION} on Ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) [#{RUBY_PLATFORM}] in (#{root})"
+      end
+    
+      def self.root
+        File.expand_path( File.dirname(File.dirname(File.dirname(File.dirname(__FILE__)))) )
+      end
+    
+    end # module Typed
+  end # module Module
+end # module Solidity

data/lib/solidity/typed.rb

@@ -0,0 +1,128 @@
+
+
+require 'forwardable'  ## def_delegate
+
+
+##
+###  add more erros - why? why not?
+class ValueError < StandardError; end
+## if type is ok, but value of type not in range (e.g. uint with negative numbers)
+##    or maybe enum out-of-range - why? why not? 
+
+
+
+
+
+## forward declare contract base (from solidity)
+##    for type checking
+class ContractBase 
+end
+   
+
+
+## our own code
+require_relative 'typed/version'
+require_relative 'typed/metatypes/types'
+require_relative 'typed/metatypes/bool'
+require_relative 'typed/metatypes/literals'
+require_relative 'typed/metatypes/array'
+require_relative 'typed/metatypes/mapping'
+
+
+require_relative 'typed/typed'
+require_relative 'typed/bool'
+require_relative 'typed/values'
+require_relative 'typed/numbers'
+
+require_relative 'typed/array'
+require_relative 'typed/array_builder'
+require_relative 'typed/mapping'
+require_relative 'typed/mapping_builder'
+
+require_relative 'typed/struct'
+require_relative 'typed/struct_builder'
+require_relative 'typed/event'
+require_relative 'typed/event_builder'
+
+
+require_relative 'typed/enum'
+require_relative 'typed/enum_builder'
+
+require_relative 'typed/conversion'
+
+
+
+#############
+# convenience helpers
+
+##  note: Bool is now (global) "monkey-patched" - no longer a wrapper
+## TypedBool           = Types::Bool
+
+
+TypedString         = Types::String
+TypedAddress        = Types::Address 
+TypedInscriptionId  = Types::InscriptionId
+TypedBytes32        = Types::Bytes32
+TypedBytes          = Types::Bytes
+TypedUInt           = Types::UInt
+TypedInt            = Types::Int
+TypedTimestamp      = Types::Timestamp
+TypedTimedelta      = Types::Timedelta
+
+TypedArray          = Types::Array
+TypedMapping        = Types::Mapping
+TypedEnum           = Types::Enum
+TypedStruct         = Types::Struct
+TypedEvent          = Types::Event
+
+T = Types   ## make T an alias for Types - why? why not?
+
+
+
+####
+##  (global) convenience helper to get type
+##
+##  use a different name 
+##     e.g. typedef( obj ) or
+##          typedclass_to_type( obj ) or
+##           Type( obj ) or type() ??
+def typeof( obj )
+    ## case 1) already a metatype?
+    return obj         if obj.is_a?( Types::Typed::Type )
+    ## case 2a) check for (typed) class
+    ##    check for Typed ancestor in class - why? why not?
+    ##     e.g.    obj.ancestors.include?( Types::Typed )
+    ##      2b)  Bool module
+    return obj.type    if obj.instance_of?( Class ) && obj.respond_to?( :type ) 
+    return obj.type    if obj == Bool   ## special case for module Bool!!!
+  
+##   support plain objects too here - why? why not?     
+##   -- check for "plain objects"
+##      return obj.class.type    if obj.class.respond_to?( :type )
+    
+   raise ArgumentError, "metatype or typedclass expected; got #{obj.inspect}"                                                                                 
+end
+  
+
+
+
+
+# "sandbox helper"
+ module Sandbox
+  include Types
+ end
+#
+## use like:
+##   module Sandbox
+##           str = String.new
+##           Array‹String› = Array.new( String )
+##           ary = Array‹String›.new
+##           ...
+##
+##     to access "old/classic" string or array use:
+##        str = ::String.new
+##        ary = ::Array.new
+##   end
+
+
+puts Solidity::Module::Typed.banner    ## say hello

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: solidity-typed
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Gerald Bauer
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-10-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+- !ruby/object:Gem::Dependency
+  name: hoe
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+description: solidity-typed - "zero-dependency" 100%-solidity compatible data type
+  and application binary interface (abi) machinery incl. bool, (frozen) string, address,
+  bytes, uint, int, enum, struct, array, mapping, event, and more for solidity-inspired
+  contract (blockchain) programming languages incl. rubidity et al
+email: gerald.bauer@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- CHANGELOG.md
+- Manifest.txt
+- README.md
+files:
+- CHANGELOG.md
+- Manifest.txt
+- README.md
+- Rakefile
+- lib/solidity/typed.rb
+- lib/solidity/typed/array.rb
+- lib/solidity/typed/array_builder.rb
+- lib/solidity/typed/bool.rb
+- lib/solidity/typed/conversion.rb
+- lib/solidity/typed/enum.rb
+- lib/solidity/typed/enum_builder.rb
+- lib/solidity/typed/mapping.rb
+- lib/solidity/typed/mapping_builder.rb
+- lib/solidity/typed/metatypes/array.rb
+- lib/solidity/typed/metatypes/bool.rb
+- lib/solidity/typed/metatypes/literals.rb
+- lib/solidity/typed/metatypes/mapping.rb
+- lib/solidity/typed/metatypes/types.rb
+- lib/solidity/typed/numbers.rb
+- lib/solidity/typed/struct.rb
+- lib/solidity/typed/struct_builder.rb
+- lib/solidity/typed/typed.rb
+- lib/solidity/typed/values.rb
+- lib/solidity/typed/version.rb
+homepage: https://github.com/s6ruby/rubidity
+licenses:
+- Public Domain
+metadata: {}
+post_install_message:
+rdoc_options:
+- "--main"
+- README.md
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: solidity-typed - "zero-dependency" 100%-solidity compatible data type and
+  application binary interface (abi) machinery incl. bool, (frozen) string, address,
+  bytes, uint, int, enum, struct, array, mapping, event, and more for solidity-inspired
+  contract (blockchain) programming languages incl. rubidity et al
+test_files: []