Exception: Types::Error

Inherits:
StandardError
  • Object
show all
Defined in:
lib/solidity/typed/error.rb,
lib/solidity/typed/error_builder.rb

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(*args, **kwargs) ⇒ Error

Returns a new instance of Error.



22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
# File 'lib/solidity/typed/error.rb', line 22

def initialize( *args, **kwargs  )
   ## fix-fix-fix: first check for matching args - why? why not?

    if kwargs.size > 0   ## assume kwargs

      ## note: kwargs.size check matching attributes "upstream" in new!!!

      self.class.attributes.each do |key, type|
         value = kwargs[ key ]
         raise ArgumentError,  "error arg with key >#{key}< missing; sorry"  if value.nil?
         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
    else
      self.class.attributes.zip( args ).each do |(key, type), value|
         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
   self  ## note: return reference to self for chaining method calls

end

Class Method Details

.build_class(class_name, scope: Types, **attributes) ⇒ Object Also known as: new

todo/fix: scope: keep empty by default



7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
 
# File 'lib/solidity/typed/error_builder.rb', line 7

def self.build_class( class_name, scope: Types, **attributes )

 ## todo/fix:

 ## check if valid class_name MUST start with uppercase letter etc.

 ##  todo/fix: check if constant is undefined in scoped namespace!!!!


   attributes = attributes.map do |key,type|
                  [key, typeof( type )]
                end.to_h


  ## note: error is a like a value type e.g. only getters

  ##         no setters (can only initialized via constructor or such)              

  klass = Class.new( Error ) do
    attributes.each do |key,type|
      define_method( key ) do
        instance_variable_get( "@#{key}" )
      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


  ## check - if Typed:: qualifier needed here?

  ##  note Error class NOT derived from Typed (but StandardError)!!!!

  ##      thus requires qualifier!!!

  type = Typed::ErrorType.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

  ### todo/fix:

  ##    auto-add support for kwargs too!!!


  ## add self.new too - note: call/forward to "old" orginal self.new of Error (base) class

  klass.define_singleton_method( :new ) do |*args, **kwargs|
      if kwargs.size > 0   ## assume kwargs

        if kwargs.size != attributes.size
          raise ArgumentError, "[Error] wrong number of arguments for #{name}.new - #{kwargs.size} for #{attributes.size}"
        end
        ## check for matching names too - why? why not?

        if kwargs.keys.sort != attributes.keys.sort
          raise ArgumentError, "[Error] argument key (names) not matching for #{name}.new - #{kwargs.key.sort} != #{attributes.key.sort} for #{attributes.size}"
        end  
        old_new( **kwargs )
      else
        if args.size != attributes.size
          ## check for required args/params - all MUST be passed in!!!

          raise ArgumentError, "[Error] wrong number of arguments for #{name}.new - #{args.size} for #{attributes.size}"
        end
        old_new( *args )
      end
  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

.zero ⇒ Object 



15
16
17
 
# File 'lib/solidity/typed/error.rb', line 15

def self.zero
  raise "error cannot be zero (by defintion); sorry"
end

Instance Method Details

#==(other) ⇒ Object 



66
67
68
69
70
71
72
73
74
 
# File 'lib/solidity/typed/error.rb', line 66

def ==(other)
   if other.is_a?( self.class )
      self.class.attributes.keys.all? do |key|
            __send__( key ) == other.__send__( key )
      end
   else
      false
   end
end

#as_data ⇒ Object 



52
53
54
55
56
57
58
59
 
# File 'lib/solidity/typed/error.rb', line 52

def as_data
   self.class.attributes.keys.map do |key|
        ivar = instance_variable_get( "@#{key}" )
        puts "  @#{key}:"
        pp ivar
        ivar.as_data
   end
end

#as_json ⇒ Object 



62
 
# File 'lib/solidity/typed/error.rb', line 62

def as_json()   as_data; end

#serialize ⇒ Object

keep serialize and/or as_json - why? why not?



61
 
# File 'lib/solidity/typed/error.rb', line 61

def serialize() as_data; end

#type ⇒ Object 



14
 
# File 'lib/solidity/typed/error.rb', line 14

def type()     self.class.type; end

#zero? ⇒ Boolean

Returns:

  • (Boolean) 


18
 
# File 'lib/solidity/typed/error.rb', line 18

def zero?() false; end