solidity-typed 0.1.0

data/lib/solidity/typed/conversion.rb

@@ -0,0 +1,52 @@
+###
+# add global type conversion functions here
+#
+#    include via Kernel module - why? why not?
+
+
+module ConversionFunctions
+#####
+#  todo/check:   use AddressType.try_convert( literal_or_obj ) or such - why? why not?
+def address( literal=0 )
+    ## hack for now support  address(0) 
+    ##  todo/fix:  address( '0x0' ) too!!!!
+    return Types::Typed::AddressType.instance.zero   if literal.is_a?(::Integer) && literal == 0
+
+    Types::Typed::AddressType.instance.check_and_normalize_literal( literal )
+end  # methdod address 
+
+
+=begin
+def uint( obj=0 )
+    ## check if typed?
+   ## raise exception on error
+end
+=end
+
+
+
+=begin  
+  def string(i)
+    if i.is_a?(TypedVariable) && i.type.is_value_type?
+      return TypedVariable.create(:string, i.value.to_s)
+    else
+      raise "Input must be typed"
+    end
+  end
+  
+  def address(i)
+    return TypedVariable.create(:address) if i == 0
+
+    if i.is_a?(TypedVariable) && i.type == Type.create(:addressOrDumbContract)
+      return TypedVariable.create(:address, i.value)
+    end
+    
+    raise "Not implemented"
+  end
+=end
+
+end  # module ConversionFunctions
+  
+
+
+Kernel.include( ConversionFunctions )

data/lib/solidity/typed/enum.rb

@@ -0,0 +1,116 @@
+###############################
+## base class for enum
+#
+#
+#  notes on enum:
+#    do NOT ever create new typed enums with new/create!!!!
+#        only create zeros with new_zero!!!!!
+#     otherwise always reuse and assign CONSTANTS!!!!
+##
+##  todo - fix-fix-fix - enforce rules in code here - why? why not?
+##              make new private or such - why? why not?
+##                          check TrueClass|FalseClass as example - why? why not?
+
+## for bool and enum
+##   use TypedData  - only allow assignment of existing instances
+##                            no NEW possible!!!
+##                     thus - deserialize has a switch for TypedData!!
+
+module Types
+class Enum  < Typed
+
+  def self.zero() members[0]; end
+  def zero?() self == self.class.zero; end  ## note: use compare by identity (object_id) and NOT value e.g. 0
+
+
+  ## return a new Enum read-only class
+  attr_reader :key
+  attr_reader :value
+
+
+  def initialize( key, value )
+    @key   = key
+    @value = value
+    self.freeze   ## make "immutable"
+    self
+  end
+
+  def self._typecheck_enum!( o )
+    if o.instance_of?( self )
+      o
+    else
+      raise TypeError.new( "[enum] enum >#{name}< type expected; got >#{o.class.inspect}<" )
+    end
+  end
+  def _typecheck_enum!( o ) self.class._typecheck_enum!( o ); end
+
+
+  def ==( other )
+    if other.is_a?( Integer ) && other == 0   ## note: only allow compare by zero (0) integer - why? why not?
+      @value == 0
+    else
+      @value == _typecheck_enum!( other ).value
+    end
+  end
+  ##   keep eql?  compare by object_id(entity) - why? why not?
+  ### alias_method :eql?, :==
+
+
+  def self.keys
+    @keys ||= members.map {|member| member.key}.freeze
+    @keys
+  end
+
+  def self.key( key )
+    ## note: returns nil now for unknown keys
+    ##   use/raise IndexError or something - why? why not?
+    @hash_by_key ||= Hash[ keys.zip( members ) ].freeze
+    @hash_by_key[key]
+  end
+
+  class << self
+    alias_method :[], :key    ## convenience alias for key
+  end
+
+  def self.values
+    @values ||= members.map {|member| member.value}.freeze
+    @values
+  end
+
+  def self.value( value )
+    ## note: returns nil now for unknown values
+    ##   use/raise IndexError or something - why? why not?
+    @hash_by_value ||= Hash[ values.zip( members ) ].freeze
+    @hash_by_value[value]
+  end
+
+  def self.min()  members[0]; end
+  def self.max()  members[-1]; end
+
+  def self.size() keys.size; end
+  class << self
+    alias_method :length, :size   ## alias (as is the ruby tradition)
+  end
+
+  def self.convert( arg )
+    ## todo/check: support keys too - why? why not?
+    ## e.g. Color(0), Color(1)
+    ##      Color(:red), Color(:blue) - why? why not?
+    ## note: will ALWAYS look-up by (member) index and NOT by value (integer number value might be different!!)
+    members[ arg ]
+  end
+
+  ## add to_i, to_int - why? why not?
+  def to_i()       @value; end
+  def to_int()     @value; end      ## allows Integer( .. )
+
+  ## add to_b/to_bool support (see safebool @ https://github.com/s6ruby/safebool) - why? why not?  
+  # def parse_bool() @value != 0; end   ## nonzero == true, zero == false like numbers
+
+   def as_data() @value; end
+
+  def pretty_print( printer ) 
+    printer.text( "<val #{type}:#{@key}(#{@value})>" ); 
+  end
+end  # class Enum
+end  #   module Types

data/lib/solidity/typed/enum_builder.rb

@@ -0,0 +1,101 @@
+
+module Types
+class Enum
+
+###################
+##  meta-programming "macro" - build class (on the fly)
+#
+# todo/fix:  scope: keep empty by default
+
+
+
+def self.build_class( class_name, *args, scope: Types )
+  if args.size > 0
+    ## e.g. :Color, :red, :green, :blue
+    ##         or
+    ##      :Color, [:red, :green, :blue]
+    ##   note: start counting a zero (0) !!!
+    keys   = args
+    values = (0...keys.size).to_a   # note: use ... (exclusive) range
+    e = Hash[ keys.zip( values ) ]
+  else
+     raise ArgumentError, "[enum] no members declared - min. one member required; got #{args}; sorry"
+  end
+
+  ## todo/fix:
+  ##  check class name MUST start with uppercase letter
+
+  ## check if all keys are symbols and follow the ruby id(entifier) naming rules
+  ##   todo/check - allow uppercase fist A-Z letters - why? why not?
+  e.keys.each do |key|
+    if key.is_a?( Symbol ) && key =~ /\A[a-z][a-zA-Z0-9_]*\z/
+    else
+      raise ArgumentError.new( "[enum] members to enum must be all symbols following the ruby/solidity id naming rules; >#{key}< failed" )
+    end
+  end
+
+  klass = Class.new( Enum )
+
+ 
+  ## add self.new too - note: call/forward to "old" orginal self.new of Event (base) class
+  klass.define_singleton_method( :new ) do |*new_args|
+      raise ArgumentError, "enum #{klass.name} - do NOT call new EVER; reuse existing enum members! sorry"
+  end
+  ## make new - private too - why? why not?
+
+
+  e.each do |key,value|
+    klass.class_eval( <<RUBY )
+      #{key.upcase} = old_new( :#{key}, #{value} )
+
+      def #{key}?
+        self == #{key.upcase}
+      end
+
+      def self.#{key}
+        #{key.upcase}
+      end
+RUBY
+  end
+
+  klass.class_eval( <<RUBY )
+    def self.members
+      @members ||= [#{e.keys.map {|key|key.upcase}.join(',')}].freeze
+    end
+RUBY
+
+
+  type = EnumType.new( class_name, klass )
+  klass.define_singleton_method( :type ) do
+    @type ||= type       
+  end
+
+=begin
+  ## note: use Kernel for "namespacing"
+  ##   make all enums Kernel convenience converters (always) global
+  ##     including uppercase methods (e.g. State(), Color(), etc.) does NOT work otherwise (with other module includes)
+
+  ## add global convenience converter function
+  ##  e.g. State(0) is same as State.convert(0)
+  ##       Color(0) is same as Color.convert(0)
+  Kernel.class_eval( <<RUBY )
+    def #{class_name}( arg )
+       #{class_name}.convert( arg )
+    end
+RUBY
+=end
+  ## note: use scoped(class) and NO Object for namespacing
+  scope.const_set( class_name, klass )   ## returns klass (plus sets global constant class name)
+  klass
+end
+
+
+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 Enum
+end   # module Types

data/lib/solidity/typed/mapping.rb

@@ -0,0 +1,108 @@
+
+module Types
+class Mapping < TypedReference
+
+    def self.zero() @zero ||= new; end 
+    def zero?()  @data.empty? end  
+
+    ## add short-cut helpers why? why not?
+    def key_type() self.class.type.key_type; end
+    def value_type() self.class.type.value_type; end
+
+    ## todo/check: make "internal" data/hash available? why? why not?
+    ## attr_reader :data   
+
+    def initialize( initial_value = {} )
+      ## was: initial_value ||= {}             
+      ##     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 )    
+ 
+        @data =     type.check_and_normalize_literal( initial_value ).map do |key, value|
+                        [
+                          type.key_type.new( key ),
+                          type.value_type.new( value )
+                        ]
+                      end.to_h
+    end
+
+
+  extend Forwardable   ## pulls in def_delegator
+  ## add more Hash forwards here!!!!
+  def_delegators :@data, :size, :empty?, :clear
+
+
+
+  def [](key)
+    puts "[debug] Mapping#[]( #{key} )"
+    key_var =  key.is_a?( Typed ) ? key : key_type.new( key )
+    obj = @data[key_var]
+
+    ## was:
+    ## if value_type.mapping? && obj.nil?
+    ##  obj = 
+    ##  @data[key_var] = obj
+    ## end
+    ##
+    ## note:
+    ##  change to 
+    ## allow access to ref to struct and than update change to assign !!=!!!!!!
+  
+    if obj.nil?
+      obj = value_type.new_zero
+      @data[ key_var ] = obj
+    end
+
+    obj 
+  end
+
+
+
+  def []=(key, new_value)
+    puts "[debug] Mapping#[]=( #{key}:#{key.class.name}, #{new_value}:#{new_value.class.name})"
+    pp type.key_type
+    key_var = key.is_a?( Typed ) ? key : key_type.new( key )
+    pp key_var
+    obj     = new_value.is_a?( Typed ) ? new_value : value_type.new( new_value )
+    pp obj
+
+    if value_type.mapping?
+      ## val_var = Proxy.new(keytype: valuetype.keytype, valuetype: valuetype.valuetype)
+      raise 'What?'
+    end
+
+    @data[key_var] = obj
+  end
+
+
+  def key?( key )
+    key_var =  key.is_a?( Typed ) ? key : key_type.new( key )
+    @data.key?( key_var )
+  end
+  alias_method :has_key?, :key?  
+
+  def delete( key )
+    key_var =  key.is_a?( Typed ) ? key : key_type.new( key )
+    @data.delete( key_var )
+  end
+
+  
+  ## note: pass through value!!!!
+  ##   in new scheme - only "plain" ruby arrays/hash/string/integer/bool used!!!!
+  ##    no wrappers!!! - no need to convert!!!
+  def as_data
+    puts "[debug] Mapping#as_data"
+    @data.reduce({}) do |h, (k, v)|
+      ## todo/fix:
+      ##   check if value is zero/ do not serialize zero - why? why not?
+        h[k.as_data] = v.as_data
+        h
+    end
+  end
+
+  def pretty_print( printer ) 
+    printer.text( "<ref #{type}:#{@data.pretty_print_inspect}>" ); 
+  end
+end  # class Mapping
+end  # module Types
+

data/lib/solidity/typed/mapping_builder.rb

@@ -0,0 +1,54 @@
+
+module Types
+
+class Mapping
+
+def self.build_class( key_type, value_type )
+
+    # key_type   = Type.create( key_type )    if key_type.is_a?( Symbol ) ||
+    #                                            key_type.is_a?( String )
+    # value_type = Type.create( value_type )  if value_type.is_a?( Symbol ) ||
+    #                                            value_type.is_a?( String )
+    # key_type   = key_type.type     if key_type.is_a?( Class ) && key_type.ancestors.include?( Typed )
+    # value_type = value_type.type   if value_type.is_a?( Class ) && value_type.ancestors.include?( Typed )
+
+    key_type   = typeof( key_type )
+    value_type = typeof( value_type ) 
+
+    type = MappingType.instance( key_type, value_type )
+
+    class_name =  type.typedclass_name
+  
+    ## note: keep a class cache
+    ##  note: klasses may have different init sizes (default 0)
+    cache           = @@cache ||= {}
+    klass           = cache[ class_name ]
+    ## fix-fix-fix - check if const klass defined for cache (no cache needed)!!!!!!!!
+  
+    if klass.nil?
+      klass = Class.new( Mapping )
+      klass.define_singleton_method( :type ) do
+        @type  ||= type
+      end
+
+      ## add self.new too - note: call/forward to "old" orginal self.new of Event (base) class
+      klass.define_singleton_method( :new ) do |*args|
+        old_new( *args )
+      end
+
+      ## add to cache for later (re)use
+      cache[ class_name ] = klass
+      Types.const_set( class_name, klass )
+    end
+
+    klass
+end # method self.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 Mapping
+end  # module Types

data/lib/solidity/typed/metatypes/array.rb

@@ -0,0 +1,56 @@
+module Types
+class Typed  ## note: use class Typed as namespace (all metatype etc. nested here - the beginning)
+    
+
+class ArrayType < ReferenceType   ## note: dynamic array for now (NOT fixed!!!! - add FixedArray - why? why not?)
+    def self.instance( sub_type, size=0 ) 
+       raise ArgumentError, "[ArrayType.instance] sub_type not a type - got #{sub_type}; sorry" unless sub_type.is_a?( Type )
+       @instances ||= {}
+       key = ''  ## note: String.new('') will pick-up TypedString!!; thus, use literal for now 
+       key += sub_type.format
+       key += "×#{size}"   if size != 0
+       @instances[ key ] ||= new( sub_type, size ) 
+    end
+
+
+    attr_reader :sub_type
+    attr_reader :size     ## rename size to dim(ension) or such - why? why not?
+    def initialize( sub_type, size=0 )
+      @sub_type = sub_type
+      @size     = size
+    end
+    def format
+      if @size == 0   ## assume dynamic
+         "#{@sub_type.format}[]"   
+      else
+        "#{@sub_type.format}[#{@size}]"
+      end
+    end
+    alias_method :to_s, :format 
+
+    def ==(other)
+      other.is_a?( ArrayType ) &&
+       @sub_type == other.sub_type &&
+       @size     == other.size    ### add check for size too - why? why not?  
+    end
+    
+
+    def typedclass_name
+      ## return/use symbol (not string here) - why? why not?
+      ##  or use TypedArrayOf<sub-type.typedclass_name>  - why? why not?
+      sub_name = _sanitize_class_name( @sub_type.typedclass_name )
+      name = ''   ## note: String.new('') will pick-up TypedString!!; thus, use literal for now
+      name += "Array‹#{sub_name}›"
+      name += "×#{size}"   if @size != 0
+      name 
+    end
+    def typedclass()  Types.const_get( typedclass_name ); end
+
+    def mut?() true; end
+    def new_zero()   typedclass.new; end  
+    def new( initial_value ) typedclass.new( initial_value ); end 
+end # class ArrayType
+
+
+end  # class Typed  ## note: use class Typed as namespace (all metatype etc. nested here - the beginning)
+end # module Types  

data/lib/solidity/typed/metatypes/bool.rb

@@ -0,0 +1,39 @@
+module Types
+class Typed  ## note: use class Typed as namespace (all metatype etc. nested here - the beginning)
+
+
+class BoolType  < DataType
+  def self.instance() @instance ||= new; end
+
+  def format() 'bool'; end
+  alias_method :to_s, :format 
+
+  def ==(other)  other.is_a?( BoolType ); end
+
+  ## note: class is really a module for bool - hack!!!
+  ##   remove class from methods (typedclass_name|typedclass) - why? why not?
+  ##  change typedclass_name to typed_name !!!
+  ##   and   typedclass      to typed      !!! - why? why not??
+  def typedclass_name()  Bool.name; end
+  def typedclass()       Bool;  end    
+
+  def mut?() false; end
+  def zero() Bool.zero; end   ## note: Bool.zero is false
+  alias_method :new_zero, :zero   ## add/keep (convenience) alias for new_zero - why? why not?
+  def new( initial_value )   ## check - add default zero value - why? why not?
+     ## allow integer 0|1 here too - why? why not?
+     ##  fix-fix-fix  check solidity functions with bool (if they use 0|1 or true|false)!!!
+     if initial_value == true    # instance_of( TrueClass )
+        true
+     elsif initial_value == false  # instance_of?( FalseClass )
+        false
+     else
+        ## use value error?
+        raise ArgumentError, "BoolType.new - true or false arg expected; got: #{initial_value}"
+     end
+  end
+end  # class BoolType
+
+end  # class Typed  ## note: use class Typed as namespace (all metatype etc. nested here - the beginning)
+end # module Types   
+