sbuilder-eth 0.0.4

data/lib/mixer/reference.rb

@@ -0,0 +1,30 @@
+module Sbuilder
+  module Eth
+
+    ##
+    # Mixer module to AST nodes, which need to be resolved for a
+    # {#reference} to a {#Sbuilder::Eth::Scoped} symbol
+    module Reference
+
+      # @!attribute enclosingScope [Scope] a pointer to scope which
+      # knows how to resolve {#reference}
+      attr_accessor :enclosingScope
+
+      # @!attribute reference [Scoped] a (resolved) pointer to
+      # {#Scoped} symbol declaration
+      attr_writer :reference
+
+      def reference
+        raise "Reference not resolved for #{self}"  if @reference.nil?
+        @reference
+      end
+      
+
+      # @return [Boolean] true because mixes as reference
+      def isReference
+        true
+      end
+      
+    end
+  end
+end

data/lib/mixer/scope.rb

@@ -0,0 +1,100 @@
+module Sbuilder
+  module Eth
+    ##
+    # Mixer module to be included to AST nodes, which scope symbols
+    module Scope
+
+      # @!attribute [Hash<Symbol:AstSexp>] symbols
+      def symbols
+        @symbols || {}
+      end
+
+      # @attribute [Sccope] enclosingScope
+      attr_accessor :enclosingScope
+
+      # @param name [String,Symbol] identifier to assign to 'astSexp'
+      # @param astSexp [AstSexp] AST node to associate with name 
+      def define(name, astSexp)
+        @symbols ||= {}
+        @symbols[name] = astSexp
+        
+        # Add back reference
+        astSexp.scopeDefining = self
+      end
+      
+      # def resolve( name )
+      #   ret 
+      # end
+
+      def scopeHiearachy
+        # assume to be included sto AstSexp implementing 'sexp_type'
+        hierarchy  =  [ sexp_type ]
+        if enclosingScope
+          hierarchy += enclosingScope.scopeHiearachy
+        end
+        hierarchy        
+      end
+
+      ##
+      # @return [Scope] topmost scope
+      def globalScope
+        return self if enclosingScope.nil?
+        enclosingScope.globalScope
+      end
+
+      def allSymbols()
+        parentSymbols = {}
+        if enclosingScope
+          parentSymbols = enclosingScope.allSymbols
+        end
+        parentSymbols.merge( symbols )
+      end
+
+      def getSymbol( name )
+        symbols[name] if symbols &&  symbols[name]
+      end
+
+      # @param [String] name to resolve
+      #
+      # @param errorReport [Boolean] true for raising error if not
+      # found
+      #
+      # @return [Symbol] symbol resolved for the 'name', nil if not
+      # found
+      def resolve( name, errorReport=true )
+        ret = getSymbol( name )
+        return ret unless ret.nil?
+        ret = enclosingScope.resolve( name, false ) if enclosingScope
+        return ret unless ret.nil?
+        
+        raise ScopeException, <<-EOS if errorReport
+        Could not resolve '#{name}' on #{self}
+
+        Scope hierarchy: #{scopeHiearachy.join(',')}
+        Known symbols :  #{allSymbols.keys().join(',')}
+        EOS
+        # it is nil
+        ret
+      end
+      
+      # def resolveOrReportError( name )
+      #   resolved = resolve( name )
+      #   return resolved if resolved
+
+      #   raise SbuilderEtherumScopeException, <<-EOS
+      #   Could not resolve '#{name}' on #{self}
+
+      #   Scope hierarchy: #{scopeHiearachy.join(',')}
+      #   Known symbols :  #{allSymbols.keys().join(',')}
+      #   EOS
+        
+      # end
+      
+
+      # @return [Boolean] true because mixes module scope
+      def isScope
+        true
+      end
+    end
+  end
+end

data/lib/mixer/scoped.rb

@@ -0,0 +1,18 @@
+module Sbuilder
+  module Eth
+    ##
+    # Mixer module to be included to AST nodes acting as symbols which
+    # can be refenced to.
+    module Scoped
+
+      # @!attribute [AstSexp:Scope] back pointer to scope defininign this symbol
+      attr_accessor :scopeDefining
+      
+      # @return [Boolean] true because can be scoped
+      def isScoped
+        true
+      end
+      
+    end
+  end
+end

data/lib/plugin/controller.rb

@@ -0,0 +1,267 @@
+module Sbuilder
+  module Eth
+    module Plugin
+      
+      # Controller for Loading Ethreum application to sbuilder.
+      #
+      # Plugin calls {#initApplication} method, which creates an array
+      # of AlObject and passes these objects controller parent using
+      # method {Sbuilder::Al::Plugin::Controller#addAlObjects}.
+      #
+      #
+
+
+      class Controller < Sbuilder::Al::Plugin::Controller
+
+
+        # ------------------------------------------------------------------
+        # @!group Attributes 
+
+
+        # @!attribute [Hash] options  command line configurations
+        attr_accessor :options
+
+        # @!attribute [Sbuilder::Eth::SolidityCompiler] compiler  
+        attr_accessor :compiler
+
+        # @!attribute [Sbuilder::Eth::SolidityLoader] loader  
+        attr_accessor :loader
+
+        # @!attribute [Sbuilder::Eth::SolidityT] eth_translator  
+        attr_accessor :eth_translator
+
+        # @!attribute [SexpProcessorScope] scope
+        attr_accessor :scope
+
+        # @!attribute [SexpProcessorResolve] resolve
+        attr_accessor :resolve
+        
+        # @!attribute ethRuntimeReturned allows 'ethRuntime' to execute only once
+        @@ethRuntimeReturned = false
+
+        # @!attribute contractClasses [Array<String>] names of classes
+        #             parsed
+        @@contractClasses = []
+        
+      
+        # @!endgroup
+
+        # ------------------------------------------------------------------
+        # @!group Constructor & initialization
+        
+        def initialize( options = {} )
+          super( options )
+          self.options = options
+          @logger = getLogger( "EthController", options )
+          @logger.info( "#{__method__}: init eth.controller")
+          # initApi
+        end
+
+        # Create tools in toolchain
+        #
+        # # @param configuration [Hash] configugration yaml from sbuilder.yaml
+        def initInputProcessingPipe( configuration )
+          @logger.info( "#{__method__}: configuration=#{configuration}")
+
+          self.loader = Sbuilder::Eth::SolidityLoader.new( options )
+
+          self.compiler = Sbuilder::Eth::SolidityCompiler.new( options )
+          compiler.solc_command =configuration['compiler']['solc_command'] if configuration && configuration['compiler'] && configuration['compiler']['solc_command']
+          compiler.solc_flags =configuration['compiler']['solc_flags'] if configuration && configuration['compiler'] && configuration['compiler']['solc_flags']
+          compiler.output_directory =configuration['compiler']['output_directory'] if configuration && configuration['compiler'] && configuration['compiler']['output_directory']
+          
+          self.scope = Sbuilder::Eth::SexpProcessorScope.new( options )
+
+          self.resolve = Sbuilder::Eth::SexpProcessorResolve.new( options )
+
+          self.eth_translator = Sbuilder::Eth::SolidityTranslator.new( options )
+          
+        end
+
+        # @!endgroup
+
+        # ------------------------------------------------------------------
+        # @!group Class services
+
+
+        # Load inputs as AlObjects to an application array (managed in
+        # super class)
+        #
+        # Method in Sbuilder::Al::Plugin::Controller overridden.
+        #
+        # @param configuration [Hash] hash with properites
+        #
+        # @option configuration [String|Array<String>] 'input' path to
+        # input files to load.
+        #
+        def initApplication( configuration )
+          @logger.info( "#{__method__}: configuration=#{configuration}")
+
+          
+          warn "No 'input'  property in #{configuration} - nothing loaded" if configuration['input'].nil?
+          
+          # Create clean state for processing
+          initInputProcessingPipe( configuration )
+
+          # add metatype definitions (used by alObjects below) to
+          # parent controller state
+          metaDefs = processMetatypes
+          addMetatypes( metaDefs )
+
+          # add AL (application language) objects to parent controller
+          alObjects = processInputs( configuration['input'] )
+          addAlObjects(  alObjects )
+          
+        end # initApplication
+
+        # Add runtime AL-objects for translation.
+        #
+        # This method called when all sbuilder plugins have had their
+        # {#initApplication} called, and next phase in sbuilder
+        # loading starts. In out case we'll add runtime AL objects
+        # (only once)
+        #
+        
+        def initApplicationFinalize
+          
+          # run only once (also for many instances!)
+          return if @@ethRuntimeReturned
+
+          alObject = []
+          # Create alObjects - if any alObjects created
+          alObjects = eth_translator.solidityRuntime( @@contractClasses ) unless eth_translator.nil?
+          addAlObjects(  alObjects )
+          
+          @@ethRuntimeReturned = true
+          
+        end
+        
+
+        # @!endgroup
+
+        # ------------------------------------------------------------------
+        # @!group Class implementation
+
+        # Implementation 1) compiles solidity source file pointed by
+        # configuration['input'], 2) loads AST files created in
+        # compilation step 3) translates AST structures to AlObjects,
+        # 4) passes AlObjects to application using method
+        # {Sbuilder::Al::Plugin::Controller#addAlObjects}.
+        # 
+        # @param inputs [String, Array<String>] file names to load
+        def processInputs( inputs )
+          inputs = inputs || []
+          inputs = [inputs] unless inputs.is_a?(Array)
+          @logger.info "#{__method__}: inputs=#{inputs.join(',')}"
+
+          alObjects =
+            # # runtime objects
+            # eth_translator.solidityTranslate( nil ) +
+
+            # objects compiled for input files
+            inputs.map do |inputFile|
+            
+            # compiles & returns name of AST fie
+            compiler.compile(inputFile)
+            
+          end.reduce( []) do |memo, astFile|
+            
+            # 1 AST file = N ASTs
+            @logger.info "#{__method__}: astFile=#{astFile}"
+            loader.load( astFile ) do |solSource, index, ast|
+              # loaded one 'ast' from 'astFile'
+              memo << {
+                :ast => ast,
+                :solSource => solSource
+              }
+            end
+            memo
+          end.
+            map do |astDef|
+            ast = astDef[:ast]
+            
+            # ensure getters for public membar variables
+            SexpProcessorGetter.new(options).process( ast )
+
+            astDef
+          end.
+            map do |astDef|
+            ast = astDef[:ast]
+
+            # find scope of declations && resolve identifiers
+            scope.process( ast )
+            resolve.process( ast )
+            
+            astDef
+
+          end.
+            map do |astDef|
+            ast = astDef[:ast]
+            
+            # sepate function call from expressions
+            SexpProcessorCallSeparator.new(options).process( ast )
+
+            astDef
+          end.
+            reduce( [] ) do |memo, astDef|
+            ast = astDef[:ast]
+            # translate one AST at a time + memoize alObjects
+            outputMsg( astDef[:solSource] )
+            memo += eth_translator.solidityTranslate( ast, astDef[:solSource] ) do |contractClass|
+              outputMsg( "   - #{astDef[:solSource]} : processing class #{contractClass}" )
+              # Collect class names into an array
+              addContractClass(contractClass)
+            end
+            memo
+          end
+
+          @logger.info( "#{__method__}: alObjects.length=#{alObjects.length}")
+          @logger.debug( "#{__method__}: alObjects=#{alObjects}") if @logger.debug?
+          # @logger.info( "#{__method__}: alObjects=#{alObjects.map { |alO| alO[:type] }.join(',')}")          
+
+          # pass alObjects to application array 
+          alObjects
+          
+        end
+
+        # @return [Hash] metaDefs (metatype definition used in
+        # application)
+        def processMetatypes
+          eth_translator.metaDefs
+        end
+
+        # @!endgroup
+
+        # ------------------------------------------------------------------
+        # @!group Helpers
+
+
+        # @param soliditySource [String] name solidity file processed
+        def outputMsg(soliditySource)
+          msg =" - Solidity translation: #{soliditySource}" 
+          @logger.info( msg )
+          puts msg
+        end
+        
+
+        # @!endgroup
+
+        # ------------------------------------------------------------------
+        # @!group Helpers
+
+        def addContractClass(className)
+          @@contractClasses << className
+        end
+        
+
+        # @!endgroup
+
+
+        
+      end # class Controller < Sbuilder::Al::Plugin::Controller
+      
+    end
+
+    
+  end
+end

data/lib/plugin/module.rb

@@ -0,0 +1,3 @@
+require_relative "controller"
+require_relative "plugin"
+

data/lib/plugin/plugin.rb

@@ -0,0 +1,33 @@
+require "sbuilder"
+
+module Sbuilder
+
+  module Eth
+
+    module Plugin
+      
+
+      # Extent Sbuilder::Al::Plugin::Plugin class.  The only
+      # modification being to replace default plugin.controller
+      # Sbuilder::Al::Plugin::Controller with
+      # Sbuilder::Eth::Controller.
+      class Plugin < Sbuilder::Al::Plugin::Plugin
+
+        def initialize( options={} )
+          @logger = getLogger( "EthPlugin", options )
+          @logger.info( "#{__method__} sbuilder-eth plugin initialized" )
+          super( options )
+          # replace controller
+          self.controller = Sbuilder::Eth::Plugin::Controller.new( options )
+        end
+
+        # @return [String] version from VERSION
+        def self.version
+          File.read( File.join( File.dirname( __FILE__), "../..",  "VERSION"))
+        end
+
+      end
+    end
+    
+  end
+end