sbuilder-ial 0.0.1

data/lib/action/translator.rb

@@ -0,0 +1,160 @@
+module Sbuilder
+  module Ial
+    module Action
+      
+      # not catched in 'Fp'
+      class TranslatorException < ActionException; end
+      # catched in 'Fp'
+      class TranslatorError < ActionError; end      
+
+      class Translator
+
+        PROGNAME = nil                        # progname for logger default class name
+        include Sbuilder::Ial::MyLogger       # mix logger
+        
+
+        # @attr [Hash] rules [rule->action]controlling translation
+        # @option rule [:Symbol] identify rule names
+        # @option action [Hash] actions 
+        attr_accessor :rules
+
+        def initialize( rules, options={} )
+          self.rules = rules
+          @logger = getLogger( nil, options )
+          @logger.info "#{__method__}: starting options=#{options}"
+          
+        end
+
+        def self.start( elementGenarator, options={} )
+          # elementGenarator = Sbuilder::Ial::Action::Render::TlaElementGenerator.start  if elementGenarator.nil?
+          Translator.new( TlaRules.rules(elementGenarator), options )
+        end
+
+        
+        def translate( node, rule=:start, ctx={} )
+
+          @logger.debug "#{__method__}: node=#{node}, rule=#{rule}, ctx.keys=#{ctx.keys.join(',')}" if @logger.debug?
+          # @logger.debug "#{__method__}: node=#{node}, ctx=#{ctx.to_yaml}" if @logger.debug?          
+          # Lookup 'rule' from rules
+          raise TranslatorException, "Configuration error missing rule '#{rule}' - knonwn rules: #{rules.keys}" if rules[rule].nil?
+          raise TranslatorException, "Configuration error, node empty #{node.to_s}" if node.nil? 
+          # raise TranslatorException, "Configuration error, node empty #{node.to_s}" if node.nil? or node == {}          
+
+          if rules[rule][:debug]
+            puts <<-EOS.unindent
+            ------------------------------------------------------------------
+            #{rule}: 
+
+            node=#{node}
+
+            ctx keys=#{ctx.keys.join(',')}
+
+            ctx=#{ctx.to_yaml}
+            EOS
+          end
+
+          # rule -name property in ctx holds current node, restored later
+          prev_rule = ctx[rule]
+          ctx[rule] = node;
+
+          # Collect 'navigationResults' to hash with key as
+          # 'navigation[:rule] and values with the result of
+          # translating the nodes navigated to navigation[:navigate]
+          navigationResults = {}
+          
+          # translate :navigations (before translating current node)
+          navigations = rules[rule][:navigations] ? rules[rule][:navigations] : []
+          navigations = [ navigations ] unless navigations.is_a?( Array )
+          navigations.each do |navigation|
+
+            # Validate rule configration
+            raise TranslatorException, "Error in rule #{navigation} " if navigation[:rule].nil? 
+
+            if navigation[:navigate].nil? &&  navigation[:iterate].nil?
+              # no change in node - run a new rule on current node
+              nodesToNaviagate = [node]
+            elsif navigation[:navigate]
+              navigateSteps = navigation[:navigate].is_a?(Array ) ? navigation[:navigate] : [ navigation[:navigate] ]
+              # real navigation: nodesToNaviagate must exist
+              begin
+                # walk array of navigation[:navigate] -steps
+                currentNode = node
+                navigateSteps.each do |navigateStep|
+                  # Hash, Model: access by ':navigate' key , Struct: send message ':navigate' message
+                  currentNode = !currentNode.is_a?( Struct )  ? currentNode[navigateStep] : currentNode.send( navigateStep )
+                end
+                nodesToNaviagate = currentNode
+                # nodesToNaviagate = !node.is_a?( Struct )  ? currentNote on[:navigate]] : node.send( navigation[:navigate] )
+                # nodesToNaviagate = !node.is_a?( Struct )  ? node[navigation[:navigate]] : node.send( navigation[:navigate] )
+                
+              rescue NameError => err
+                raise $!, <<-EOS,
+                         #{$!}
+
+                         Error navigating to '#{navigation[:navigate]}' in node #{node}.
+
+                         EOS
+                $!.backtrace
+              end
+              raise TranslatorError, "Navigation '#{navigation[:navigate]}' in node '#{node}' failed" if nodesToNaviagate.nil?
+              nodesToNaviagate = [nodesToNaviagate] unless nodesToNaviagate.is_a?(Array)
+            elsif navigation[:iterate]
+              # NB {} -node --> no iteration
+              nodesToNaviagate = node.keys.map { |key| node[key] }
+              # raise TranslatorError, "Navigation iterator '#{navigation[:iterate]}' in node '#{node}' failed" unless nodesToNaviagate.any?
+            else
+              raise TranslatorException, "Error in rule #{navigation} " if navigation[:rule].nil? 
+            end
+            
+
+            # nextRule possibly defined using a lamdba
+            traslationKey, nextRule = navigation[:rule].respond_to?( :call ) ? navigation[:rule].call( node ).flatten : [ navigation[:rule], navigation[:rule] ]
+            navigationResults[ traslationKey ] = 
+              nodesToNaviagate.map do |nodeToNaviagate|
+              begin
+                # run translation
+                nextTranslate = nextRule ? translate( nodeToNaviagate, nextRule, ctx ) : []
+              rescue TranslatorError => e
+                msg = <<-EOS
+                #{e.message} 
+
+                within
+
+                node: #{node}
+                rule: #{rule} 
+                ctx: #{ctx.to_yaml} 
+                EOS
+
+                raise e.class.new,  msg, e.backtrace
+                
+              end
+              nextTranslate
+            end
+            # puts "navigationResults=#{navigationResults}"
+
+          end # navigations.each 
+
+          # translate current node
+          if  rules[rule][:translator] 
+            ret = rules[rule][:translator].call( ctx.merge( { :navigationResults => navigationResults  } ))
+            if rules[rule][:debug]
+              puts <<-EOS.unindent
+              
+              ----->  translation
+              
+              #{ret}
+              EOS
+
+            end
+            
+          end
+          
+          # out of scope
+          # ctx.delete(ctx[rule])
+          ctx[rule] = prev_rule
+          ret
+        end
+      end
+    end
+  end
+end

data/lib/app/app.rb

@@ -0,0 +1,259 @@
+# coding: utf-8
+module Sbuilder
+  module Ial
+    module App
+      class App
+
+        PROGNAME = nil                        # progname for logger default class name
+        include Sbuilder::Ial::MyLogger       # mix logger
+        attr_reader :logger
+        
+
+        extend Forwardable                      # for easy delegation
+        
+
+        TRANSLATION_TARGETS = [
+          :domains_defines
+        ]
+
+        SNIPPET_TEMPLATE =
+              <<-EOS.unindent
+              {|# comment |}(* {|{ comment }|} *)
+              {|/ comment |}{|! 
+                  Output comment (with newline)
+              |}{|#useEval|}{|#EVAL|}template{|/EVAL|}{|/useEval|}{|^useEval|}{|{body}|}{|/useEval|}
+              EOS
+
+        # @attr [Sbuilder::Ial::Action::ModelBuilder] modelBuilder sexp-> model
+        attr_accessor :modelBuilder
+
+        # # @attr [Sbuilder::Ial::Action::Translator] translator model -> snippet
+        attr_accessor :translator
+
+        # @attr [object] applicationConfiguration to pass to Ruby IAL application modules
+        attr_accessor :applicationConfiguration
+
+        # @attr [Sbuilder::Ial::Action::Render::Producer]
+        attr_accessor :gen
+        
+        # # @attr [Hash] partial
+        # attr_accessor :partials
+
+        # @attr [Sbuilder::Ial::Action::Translator] extender snippet -> sbuilder
+        attr_accessor :extender
+
+        # @attr [Sbuilder::Ial::Action::Render::Renderer] renderer
+        attr_accessor :renderer
+
+        def_delegators :extender,       # access extension point
+                       :defineDomain,
+                       :defineSnippet
+        
+        # ------------------------------------------------------------------
+        # @!group Contruct & configure
+        
+
+        def initialize( options = {} )
+          @logger = getLogger( nil, options )
+          @logger.info "#{__method__}: starting options=#{options}"
+        end
+                         
+        #
+        # @param [String] metatypes prefix to make specnames in TLA
+        # language unique
+        #
+        # @param [Object] applicationConfiguration passed to ial
+        # modules
+        # 
+        # @return [App] app initilized with actions to implment steps
+        def self.start( options = {}, metatypes: nil, applicationConfiguration: nil )
+          
+          app = App.new( options )
+
+          # remember configuration which will be passed to script-eval
+          app.applicationConfiguration = applicationConfiguration
+          app.logger.info "#{__method__}: applicationConfiguration=#{applicationConfiguration}" 
+
+          # sexp -> model
+          app.modelBuilder = Sbuilder::Ial::Action::ModelBuilder.start
+
+          # produce snippets etc
+          app.gen = Sbuilder::Ial::Action::Render::ProducerEthereum.start( options, metatypes )                    
+          # # model -> translations
+          app.translator = Sbuilder::Ial::Action::Translator.start( app.gen, options )
+
+          # tempate -> data -> string
+          app.renderer = Sbuilder::Ial::Action::Render::Renderer.start( options )
+
+          # translation -> extension
+          app.extender = Sbuilder::Ial::Action::Extender.start
+          
+          app
+        end
+
+        # @!endgroup    
+
+        # ------------------------------------------------------------------
+        # @!group Workdflow
+        
+        # Load IAL implemetations arrays from Ruby 'filenames'
+        #
+        # @return [Result|Error] Result holds an Array of Ruby IAL
+        # objects read, Error wraps an exception encounted when
+        # procesing 'filename'
+        def loadIalImplementation( filenames )
+
+
+          filenames = filenames.is_a?( Array ) ? filenames : [ filenames ]
+
+          errors = false
+          ret = Sequence( filenames ).
+                inject( [] ) do |memo,filename|
+            @logger.info "#{__method__}: evaluate script filename=#{filename}, applicationConfiguration=#{applicationConfiguration}"
+            evaluated = Sbuilder::Ial::Action::ScriptEval.script_eval( filename, applicationConfiguration )
+            errors ||= evaluated.isError
+            memo += evaluated.value.is_a?(Array) ? evaluated.value : [evaluated.value]
+          end
+          errors ? Error( ret ) : Result( ret )
+
+        end
+
+        #
+        # @return [Result|Error] Result wraps
+        # Sbuilder::Ial::Model::Model, Error wraps 'Array' (with at
+        # least one 'Error' ialObjects)
+        
+        def buildModel( ialObjects )
+
+          return Error( "No objects to buidl model ialObjects.nil?=#{ialObjects.nil?}") if ialObjects.nil?
+
+          ret =
+            Sbuilder::Fp::Sequence( ialObjects ).and_then  do |vo|
+          #   modelBuilder.updateVo(vo)
+          # end.and_then  do |vo|
+          #   # remap Result to Sequence
+          #   Sequence( vo )
+          # end.and_then  do |vo|
+          #   modelBuilder.validateVo(vo)
+          # end.and_then  do |vo|            
+          #   # remap Result to Sequence
+          #   Sequence( vo )
+          # end.and_then do |vo|
+            modelBuilder.defineVo(vo)
+          end
+
+          # # Returns 'Result' (no Error objects in block), or 'Error'
+          # # if sequence block found some error.
+          
+          ret
+          
+        end
+
+        def getModel
+          modelBuilder.getModelBuilt
+        end
+
+        # @!endgroup
+
+        
+        # ------------------------------------------------------------------
+        # @!group Walk model 
+
+        # Run 'translateTargets' on 'model' to return array of
+        # translation ':results' for tranlation types :domain,
+        # :snippet, :interface.
+        #
+        # @param [Sbuilder::Ial::Model::Model] model
+        #
+        # @param [:Symbol:Array] array of tranlation targets to run
+        #
+        # @return [Hash:Sequence] translations
+        # @option translations [:Symbol] :translation values :domain, :snippet, :interface
+        # @option translations [:Symbol] :results array of translation types
+        
+        def translateModel( model, translateTargets=nil )
+
+          # default targets can be overridden on command line
+          translateTargets = TRANSLATION_TARGETS if translateTargets.nil?
+
+          # Wrap targets to a sequence, and process target in block
+          ret = Sbuilder::Fp::Sequence( translateTargets ).and_then  do |target|
+
+            # Translate 'target' in 'model' --> { :translation=>.. , :results => [] .. }
+            translationResults = translator.translate( model, target  )
+            translationResults
+          end
+
+          # Return
+          ret
+        end
+
+        # @!endgroup
+
+
+        # Render 'snippetTemplate' only if 'snippetTemplate[:template]' or 'snippetTemplate[:body]' defined
+        def renderSnippet( snippetTemplate )
+          return nil if snippetTemplate.nil? || ( snippetTemplate[:template].nil? && snippetTemplate[:body].nil? )
+          snippetTemplate[:useEval] = snippetTemplate[:template] ? true : false
+          renderer.partials = gen.partials          
+          snippetBody = renderer.to_str( SNIPPET_TEMPLATE, snippetTemplate )
+          snippetBody
+        end
+
+        # # @return [Hash] metatypes
+        # # @option metatypes [Symbol|String] key metatype
+        # # @option metatypes [Symbol] :name
+        # # @option metatypes [Symbol] :prefix                
+        def appMetatypes
+          gen.rule_metatypes
+        end
+
+        # ------------------------------------------------------------------
+        # @!group Pass forward
+
+        #
+        # @param [Result] translation with value { :translation=>..., :results=> ... }
+        #
+        def extendWithTranslations( translation )
+
+          # Extract Has from 
+          translation = translation.value
+          raise "Error in translation=#{translation}" if translation.nil? || translation[:translation].nil?  || translation[:results].nil?
+          case translation[:translation]
+          when :domain
+            translation[:results].each{ |domainDefinition| defineDomain( domainDefinition ) }
+            ret = Result( "Domains defined" )
+          when :snippet
+            warn "TODO: snippeet =#{translation}"
+            # translation[:results].each{ |snippetDefinition| defineSnippet( snippetDefinition ) }
+            translation[:results].each{ |snippetDefinition|
+              warn "snippetDefinition=#{snippetDefinition}"
+              metatype = 'metatype to set'
+              appName = 'apppi'
+              renderData =
+                {
+                    :metatype => metatype,
+                    :appName => appName,
+                    :comment => 'commenttit',
+                    :snippet => snippetDefinition
+                }
+              renderer.partials = elementGenarator.partials
+              snippetBody = renderer.to_str( SNIPPET_TEMPLATE, renderData )
+              specName = nil
+              defineSnippet( metatype, appName, snippetBody, specName )
+            }       
+            ret = Result( "Snippets defined #{translation}" )
+          else
+            raise "Error in translation=#{translation}" 
+          end
+          ret
+        end
+
+
+        # @!endgroup        
+        
+        
+      end # class App
+    end
+  end
+end