sbuilder-ethereum 0.0.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fa3a1818b9e4c6c2f3eb5fcc251320fce12bf664
+  data.tar.gz: 4b5e415b5aacf139ae0b495d78df88c0db29f51f
+SHA512:
+  metadata.gz: e80192d1a6c95840eed592ead93333e74e4dc8a70d6b505a3257224faf312a0e27ceb7db51d5a0820578099a38bdd1d38ddb742a56f6db3e7dc29a77cea22f9c
+  data.tar.gz: 8a9a1faba9367c4048c324448d67e133506c3bc3d9198b05a0683c08838df9afd679c8796154fea1553b25ec357712177289eb4570367cc91893d0c2fd4f1c7b

data/VERSION

@@ -0,0 +1 @@
+0.0.6

data/lib/mixer/decl_ref.rb

@@ -0,0 +1,19 @@
+
+module Sbuilder; module Ethereum
+                   
+module DeclRef
+
+  # @attr [Ast] enclosingScope pointer to scope (sets in SexpProcessorSymbolTable1)
+  attr_accessor :enclosingScope
+
+  # @attr [Ast] declationRef pointer to declartion (set in SexpProcessorSymbolTable2)
+  attr_accessor :declationRef
+
+  # @return [Boolean] true because mixes as declaration reference
+  def isDeclarationRef
+    true
+  end
+
+end
+
+end; end

data/lib/mixer/domain_ref.rb

@@ -0,0 +1,18 @@
+module Sbuilder
+  module Ethereum
+                   
+module DomainRef
+
+  # @attr [Domain] domainReference 
+  attr_accessor :domainReference
+
+  # @return [Boolean] true because mixes as declaration reference
+  def isDomainRef
+    true
+  end
+  
+end
+
+
+  end
+end

data/lib/mixer/scope.rb

@@ -0,0 +1,92 @@
+
+module Sbuilder
+  module Ethereum
+
+    module Scope
+      # @attr [Hash] map name to symbol
+      attr_reader :symbols
+
+      # @attr [Sccope] enclosing_scope
+      attr_accessor :enclosing_scope
+
+      #
+      # @param [SexpAst] symbol to add to scope
+      #
+      def define( name, symbol )
+        @symbols ||={}
+        symbols[name] = symbol
+        
+      end
+
+      def allSymbols()
+        parentSymbols = {}
+        if getEnclosingScope
+          parentSymbols = getEnclosingScope.allSymbols
+        end
+        parentSymbols.merge( symbols || {} )
+      end
+
+      ##
+      # Return symbol definitions
+      def symbolDefinitions
+        symbols.values
+      end
+
+      def scopeHiearachy
+        hierarchy  =  [ sexp_type ]
+        if getEnclosingScope
+          hierarchy += getEnclosingScope.scopeHiearachy
+        end
+        hierarchy        
+      end
+
+      ##
+      # Return top most scope
+      def globalScope
+        return self if getEnclosingScope.nil?
+        getEnclosingScope.globalScope
+      end
+
+      def getSymbol( name )
+        symbols[name] if symbols &&  symbols[name]
+      end
+
+      # @param [String] name to resolve
+      #
+      # @return [Symbol] symbol resolved for the {name}, nil if not found
+      def resolve( name )
+        ret = getSymbol( name )
+        return ret unless ret.nil?
+        return getEnclosingScope.resolve( name ) if getEnclosingScope
+        nil
+      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 [Scope|nil] scope for enclosing scope, nil for root scope
+      def getEnclosingScope
+        enclosing_scope
+      end
+
+      # @return [Boolean] true because mixes module scope
+      def isScope
+        true
+      end
+      
+
+    end
+
+  end
+end

data/lib/mixer/scoped.rb

@@ -0,0 +1,17 @@
+module Sbuilder
+  module Ethereum
+
+    module Scoped
+
+      # @attr [Ast] enclosingScope pointer to scope (sets in SexpProcessorSymbolTable1)
+      attr_accessor :scopeDefining
+      
+      # @return [Boolean] true because can be scoped
+      def isScoped
+        true
+      end
+
+    end
+
+  end
+end

data/lib/mixer/symbol_ref.rb

@@ -0,0 +1,16 @@
+module Sbuilder
+  module Ethereum
+    module SymbolRef
+      # add a reference to type definition
+
+      # @attr [TypeSymbol] symbolTypeReference pointer to symbol (sets in SexpProcessorSymbolTable2)
+      attr_accessor :symbolTypeReference
+      
+      # @return [Boolean] true because mixes module symbol reference
+      def isSymbolRef
+        true
+      end
+      
+    end
+  end
+end

data/lib/mixer/type_symbol.rb

@@ -0,0 +1,75 @@
+module Sbuilder
+  module Ethereum
+
+    # Depends on 'scope'
+    
+    module TypeSymbol
+      # add a reference to type definition
+
+      # @attr [TypeSymbol] isA pointer to parent type
+      attr_accessor :isA
+
+      # @attr [TypeSymbol:Array] derivedTypes direct 'derivedTypes' 
+      # @return [TypeSymbol:Array] 
+      def derivedTypes
+        @derivedTypes || []
+      end
+
+      # @return [Hash] knownTypes all known 'derivedTypes' in
+      # derication hierarch
+      # @option knownTypes [String] <key >typeName
+      # @option knownTypes [Array] <value> array of known types
+      
+      def allDerivedTypes( knownTypes )
+        childTypes = []
+        knownTypes[typeName]  = [self] 
+        derivedTypes.each do |derivedType|
+          # find out knownTypes in 'derivedTypes'
+          knownTypes = derivedType.allDerivedTypes( knownTypes )
+          # propagete derived types to parent type
+          childTypes += knownTypes[derivedType.typeName] unless knownTypes[derivedType.typeName].nil?
+        end
+
+        knownTypes[typeName]  +=  childTypes.uniq
+        knownTypes
+      end
+      
+      # @return [TypeSymbol|nil] typeSymbol scope for enclosing type,
+      # nil for root type. Wrapper to isA
+      def getEnclosingType
+        isA
+      end
+
+      #
+      # @return [TypeSymbol] top element in type hierarchy
+      def rootSymbol
+        return self if isA.nil?
+        isA.rootSymbol
+      end
+
+      # Build type hierarchy bottom up ie. child.inherits( parent )'
+      #
+      # @param [TypeSymbol] parentExp inherited
+      def inherits( parentExp )
+        raise "parentExp #{parentExp} is not 'TypeSymbol'" unless parentExp.respond_to?(:isTypeSymbol) && parentExp.isTypeSymbol
+        self.isA = parentExp
+        # add back pointer in parent to poin to me
+        parentExp.addDerivedTypes( self )
+        self
+      end
+
+      # Add 'childEntry' to '@derivedTypes', private method
+      def addDerivedTypes( childEntry )
+        @derivedTypes = [] if  @derivedTypes.nil?
+        @derivedTypes << childEntry
+      end
+
+
+      # @return [Boolean] true because mixes module symbol
+      def isTypeSymbol
+        true
+      end
+      
+    end
+  end
+end

data/lib/plugin/plugin.rb

@@ -0,0 +1,332 @@
+require  'sbuilder'
+
+module Sbuilder
+  module Ethereum
+    
+    class Plugin < Sbuilder::LoaderPluginRoot
+
+      extend Forwardable                      # for easy delegation
+
+      # mix api loader plugin services
+      include ApiLoaderPluginMixer
+
+      # mix snippet loader plugin services
+      include SnippetLoaderPluginMixer
+
+      # @attr [SexpProcessorTla] tla which has created +interfaces+,
+      # +snippets+, +partials+, and +metatypes+
+      attr_reader :tla
+
+      # @attr [GlobalScope] globalScope the one
+      attr_reader :globalScope
+
+      def_delegators :tla,
+                     # @attr [Interfaces] interfaces created by tla-processor
+                     :interfaces,
+                     # @attr [Definitions] definitions created by tla-processor
+                     :definitions,
+                     # @attr [Snippets] snippets i.e. TLA generate
+                     # elements created by tla-processor
+                     :snippets,
+                     # @attr [Hash] partials mapping TLA generate element to mustache partial
+                     :partials,
+                     # @attr [Hash] metatypes used by TLA generate,
+                     # key=metatype, value=desciption
+                     :metatypes,
+                     # @attr [String:Array] domainNames to create in TLA model
+                     :domainNames
+
+      # @attr [Domains] dataFlowDomains
+      attr_reader :dataFlowDomains
+
+      # @attr [Hash] preferences passesed as PREFERENCES property to rendering
+      attr_reader :preferences
+
+      ## 
+      # Collect domains in 'dataFlowDomains'.
+      #
+      # @param [Domains] resolvedDomains
+      def addDataflowDomains( resolvedDomains )
+        if dataFlowDomains.nil?
+          # init array
+          @dataFlowDomains = resolvedDomains
+        else
+          # concat arrays
+          resolvedDomains.domains.each do |resolvedDomain|
+            @dataFlowDomains << resolvedDomain
+          end
+        end
+        @logger.info "#{__method__}: domains=#{dataFlowDomains}"        
+      end
+      
+
+      # @attr [Hash] options set in constructor
+      attr_reader :options 
+
+      # ------------------------------------------------------------------
+      # @!group Construct && configure
+
+      def initialize( options = {} )
+        super( options )
+        @options = options
+        logger.info "#{__method__}: plugin created"
+      end
+
+      # Class level configuration
+      #
+      # @param [Hash] configuration given in 'extend.loaders'
+      # @option configuration [String] solc_command path to solc executable
+      #
+      def self.configure( configuration )
+        validateProperties( configuration, Constants::VALIDATION[:class_configure][:required], Constants::VALIDATION[:class_configure][:allowed] )        
+        @@solc_command = configuration['solc_command'] if configuration.is_a?(Hash )  &&  configuration.key?( 'solc_command' )
+      end
+
+      # Instance level configuration
+      #
+      # @param [Hash] configuration for object instance
+      def configure( configuration )
+        logger.info "#{__method__}: configuration=#{configuration}"
+        validateProperties( configuration, Constants::VALIDATION[:configure][:required], Constants::VALIDATION[:configure][:allowed] )        
+        @preferences = configuration['preferences']
+      end
+
+      ##
+      # @return [String] solc_command path to compile executable- if configerd
+      def self.solc_command
+        @@solc_command if defined?( @@solc_command )
+      end
+
+      
+
+      # @!endgroup
+
+      # ------------------------------------------------------------------
+      # @!group compile & parse solidity
+
+      ##
+      # compile, load, create symbol table, resolve symbols, identify domains,
+      # create TLA snippets && infterfaces
+      #
+      
+      def processSource( soliditySource )
+        
+        # Compile +soliditySource+ to +astPath+ json file
+        compiler = Compile.new( options )
+        compiler.output_directory = compileWorkDirectory
+        compiler.solc_command = self.class.solc_command
+        compiler.compile( soliditySource )
+        astPath = compiler.compiledAst
+
+        # load +astPath+ into SexpAst tree +ast+
+        loader   = Load.new( options )
+
+        # Create the unique global scope
+        @globalScope = SexpUtils.createGlobalScope
+        @logger.debug "#{__method__}: globalScope=#{globalScope}" if @logger.debug?
+        # create tla processor, which maps ast to snippets,
+        # interfaces, etc. make tla aware of +baseMetatypes+ in
+        # 'sbuilder' framework.
+
+        @tla      = SexpProcessorTla.new( facade.baseMetatypes, options )
+        # tla.setBaseMetatypes( facade.baseMetatypes )
+
+        # process global scope - it defines global functions, which should be processed
+        processAst( "GlobalScope", globalScope, nil )
+        
+        # process all compile units
+
+        asts = []
+        loader.processAllAsts( astPath ) do |ast, astName |
+          processAst( astName, ast, globalScope )
+          asts << ast
+        end
+
+        # after all solidity ast's have been preprossesed
+        tla.process( globalScope )
+        asts.each do |ast|
+          # Create +snippets+, +interfaces+, +partials+, +domains+
+          tla.process(  ast )
+        end
+        
+      end
+
+
+      ##
+      # Process 'ast' trhough steps: 1) fix.point( canonize ), 2)
+      # Create symbol table hierarchy, 3) Resolve refernces using the
+      # symbol table, 4) identify data flows, 4) map processed ast to
+      # tla-language elements
+      #
+      # @param [String] compileUnit name of solidity AST
+      private def processAst( compileUnit, ast, globalScope )
+
+        @logger.debug "#{__method__}: ast=#{ast}" if @logger.debug?
+
+        # preprocess
+        needAnalyzer =  Sbuilder::Ethereum::SexpProcessorNeedToCanonize.new( options ) 
+        needProcessor = Sbuilder::Ethereum::SexpProcessorCanonize.new( options )
+        needProcessor.setCompileUnit( compileUnit )
+
+        # iterate canonization until fixpoint
+        begin
+          needAnalyzer.initIt
+          needAnalyzer.process( ast )
+          needProcessor.setNeeds( needAnalyzer )
+          needProcessor.process( ast );
+        end while ( needProcessor.somethingCanonized )
+        
+
+        # Scope hierarchy for symbol table in +ast+
+        symbolTable1 = SexpProcessorSymbolTable1.new( options )
+        symbolTable1.globalScope = globalScope
+        symbolTable1.process( ast )
+
+        # Resolve references in +ast+
+        symbolTable2 = SexpProcessorSymbolTable2.new( options )
+        symbolTable2.process( ast )
+
+        # Identity dataflow in in +ast+ and produde +domains+
+        dataFlow = SexpProcessorDataflow.new( options )
+        dataFlow.process( ast )
+
+        # adds to context accross compile units
+        addDataflowDomains( dataFlow.domains )
+
+        # # Create +snippets+, +interfaces+, +partials+, +domains+
+        # tla.process( ast )
+
+        # @logger.debug "#{__method__}: #{compileUnit} defines-snippets=#{snippets.length}"  if @logger.debug?      
+        # @logger.debug "#{__method__}: interfaces=#{interfaces}" if @logger.debug?
+        # @logger.debug "#{__method__}: definitions=#{definitions}" if @logger.debug?              
+        
+      end 
+
+      # @!endgroup
+
+      
+      # ------------------------------------------------------------------
+      # @!group APi loader
+
+      ##
+      # Load API interfaces to sbuilder for solidity source
+      #
+      # @param [String] soliditySource given in sbuilder.yaml
+      #
+      def load( soliditySource )
+        logger.info "#{__method__} soliditySource=#{soliditySource}"
+        # snippets parsed
+        
+        processSource( soliditySource )
+
+        loadDomains
+        
+        loadApis
+
+      end
+
+      ##
+      # Load domainNames to sbuilder using via +facade+
+      private def loadDomains
+        logger.info "#{__method__}: starting"
+
+        # Load domains idendified during dataflow analysis
+        dataFlowDomains.domains.each do |domain|
+          logger.info "#{__method__}: dataflow domainName=#{domain.domainName}, values=#{domain.domainValues.join(',')}"          
+          facade.defineDomain( domain.domainName, domain.domainValues )          
+        end
+
+        # Load domains identified during TLA processing 
+        domainNames.each do |domain|
+          logger.info "#{__method__}: TLA app-domainName=#{domain.domainName}, values=#{domain.domainValues.join(',')}"
+          facade.defineDomain( domain.domainName, domain.domainValues )
+        end
+        logger.debug "#{__method__} done" if logger.debug?
+      end
+
+
+      ##
+      # Ensture that 'getCacheDir'/solidity exists && return this
+      # directory as a path. Called in API loader phase --> use facade
+      # to access sbuilder context.
+      #
+      # @return [String] path to compiler wordking directory private
+      
+      def compileWorkDirectory()
+        
+        subDir = "solidity"
+        
+        directoryPath = "#{facade.getCacheDir}/#{subDir}"
+        
+        Dir.mkdir( directoryPath ) unless File.exist?( directoryPath )
+        directoryPath
+        
+      end
+
+      ##
+      # Load api configuration to sbuilder using via +facade+.
+      private def loadApis
+
+        # Create loader to process :Interfaces sexps
+        apiLoader = SexpProcessorApi.new( options )
+        apiLoader.apiFacade = facade
+        # InfrastructureService -> support returning 'response'
+        facade.configureInfrastructureService( true )
+        apiLoader.process( interfaces )
+
+        apiLoader.process( definitions )        
+        
+      end
+
+      # @return [Boolean] true #load has called #process, which sets +snippets+
+      def loadDone
+        !tla.nil? && !snippets.nil?
+      end
+      
+
+      # @!endgroup
+      
+      # ------------------------------------------------------------------
+      # @!group Snippet loader
+
+      ##
+      # Register snippets for a solidity contract.
+
+      # Implemtnation assumes that +process+ method has been called
+      # earlier, and uses +snippets+ getter to retrive TLA generate
+      # element to load into sbuilder.
+      #
+      # Overrides abstract method in parent class.
+      #
+      # @param [Hash:Array] snippetDefitions given in sbuilder.yaml
+      #
+      # @return [Boolean] true after success
+      #
+      def doRegisterSnippets( snippetDefitions )
+        logger.info "#{__method__}: snippetDefitions=#{snippetDefitions}"
+        raise SbuilderEtherumPluginException, "Should call #load before calling ##{__method__}" unless loadDone
+        logger.debug "#{__method__}: snippets-dump=#{snippets}" if logger.debug?
+        logger.info "#{__method__}: snippets=#{snippets.return_nodes_with_type(:Snippet).map {|s| s.metatype.to_s + '/' + s.appName.to_s}.join(',')}"
+
+        # Create renderer i.e. an object to convert TLA generate
+        # element to TLA language snippets by using mustache partial
+        renderer =  Render.new( options )
+        renderer.setPreferences( preferences )
+        renderer.setPartials( partials )
+
+        # Create && configure snippet loader to process ':Snippets' sexps
+        snippetLoader  = SexpProcessorSnippet.new( options )
+        snippetLoader.setSnippetFacade( snippetFacade )
+        snippetLoader.setRenderer( renderer )
+        snippetLoader.setMetatypes( metatypes )
+        snippetLoader.process( snippets )
+        
+        true
+      end
+
+      # @!endgroup      
+      
+      
+    end # class Plugin < Sbuilder::SnippetLoaderPlugin
+  end
+end