sbuilder-ethereum 0.0.6

data/lib/sbuilder/sexp_utils.rb

@@ -0,0 +1,417 @@
+module Sbuilder
+  module Ethereum
+
+    class SexpUtils
+
+      # ------------------------------------------------------------------
+      # @!group Id-generator
+
+      # @attr [Integer] idGenerator class variable used to generate
+      # unique identifiers
+      @@idGenerator = 1
+
+      ##
+      # @return [String] nextId unique indetifier generated for each call
+      def self.nextId
+        @@idGenerator += 1
+        "canonized-#{@@idGenerator}"
+      end
+
+      # ## 
+      # # Wrap to self.class.nextId
+      # def nextId
+      #   self.class.nextId
+      # end
+
+      # @!endgroup
+
+      # ------------------------------------------------------------------
+      # @!group create nodes
+
+      ##
+      # Add 'chldExp' to 'exp'
+      def self.addNewChild( exp, chldExp )
+        chldExp.setParent(  exp )
+        exp << chldExp
+        exp
+      end
+
+      ##
+      # Add method to FunctionDefintion 'exp'. It returns inteface
+      # names like 'Demo()', 'Send()', 'Demo(set)', to be used for
+      # example on setup step 'interface' properties.  for function
+      def self.defineInterfaceName( exp, interfaceName )
+        exp.define_singleton_method( :interfaceName ) do
+          interfaceName
+        end
+      end
+
+      
+      # @!endgroup
+      
+      # ------------------------------------------------------------------
+      # @!group create nodes
+
+      ##
+      # @return [FunctionDefinition] functionAst for +functionName+
+      def self.createFunction( functionName, isConstructor )
+
+        yaml_str=<<-EOS
+           name: FunctionDefinition
+           id: #{nextId}
+           attributes:
+             constant: false
+             name: #{functionName}
+             public: true
+           children:
+           - children: []
+             id: #{nextId}
+             name: ParameterList
+           - children: []
+             id: #{nextId}
+             name: ParameterList
+           - name: Block
+             children: []
+             id: #{nextId}
+        EOS
+        hash = YAML.load(yaml_str)
+        # logger.debug "#{__method__}: function hash #{hash}"
+        exp = SexpAst.build_sexp( hash )
+        exp
+        
+      end
+
+      # ##
+      # # Contruct 'FunctionDefinition' sexp for 'functionName'.
+      # # Add also 'interfaceName' method to this sexp.
+      # def self.createBoolFunction( functionName )
+
+      #   yaml_str=<<-EOS
+      #      name: FunctionDefinition
+      #      id: #{nextId}
+      #      attributes:
+      #        constant: false
+      #        name: #{functionName}
+      #        public: true
+      #      children:
+      #      - children: []
+      #        id: #{nextId}
+      #        name: ParameterList
+      #      - children: 
+      #        - attributes:
+      #            name: ''
+      #            type: bool
+      #          children:
+      #          - attributes:
+      #              name: bool
+      #            id: #{nextId}
+      #            name: ElementaryTypeName
+      #          id: #{nextId}
+      #          name: VariableDeclaration
+      #        id: #{nextId}
+      #        name: ParameterList
+      #      - children: []
+      #        id: #{nextId}
+      #        name: Block
+      #   EOS
+      #   hash = YAML.load(yaml_str)
+      #   # logger.debug "#{__method__}: function hash #{hash}"
+      #   exp = SexpAst.build_sexp( hash )
+
+      #   interfaceName = "#{functionName}()"
+      #   defineInterfaceName( exp, interfaceName )
+      #   exp 
+      # end
+
+      
+
+      ##
+      # @return [FunctionDefinition] constructor for +contractName+
+      #
+      # @see createFunction
+      def self.createConstructorNode( contractName )
+        constructor = createFunction( contractName, true )
+
+        interfaceName = "#{contractName}()"
+        defineInterfaceName( constructor, interfaceName )
+        constructor
+        
+      end
+
+      # @param [String] operator like +=, *=
+      # @return [String] operator like +, *, ...
+      def self.mapAssignmentOperator( operator )
+        operatorMapper = {
+          "+=" => '+'
+        }
+        mapped = operatorMapper[operator]
+        raise "DO not know how to map operator #{operator}" if mapped.nil?
+        mapped
+      end
+
+      def self.createBinaryOperator( operator )
+        yaml_str=<<-EOS
+                  name: BinaryOperation
+                  id: #{nextId}
+                  attributes:
+                    operator: #{operator}
+                    type: uint256
+                  children: []
+        EOS
+        hash = YAML.load(yaml_str)
+        exp = SexpAst.build_sexp( hash )
+        exp
+      end
+
+      def self.createBoolDecl
+        yaml_str=<<-EOS
+           name: VariableDeclaration
+           id: #{nextId}
+           attributes:
+               name: ''
+               type: bool
+           children: 
+               - name: ElementaryTypeName
+                 id: #{nextId}
+                 children:
+                 attributes:
+                     name: bool
+        EOS
+        hash = YAML.load(yaml_str)
+        exp = SexpAst.build_sexp( hash )
+        exp
+      end
+
+      def self.createReturn()
+        yaml_str=<<-EOS
+        name: Return
+        id: #{nextId}
+        children:
+          - name: Literal
+            id: #{nextId}
+            attributes:
+               string: 'true'
+               type: bool
+               value: 'true'
+        EOS
+        hash = YAML.load(yaml_str)
+        exp = SexpAst.build_sexp( hash )
+        exp
+      end
+
+      def splitOperator( operator, assigned, expr )
+      end
+
+      # @return [FunctionDefinition] getter SexpAst for +variableName+
+      def self.createGetter( variableName )
+
+        getterForVariable = variableName[0,1].upcase + variableName[1..-1]
+        getterName = "get#{getterForVariable}"
+        
+
+        # Type should be of no interest because specification uses
+        # domains. use 
+        type ="uint256"
+        elementaryType="uint"
+        
+
+        getterStr = <<-EOS
+               attributes:
+                 constant: true
+                 name: #{getterName}
+                 public: true
+               children:
+               - children: []
+                 id: #{nextId}
+                 name: ParameterList
+                 src: ""
+               - children:
+                 - attributes:
+                     name: #{variableName}
+                     type: uint256
+                   children:
+                   - attributes:
+                       name: uint
+                     id: #{nextId}
+                     name: ElementaryTypeName
+                     src: ""
+                   id: #{nextId}
+                   name: VariableDeclaration
+                   src: ""
+                 id: #{nextId}
+                 name: ParameterList
+                 src: ""
+               - children:
+                 - children:
+                   - attributes:
+                       type: uint256
+                       value: #{variableName}
+                     id: #{nextId}
+                     name: Identifier
+                     src: ""
+                   id: #{nextId}
+                   name: Return
+                   src: ""
+                 id: #{nextId}
+                 name: Block
+                 src: ""
+               id: #{nextId}
+               name: FunctionDefinition
+               src: ""
+        EOS
+        
+        getterHash = YAML.load(getterStr)
+        # logger.debug "#{__method__}: getterHash=#{getterHash}"
+        SexpAst.build_sexp( getterHash )
+        
+      end
+
+      # @return [VariableDeclaration] variableDeclarion SexpAst for +variableName+
+      def self.createVariableDeclaration( variableName )
+        
+
+        # Type should be of no interest because specification uses
+        # domains. use 
+        type ="uint256"
+        elementaryType="uint"
+        
+        variableStr=<<-EOS
+            name: VariableDeclaration
+            id: #{nextId}
+            attributes:
+              name: #{variableName}
+              type: #{type}
+            children:
+            - attributes:
+                name: #{elementaryType}
+              name: ElementaryTypeName
+              id: #{nextId}
+        EOS
+
+        
+        variable = YAML.load(variableStr)
+        # logger.debug "#{__method__}: variable #{hash}"
+        SexpAst.build_sexp( variable )
+        
+        
+      end
+
+      
+      def self.createVariableDeclarationWithDomain( variableName, domainName )
+
+        # Type should be of no interest because specification uses
+        # domains. use 
+        type =domainName
+        elementaryType="uint"
+        
+        # eg. knows how to resolve 'send' and other address releated functions
+        solidityType = domainName == Constants::DOMAIN_ADDRESS ? Constants::SOL_ADDRESS : nil
+        
+        variableStr=<<-EOS
+            name: VariableDeclaration
+            id: #{nextId}
+            attributes:
+              name: #{variableName}
+              type: #{type}
+            children:
+            - attributes:
+                name: #{domainName}
+                solidityType: #{solidityType}
+              name: Domain
+              id: #{nextId}
+        EOS
+
+        variable = YAML.load(variableStr)
+        # logger.debug "#{__method__}: variable #{hash}"
+        SexpAst.build_sexp( variable )
+        
+      end
+
+      # @!endgroup
+
+      # ------------------------------------------------------------------
+      # @!group Id-generator
+
+      def self.createGlobalScope
+
+        scope = GlobalScope.new
+
+        scopeName = "GlobalScope"
+
+        globalFunctions = [Constants::SOL_SEND].inject( { }) do |memo,fname|
+          memo[fname] = initFunction( scopeName, fname )
+          memo
+        end
+
+
+        # generate uqiue identfiers
+        # id = 1
+        # scope.define( Constants::SOL_NOW, Now.new( "GLOB-#{id}" ) ); id += 1;
+
+        # global scope acts as a contract - add global functions there
+        globalFunctions.each do |name, func |
+          scope << func
+          scope.define( func.interfaceName, func )
+        end
+
+        # add built in types, possibly define some function
+        # e.g. address send
+        [
+          [ Constants::SOL_BOOLEAN_TYPE, nil],
+          [ Constants::SOL_UINT,  nil],
+          [ Constants::SOL_ADDRESS,  globalFunctions],          
+        ].each do |builtIn|
+          builtInType = builtIn[0]
+          funcs = builtIn[1]
+          newType = BuiltInSymbol.new( builtInType )
+          scope.define( builtInType, newType )
+          
+          # funcs is a hash
+          funcs  && funcs.each do |name,func|
+            newType.define( name, func)
+          end
+        end
+        
+        scope
+      end
+
+      ##
+      # Create function 'functionName', in 'scopeName', and add common
+      # request paramerters
+      def self.initFunction( scopeName, functionName )
+
+        isConstructor = false
+        functionSexp = SexpUtils.createFunction(functionName, isConstructor)
+        interfaceName = "#{scopeName}(#{functionName})"
+        defineInterfaceName( functionSexp, interfaceName )
+        
+        functionSexp.block<< SexpUtils.createReturn()
+
+        # add common requet parameters
+        requestParameters = functionSexp.parameterList        
+        TlaElementText.commonMsgProperties( 'request', isConstructor ).each do |parameter|
+          newParameter = SexpUtils.createVariableDeclarationWithDomain( parameter[1], parameter[2] )
+          SexpUtils.addNewChild( requestParameters, newParameter )
+        end
+
+        # Add return parameters for boolean variable
+        TlaElementText.commonMsgProperties( 'response-bool', isConstructor ).each do |parameter|
+          newParameter = SexpUtils.createVariableDeclarationWithDomain( parameter[1], parameter[2] )
+          SexpUtils.addNewChild( functionSexp.returnList, newParameter )
+        end
+        
+        #
+        return functionSexp
+      end
+      
+      
+
+      # @!endgroup      
+
+      
+
+    end
+
+  end
+
+end

data/lib/utils/logger.rb

@@ -0,0 +1,82 @@
+module Sbuilder
+  module Ethereum
+require 'logger'
+
+# see http://hawkins.io/2013/08/using-the-ruby-logger/
+
+module MyLogger
+
+  # no logging done
+
+  class NullLoger < Logger
+    def initialize(*args)
+    end
+
+    def add(*args, &block)
+    end
+
+    def debug?
+      false
+    end
+  end
+
+  @@logfile = nil                          # absolute path to log file
+  LOGFILE="sbuilder.log"
+
+  def logfile( options ) 
+    return @@logfile if @@logfile
+    @@logfile = options[:logfile] || File.join( Dir.getwd, LOGFILE )
+    @@logfile
+  end
+
+  def getLogger( progname=nil, options={} )
+
+
+    progname = self.class.name.split('::').last if progname.nil?
+    level = get_level( options )
+
+    if level.nil? 
+
+      return NullLoger.new 
+
+    else
+
+      
+      logger = Logger.new( logfile(options) )
+      logger.level=level
+      logger.progname = progname
+      return logger
+
+    end
+
+  end # getLogger
+  
+
+  # ------------------------------------------------------------------
+  private
+
+  def get_level( options ) 
+
+    level_name = options && options[:log] ? options[:log] : ENV['LOG_LEVEL']
+
+    level = case  level_name
+            when 'warn', 'WARN'
+              Logger::WARN
+            when 'info', 'INFO'
+              Logger::INFO
+            when 'debug', 'DEBUG'
+              Logger::DEBUG
+            when 'error', 'ERROR'
+              Logger::ERROR
+            else
+              nil
+            end
+
+    return level
+  end
+
+end
+
+
+  end
+end