sbuilder-ial 0.0.1

data/lib/action/script_eval.rb

@@ -0,0 +1,32 @@
+module Sbuilder
+  module Ial
+    module Action
+
+      class ScriptEval
+
+        # @param [String] filename script to evaluate
+        #
+        # @param [Object] applicationConfiguration made available for
+        # the Ruby script to evaluate
+        #
+        # @return [Result|Error] 
+        def self.script_eval( filename, applicationConfiguration=nil )
+          begin
+            # applicationConfiguration can  be accessed in 'filename' in variable 'configuration'
+            configuration = applicationConfiguration
+            proc = Proc.new {
+            }
+            ret = eval(File.read(filename), proc.binding, filename)
+            Result( ret )
+          rescue Errno::ENOENT => err
+            Error( err )            
+          rescue SyntaxError => err
+            Error( err )
+          end
+        end
+      end
+      
+    end
+  end
+end
+

data/lib/action/text.rb

@@ -0,0 +1,17 @@
+module Sbuilder
+  module Ial
+    module Action
+
+
+      class Text
+
+        def self.from_string( str )
+          new( str )
+        end
+        
+        include Sbuilder::Fp::Compositable 
+        
+      end
+    end
+  end
+end

data/lib/action/tla_rules.rb

@@ -0,0 +1,512 @@
+module Sbuilder
+  module Ial
+    module Action
+      class TlaRules
+
+        #
+        # Rules is a hash, map with [ ruleId --> rule ].
+        #
+        # ruleId : Symbol
+        #
+        # rule : Hash with keys
+        # - :navigations : Navigation|Navigation:Array
+        # - :translator : lamda function ->(ctx) {  }
+        #
+        # ctx is a hash map with properties
+        # - :navigationResults: TranslateResult
+        # - <rule> -symbol (of current translate step, and all steps abover
+        #
+        # Navigation: Hash with keys
+        # - :rule: ruleId (mandatory)
+        # - :navigate: Symbol which must exist in curent node
+        
+        # @param [ElementGenarator] gen to create expressions
+        def self.rules( gen=nil )
+          {
+            # 
+            :start => {
+              :navigations => [
+                { :rule =>  :domains_defines },
+                # { :rule =>  :states_defines },               
+              ],
+              :translator => ->( ctx ) {
+                { :domains => ctx[:navigationResults][:domains_defines].flatten,
+                  # :states => ctx[:navigationResults][:states_defines].flatten,
+                } },
+            },
+            :test => {
+              :navigations => [  { :rule =>  :domains_defines } ],
+              :translator => ->( ctx ) { { :domains => ctx[:navigationResults][:domains_defines]}},
+            },
+
+            # transaction_interfaces: for API loader extension point
+            :transaction_interfaces => {
+              :debug => false,
+              :navigations => [ { :navigate => :transaction, :rule => :transactions_interface_iterate } ],
+              :translator => ->( ctx ) do 
+                (ctx[:navigationResults][:transactions_interface_iterate]).flatten
+              end,
+            },
+            :transactions_interface_iterate => {
+              :debug => false,
+              :navigations => [ { :iterate => true, :rule => :transaction_interface } ],
+              :translator => ->( ctx ) { ctx[:navigationResults][:transaction_interface] },
+            },
+            :transaction_interface => {
+              :translator => ->( ctx ) do
+                tx = ctx[:transaction_interface]
+                appName = tx.name
+                action = tx.operation
+                {
+                  :path => appName,
+                  :operation => action,
+                  :request => tx.request,
+                  :response => tx.response,
+                }
+              end
+            },
+
+            # snippets produced only once & first
+            :library_snippets => {
+              :debug => false,              
+              :navigations => [ { :navigate => :library, :rule => :library_snippet_iterate } ],
+              :translator => ->( ctx ) { ctx[:navigationResults][:library_snippet_iterate].flatten },              
+            },
+            :library_snippet_iterate => {
+              :debug => false,
+              :navigations => [ { :iterate => true, :rule => :library_snippet } ],
+              :translator => ->( ctx ) { ctx[:navigationResults][:library_snippet] },
+            },
+            :library_snippet => {
+              :debug => false,
+              :navigations => [ { :navigate => :modules, :rule => :library_module } ],
+              :translator => ->( ctx ) { ctx[:navigationResults][:library_module] },
+            },
+            :library_module => {
+              :debug => false,            
+              :navigations => [ { :rule => ->(node) do
+                                    nodeType = node[:type]
+                                    case nodeType
+                                    when :variable
+                                      [:lib_type, :variable_define ]                                      
+                                    else
+                                      raise "Unknwon node type #{nodeType} for #{node}"
+                                    end
+                                  end
+                                } ],
+              :translator => ->( ctx ) { ctx[:navigationResults][:lib_type].flatten(1) }
+            },
+
+            # macros_snippets: macro definitions
+            :macros_snippets => {
+              :debug => false,
+              :navigations => [ { :navigate => :macro, :rule => :macros_iterate } ],
+              :translator => ->( ctx ) do 
+                (ctx[:navigationResults][:macros_iterate]).flatten
+              end,
+            },
+            :macros_iterate => {
+              :debug => false,
+              :navigations => [ { :iterate => true, :rule => :macro_entry } ],
+              :translator => ->( ctx ) { ctx[:navigationResults][:macro_entry] },
+            },
+            :macro_entry => {
+              :navigations => [
+                { :navigate => :block, :rule => :block_statements },
+              ],
+              :translator => ->( ctx ) do
+                macroName = ctx[:macro_entry].name
+                params = ctx[:macro_entry].parameters.map(&:name)
+                stmts = ctx[:navigationResults][:block_statements].flatten
+                gen.p_macro( macroName, params, stmts )
+              end
+            },
+
+            # operators
+            :operators_snippets => {
+              :debug => false,
+              :navigations => [ { :navigate => :operator, :rule => :operators_iterate } ],
+              :translator => ->( ctx ) do 
+                (ctx[:navigationResults][:operators_iterate]).flatten
+              end,
+            },
+            :operators_iterate => {
+              :debug => false,
+              :navigations => [ { :iterate => true, :rule => :operator_entry } ],
+              :translator => ->( ctx ) { ctx[:navigationResults][:operator_entry] },
+            },
+            :operator_entry => {
+              :navigations => [ { :navigate => :body, :rule => :rval } ],
+              :translator => ->( ctx ) do
+                operatorName = ctx[:operator_entry].name
+                params = ctx[:operator_entry].parameters.map(&:name)
+                body = ctx[:navigationResults][:rval].flatten(1)
+                gen.p_operator( operatorName, params, body )
+              end
+            },
+            
+
+            # transaction_entry_snippets: macro called 
+            :transaction_entry_snippets => {
+              :debug => false,
+              :navigations => [ { :navigate => :transaction, :rule => :transactions_entry_iterate } ],
+              :translator => ->( ctx ) do 
+                (ctx[:navigationResults][:transactions_entry_iterate]).flatten
+              end,
+            },
+            :transactions_entry_iterate => {
+              :debug => false,
+              :navigations => [ { :iterate => true, :rule => :transaction_entry } ],
+              :translator => ->( ctx ) { ctx[:navigationResults][:transaction_entry] },
+            },
+            :transaction_entry => {
+              :debug => false,
+              :navigations => [
+                { :navigate => :entryBlock, :rule => :block_statements },
+              ],
+              :translator => ->( ctx ) do
+                txName = ctx[:transaction_entry].name
+                operationName = ctx[:transaction_entry].operation
+                stmts = ctx[:navigationResults][:block_statements].flatten
+                gen.p_tx_entry( txName, operationName, stmts )
+              end
+            },
+
+            # produce function for transaction implementation 
+            :transaction_function_snippets => {
+              :debug => false,
+              :navigations => [ { :navigate => :transaction, :rule => :transactions_function_iterate } ],
+              :translator => ->( ctx ) do 
+                (ctx[:navigationResults][:transactions_function_iterate]).flatten
+              end,
+            },
+            :transactions_function_iterate => {
+              :debug => false,
+              :navigations => [ { :iterate => true, :rule => :transaction_function } ],
+              :translator => ->( ctx ) { ctx[:navigationResults][:transaction_function] },
+            },
+            :transaction_function => {
+              :debug => false,
+              :navigations => [
+                { :navigate => :block, :rule => :block_statements },
+              ],
+              :translator => ->( ctx ) do
+                txName = ctx[:transaction_function].name
+                operationName = ctx[:transaction_function].operation
+                stmts = ctx[:navigationResults][:block_statements].flatten
+                # Just array of strings
+                locals = ctx[:transaction_function].locals.map { |l| l.is_a?(Sbuilder::Ial::Model::Local) ? l.name : l }
+                gen.p_tx_function( txName, operationName, locals, stmts  )
+              end
+            },
+
+            # produce block of statmentes 'gen_stmts( s(gen_skip))'
+            :block_statements => {
+              :debug => false,
+              :navigations => [ { :navigate => :statements, :rule => :block_statement } ],
+              :translator => ->( ctx ) do
+                stmts = ctx[:navigationResults][:block_statement]
+                if stmts && stmts.any?
+                  gen.gen_stmts( stmts.reduce(&:concat) )
+                else
+                  []
+                end
+              end,
+            },
+            :block_statement => {
+              :debug => false,
+              :navigations => [ { :rule => ->(node) do
+                                    nodeType = node[:type]
+                                    case nodeType
+                                    when :printStatement
+                                      [:stmt_type, :print_statement ]                                      
+                                    when :skipStatement
+                                      [:stmt_type, :skip_statement ]
+                                    when :callStatement
+                                      [:stmt_type, :call_statement ]
+                                    when :conditionalStatement
+                                      [:stmt_type, :conditional_statement ]
+                                    when :assignStatement
+                                      [:stmt_type, :assign_statement ]
+                                    else
+                                      raise "Unknwon node type '#{nodeType}' for #{node}"
+                                    end
+                                  end
+                                } ],
+              # :translator => ->( ctx ) { ctx[:navigationResults][:stmt_type].inject( s() ) {|m,stmts| m += stmts; m} }
+              :translator => ->( ctx ) { ctx[:navigationResults][:stmt_type].flatten(1) }
+            },
+
+            # various statement types s( s(), s(), ... )
+            :skip_statement => {
+              :translator => ->( ctx ) { gen.p_skipStatement } 
+            },
+            :conditional_statement => {
+              :debug => false,
+              :navigations => [
+                { :navigate => :condition, :rule => :rval },
+                { :navigate => :ifBlock, :rule => ->(node) { [ :ifBlock, :block_statements ]} },
+                { :navigate => :elseBlock, :rule => ->(node) {
+                    if node.elseBlock == false
+                      # no else block to traverse
+                      [ :elseBlock, false ]
+                    else
+                      [ :elseBlock, :block_statements ]
+                    end
+                  }
+                },
+                ],              
+              :translator => ->( ctx ) do
+                condition = ctx[:navigationResults][:rval].flatten(1)
+                ifBlock =  ctx[:navigationResults][:ifBlock].flatten(1)
+                elseBlock =  ctx[:navigationResults][:elseBlock].flatten(1)                
+                gen.p_conditionalStatement( condition, ifBlock, elseBlock )
+              end
+            },
+            :call_statement => {
+              :debug => false,
+              :navigations => [ { :navigate => :parameters, :rule => :rval } ],
+              :translator => ->( ctx ) {
+                targetType = ctx[:call_statement][:targetType]
+                parameters = ctx[:navigationResults][:rval]
+                case targetType
+                when :macro
+                  target = ctx[:call_statement][:target]
+                  gen.p_callMacroStatement( target, parameters )
+                when :service
+                  txName = ctx[:call_statement][:target]
+                  operation = ctx[:call_statement][:operation]
+                  gen.p_callServiceStatement( txName, operation, parameters )       
+                else
+                  raise "Unknwon  target type '#{targetType}' in call-statements #{ctx[:call_statement]}"
+                end
+              } 
+            },
+            :print_statement => {
+              :navigations => [ { :navigate => :expression, :rule => :rval } ],
+              :translator => ->( ctx ) do
+                node = ctx[:print_statement]
+                printExpr = ctx[:navigationResults][:rval]
+                gen.p_printStatement(  printExpr  )
+              end
+            },
+            :assign_statement => {
+              :debug => false,
+              :navigations => [
+                { :navigate => [:variable, :ref ], :rule => :rval_reference },                
+                { :navigate => :expression, :rule => :rval },
+              ],
+              :translator => ->( ctx ) do
+                assignTo = ctx[:navigationResults][:rval_reference].flatten(1)
+                rval = ctx[:navigationResults][:rval].flatten(1)                
+                gen.p_assignTo(  assignTo, rval )
+              end
+            },
+            
+
+            # expression rval
+            :rval => {
+              :debug => false,
+              :navigations => [ { :rule => ->(node) do
+                                    nodeType = node[:type]
+                                    case nodeType
+                                    when :constantExpression
+                                      [:rval, :rval_constant ]                                      
+                                    when :referenceExpression
+                                      [:rval, :rval_reference ]                                      
+                                    when :binaryExpression
+                                      [:rval, :rval_binary_expression ]                                      
+                                    when :tlaExpression
+                                      [:rval, :rval_tla_expression ]                                      
+                                    when :operatorExpression
+                                      [:rval, :rval_operator_expr ]                                      
+                                    when :variable
+                                      [:rval, :rval_variable ]                                      
+                                    else
+                                      raise "Unknwon node type '#{nodeType}' for #{node}"
+                                    end
+                                  end
+                                } ],
+              :translator => ->( ctx ) { ctx[:navigationResults][:rval].flatten(1) }
+            },
+            :lval => {
+              # used in binary operator where lval and rval are both
+              # expressions, just forward to :rval,
+              :debug => false,
+              :navigations => [ { :rule => :rval } ],
+              :translator => ->( ctx ) { ctx[:navigationResults][:rval].flatten(1) },
+            },
+            :rval_binary_expression =>  {
+              :navigations => [ { :navigate => :lval, :rule => :lval }, { :navigate => :rval, :rule => :rval } ],
+              :translator => ->( ctx ) {
+                lval = ctx[:navigationResults][:lval].flatten(1)
+                rval = ctx[:navigationResults][:rval].flatten(1)
+                gen.p_binary_expression( lval, ctx[:rval_binary_expression].op, rval ) }
+            },
+            :rval_constant =>  {
+              # rval_constant is ConstantExpression
+              :translator => ->( ctx ) { gen.p_constant_expression( ctx[:rval_constant].const ) }
+            },
+            :rval_reference =>  {
+              :navigations => [{ :rule => ->(node) do
+                                  refType = node.refType
+                                  case refType
+                                    when :domain
+                                      [:ref, :rval_domain ]                                      
+                                    when :variable
+                                      [:ref, :rval_variable ]                                      
+                                    when :parameter
+                                      [:ref, :rval_parameter ]                                      
+                                    when :local
+                                      [:ref, :rval_local ]                                      
+                                    when :plain
+                                      [:ref, :rval_local ]                                      
+                                    else
+                                      raise "Unknwon refType type '#{refType}' for #{node}"
+                                    end
+                                  end
+                              }],
+              :translator => ->( ctx ) { ctx[:navigationResults][:ref].flatten(1) }
+            },
+            :rval_variable =>  {
+              :translator => ->( ctx ) { gen.p_variable_expression( ctx[:rval_variable].ref ) }
+            },
+            :rval_operator_expr =>  {
+              :navigations => [ { :navigate => :args, :rule => :rval } ],
+              :translator => ->( ctx ) do
+                operatorName = ctx[:rval_operator_expr].called
+                args = ctx[:navigationResults][:rval]
+                if ctx[:rval_operator_expr].infrastructureService
+                  gen.p_infra_operator_expression( operatorName, args )                  
+                else
+                  gen.p_operator_expression( operatorName, args )
+                end
+              end
+            },
+            :rval_parameter =>  {
+              :translator => ->( ctx ) {
+                # Reference to one of :transaction_function, :macro_entry
+                if ctx[:transaction_function] 
+                  txName = ctx[:transaction_function].name
+                  operationName = ctx[:transaction_function].operation
+                  parameterName = ctx[:rval_parameter].ref
+                  gen.p_tx_parameter_expression( txName, operationName, parameterName )
+                elsif ctx[:macro_entry]
+                  macroName = ctx[:macro_entry].name
+                  parameterName = ctx[:rval_parameter].ref
+                  gen.p_macro_parameter_expression( macroName, parameterName )
+                elsif ctx[:operator_entry]
+                  operatorName = ctx[:operator_entry].name
+                  parameterName = ctx[:rval_parameter].ref
+                  gen.p_operator_parameter_expression( operatorName, parameterName )
+                else
+                  raise "Expect to be called within :transaction_function, :operator_entry, or :macro_entry"
+                end
+              }
+            },
+            :rval_domain =>  {
+              :translator => ->( ctx ) { gen.p_domain_expression( ctx[:rval_domain].ref ) }
+            },
+            :rval_local =>  {
+              :translator => ->( ctx ) { gen.p_local_expression( ctx[:rval_local].ref ) }
+            },
+            :rval_tla_expression =>  {
+              :debug => false,
+              :navigations => [ { :navigate => :args, :rule => :rval } ],
+              :translator => ->( ctx ) {
+                # args is array of parameters p1,p2, ... [p1,p2,...],
+                # using splat * to pass these parameters to to gen-methods
+                args = ctx[:navigationResults][:rval]
+                gen.p_template_expression( ctx[:rval_tla_expression].templateEval, args) }
+            },
+            
+
+            # transaction_exit_snippets
+            :base_snippets => {
+              :debug => false,
+              :translator => ->( ctx ) do
+                gen.p_base_snippets( )
+              end,
+            },
+
+            # transaction_exit_snippets
+            :transaction_exit_snippets => {
+              :debug => false,
+              :navigations => [ { :navigate => :transaction, :rule => :transactions_exit_iterate } ],
+              :translator => ->( ctx ) do 
+                (ctx[:navigationResults][:transactions_exit_iterate]).flatten
+              end,
+            },
+            :transactions_exit_iterate => {
+              :debug => false,
+              :navigations => [ { :iterate => true, :rule => :transaction_exit } ],
+              :translator => ->( ctx ) { ctx[:navigationResults][:transaction_exit] },
+            },
+            :transaction_exit => {
+              :translator => ->( ctx ) do
+                txName = ctx[:transaction_exit].name
+                operationName = ctx[:transaction_exit].operation
+                gen.p_tx_exit( txName, operationName  )
+              end
+            },
+
+            # Create snippets for variable definitions
+            :variables_snippets => {
+              :navigations => [ { :navigate => :variable, :rule => :variable_iterate } ],
+              :translator => ->( ctx ) do 
+                ctx[:navigationResults][:variable_iterate].flatten
+              end,
+            },
+            :variable_iterate => {
+              :debug => false,
+              :navigations => [ { :iterate => true, :rule => :variable_define } ],
+              :translator => ->( ctx ) { ctx[:navigationResults][:variable_define] }              
+            },
+            :variable_define => {
+              :debug => false,
+              :navigations => [ { :navigate => :init, :rule => :rval } ],
+              :translator => ->( ctx ) do
+                varName = ctx[:variable_define].name
+                init = ctx[:navigationResults][:rval].flatten
+                gen.p_variable_definition( varName, init )
+              end
+            },
+
+            :api_definitions => {
+              :debug => false,              
+              :navigations => [ { :navigate => :definition, :rule => :api_definitions_iterate } ],
+              :translator => ->( ctx ) do
+                ctx[:navigationResults][:api_definitions_iterate].flatten(1)
+              end
+            },
+            :api_definitions_iterate => {
+              :debug => false,
+              :navigations => [ { :iterate => true, :rule => :api_definition } ],
+              :translator => ->( ctx ) { ctx[:navigationResults][:api_definition] },
+            },
+            :api_definition => {
+              :translator => ->( ctx ) { { :name => ctx[:api_definition].name, :properties => ctx[:api_definition].properties || [] } }
+            },
+            
+
+            #  { :name, :values }:Array
+            :domains_defines => {
+              :navigations => [ { :navigate => :domain, :rule => :domain_iterate } ],
+              :translator => ->( ctx ) do
+                ctx[:navigationResults][:domain_iterate].flatten
+              end
+            },
+            :domain_iterate => {
+              :navigations => [ { :iterate => true, :rule => :domain_define } ],
+              :translator => ->( ctx ) { ctx[:navigationResults][:domain_define] }              
+            },
+            :domain_define => {
+              :translator => ->( ctx ) { { :name => ctx[:domain_define].name, :values => nil } }
+            },
+          }
+        end
+        
+      end
+    end
+  end
+end