sbuilder-al 0.0.8

data/lib/sbuilder-al.rb

@@ -0,0 +1,30 @@
+module Sbuilder
+
+  ##
+  # Api language for Sbuilder
+  #
+  # * Model : {Sbuilder::Al::Model} : Application model classes and
+  #           Domain Scpecific (DSL) language to build application
+  #           model for {Sbuilder::Al}
+  #
+  # * Translator : {Sbuilder::Al::Tranlator} : Module for configurable
+  #                visitor for hash/struct model for {Sbuilder::Al}
+  #
+  # * Util: {Sbuilder::Al::Util}: Generic helpers and utilities for
+  #         {Sbuilder::Al}
+  module Al
+  end
+end
+
+require 'forwardable'
+
+require_relative( "meta/meta")
+# require_relative( "./test"  )
+# require_relative( "model/model"  )
+
+#
+require_relative( "util/module"  )
+require_relative( "model/module"  )
+require_relative( "translator/module"  )
+# require_relative( "controller/module"  )
+require_relative( "plugin/module"  )

data/lib/translator/alrules.rb

@@ -0,0 +1,424 @@
+module Sbuilder
+  module Al
+    module Translator
+
+      ##
+      # Visitor configuration to translate {Sbuilder::Al::Model}
+      # application model structrure using
+      # {Sbuilder::Al::Translator::Translator} visitor/translator.
+      # 
+       
+      class AlRules
+
+        # @return [Hash] tranlation rules for
+        # {Sbuilder::Al::Translator::Translator} visitor algorithm,
+        # see {Sbuilder::Al::Translator::Translator#rules}
+        def self.rules( producer = nil )
+          {
+            :domain => {
+              # :translator => ->( ctx ) { { :name => ctx[:domain].name, :values => nil } }
+              :navigations => [ { :navigate => :values, :rule => :rval } ],
+              :translator => ->( ctx ) do
+                values = ctx[:navigationResults][:rval].flatten(1)
+                producer.p_domain( ctx[:domain].name, values )
+              end
+            },
+
+            :definition => {
+              :navigations => [ { :navigate => :properties, :rule => :property } ],
+              :translator => ->( ctx ) { producer.p_definition( ctx[:definition].name, ctx[:navigationResults][:property].flatten ) }              
+              # :translator => ->( ctx ) { producer.p_definition( ctx[:definition].name, ctx[:definition][:properties] ) }
+            },
+
+            :function_definition => {
+              :navigations => [ { :navigate => :properties, :rule => :property } ],
+              :translator => ->( ctx ) { producer.p_function_definition( ctx[:function_definition].name, ctx[:navigationResults][:property].flatten ) }              
+            },
+
+            # transaction nodes processes alos as  interface
+            :interface => {
+              :navigations => [
+                { :navigate => :request, :rule => :interface_request },
+                { :navigate => :response, :rule => :interface_response },
+              ],
+              :translator => ->( ctx ) do
+                iface = ctx[:interface]
+                request = ctx[:navigationResults][:interface_request].flatten
+                response = ctx[:navigationResults][:interface_response].flatten                
+                producer.p_interface( iface.name, iface.operation, request, response )
+              end
+            },
+            :interface_request => {
+              :navigations => [ { :navigate => :properties, :rule => :property } ],
+              :translator => ->( ctx ) do
+                ctx[:navigationResults][:property].flatten
+              end
+            },
+            :interface_response => {
+              :navigations => [ { :navigate => :properties, :rule => :property } ],
+              :translator => ->( ctx ) do
+                ctx[:navigationResults][:property].flatten
+              end
+            },
+            
+            :snippet => {
+              # :navigations => [ { :navigate => :properties, :rule => :property } ],
+              :translator => ->( ctx ) do
+                producer.p_snippet( ctx[:snippet] )
+              end
+            },
+            
+            :transaction => {
+              :navigations => [
+                { :navigate => :block, :rule => :block },
+                { :navigate => :locals, :rule => :locals },                                
+              ],              
+              :translator => ->( ctx ) do
+                tx  = ctx[:transaction]
+                stmts = ctx[:navigationResults][:block].flatten(1)
+                locals = ctx[:navigationResults][:locals]
+                producer.p_transaction( tx, locals, stmts )
+              end
+            },
+
+            :macro => {
+              :navigations => [
+                { :navigate => :block, :rule => :block },
+                { :navigate => :parameters, :rule => :parameters },                
+              ],              
+              :translator => ->( ctx ) do
+                macro  = ctx[:macro]
+                parameteres = ctx[:navigationResults][:parameters].flatten(1)
+                stmts = ctx[:navigationResults][:block].flatten(1)
+                producer.p_macro( macro, parameteres, stmts )
+              end
+            },
+
+            :operator => {
+              :navigations => [
+                { :navigate => :rval, :rule => :rval },
+                { :navigate => :parameters, :rule => :parameters },                
+              ],              
+              :translator => ->( ctx ) do
+                operator  = ctx[:operator]
+                parameteres = ctx[:navigationResults][:parameters].flatten(1)
+                rval = producer.unwrap(ctx[:navigationResults][:rval])
+                producer.p_operator( operator, parameteres, rval )
+              end
+            },
+            
+            # ------------------------------------------------------------------
+            # Elements in operators, macros, function and transactions
+
+            :locals => {
+              :translator => ->( ctx ) do
+                ctx[:locals]
+              end
+            },
+
+            :parameters => {
+              :translator => ->( ctx ) do
+                ctx[:parameters]
+              end
+            },
+            
+            :block => {
+              :debug => false,
+              :navigations => [ { :navigate => :statements, :rule => :statement } ],
+              :translator => ->( ctx ) do
+                stmts = ctx[:navigationResults][:statement].flatten(1)
+                if stmts && stmts.any?
+                  # producer.p_block( stmts.reduce(&:concat) )
+                  producer.p_block( stmts )                  
+                else
+                  []
+                end
+              end,
+            },
+            
+            # ------------------------------------------------------------------
+            # statements
+            :statement => {
+              :debug => false,
+              :navigations => [ { :rule => ->(node) do
+                                    nodeType = node[:type]
+                                    case nodeType
+                                    when :outputStatement
+                                      [:stmt_type, :output_statement ]                                      
+                                    when :skipStatement
+                                      [:stmt_type, :skip_statement ]
+                                    when :callStatement
+                                      [:stmt_type, :call_statement ]
+                                    when :conditionalStatement
+                                      [:stmt_type, :conditional_statement ]
+                                    when :returnStatement
+                                      [:stmt_type, :return_statement ]
+                                    when :returnStatus
+                                      [:stmt_type, :return_status ]
+                                    when :returnValue
+                                      [:stmt_type, :return_value ]
+                                    when :jumpStatement
+                                      [:stmt_type, :jump_statement ]
+                                    when :assignStatement
+                                      [:stmt_type, :assign_statement ]
+                                    else
+                                      raise "Unknwon node type '#{nodeType}' for #{node}"
+                                    end
+                                  end
+                                } ],
+              :translator => ->( ctx ) { ctx[:navigationResults][:stmt_type] }
+            },
+
+            # various statement types s( s(), s(), ... )
+            :skip_statement => {
+              :translator => ->( ctx ) { producer.p_skipStatement(ctx[:skip_statement]) } 
+            },
+            :jump_statement => {
+              :translator => ->( ctx ) { producer.p_jumpStatement(ctx[:jump_statement]) } 
+            },
+            :return_statement => {
+              :navigations => [
+                { :navigate => :status, :rule => ->(node) { [:status, :rval] } },
+                { :navigate => :expression,  :rule => ->(node)  {  [:expression, :rval] } },
+              ],
+              :translator => ->( ctx ) {
+                raise "return_statement context error: could not find :transaction in [#{ctx.keys.join(',')}]" unless ctx[:transaction]
+                tx = ctx[:transaction]
+                status = producer.unwrap(ctx[:navigationResults][:status])
+                expression = producer.unwrap(ctx[:navigationResults][:expression])                
+                producer.p_returnStatement( tx, status, expression )
+              } 
+            },
+            :return_status => {
+              :navigations => [
+                { :navigate => :status, :rule => ->(node) { [:status, :rval] } },
+              ],
+              :translator => ->( ctx ) {
+                raise "return_statement context error: could not find :transaction in [#{ctx.keys.join(',')}]" unless ctx[:transaction]
+                tx = ctx[:transaction]
+                status = producer.unwrap(ctx[:navigationResults][:status])
+                producer.p_returnStatus( tx, status )
+              } 
+            },
+            :return_value => {
+              :navigations => [
+                { :navigate => :expression, :rule => ->(node) { [:expression, :rval] } },
+              ],
+              :translator => ->( ctx ) {
+                raise "return_value context error: could not find :transaction in [#{ctx.keys.join(',')}]" unless ctx[:transaction]
+                tx = ctx[:transaction]
+                variable = ctx[:return_value].variable
+                expression = producer.unwrap(ctx[:navigationResults][:expression])                
+                producer.p_returnValue( tx, variable, expression )
+              } 
+            },
+            :conditional_statement => {
+              :debug => false,
+              :navigations => [
+                { :navigate => :condition, :rule => :rval },
+                { :navigate => :ifBlock, :rule => ->(node) { [ :ifBlock, :block ]} },
+                { :navigate => :elseBlock, :rule => ->(node) {
+                    if node.elseBlock == false
+                      # no else block to traverse
+                      [ :elseBlock, false ]
+                    else
+                      [ :elseBlock, :block ]
+                    end
+                  }
+                },
+                ],              
+              :translator => ->( ctx ) do
+                condition = producer.unwrap(ctx[:navigationResults][:rval])
+                ifBlock =  producer.unwrap(ctx[:navigationResults][:ifBlock])
+                elseBlock =  producer.unwrap(ctx[:navigationResults][:elseBlock])                
+                producer.p_conditionalStatement( condition, ifBlock, elseBlock )
+              end
+            },
+            :call_statement => {
+              :navigations => [ { :navigate => :parameters, :rule => :rval } ],
+              :translator => ->( ctx ) {
+                alCallStmt = ctx[:call_statement]
+                tlaParams = ctx[:navigationResults][:rval]
+                tlaParams = tlaParams.map{ |e| producer.unwrap(e) }                
+                case alCallStmt.callType
+                when :service
+                  producer.p_callServiceStatement( alCallStmt, tlaParams )
+                when :macro
+                  producer.p_callMacroStatement( alCallStmt, tlaParams )
+                else
+                  raise "Unknown callType '#{alCallStmt.callType}' in #{alCallStmt}"
+                end
+
+              } 
+            },
+            :output_statement => {
+              :navigations => [ { :navigate => :expression, :rule => :rval } ],
+              :translator => ->( ctx ) {
+                expressions = ctx[:navigationResults][:rval]
+                # process array of expressions (which should be unwrapped)
+                expressions = expressions.map{ |e| producer.unwrap(e) }
+                producer.p_outputStatement( expressions )
+              } 
+            },
+            :assign_statement => {
+              :debug => false,
+              :navigations => [
+                # { :navigate => [:variable ], :rule => :rval_reference },                
+                { :navigate => :rval, :rule => :rval },
+              ],
+              :translator => ->( ctx ) do
+                variableReference = ctx[:assign_statement].variable
+                tlaReference = producer.p_reference(variableReference)
+                tlaRval = producer.unwrap(ctx[:navigationResults][:rval])
+                producer.p_assignTo(tlaReference, tlaRval )
+              end
+            },
+            
+            :property => {
+              # :navigations => [ { :navigate => :properties, :rule => :property } ],
+              :translator => ->( ctx ) { producer.p_property( ctx[:property] ) }
+            },
+
+            :variable => {
+              :debug => false,
+              :navigations => [ { :navigate => :init, :rule => :rval } ],
+              :translator => ->( ctx ) do
+                nameSexp = ctx[:variable]
+                initSexp = ctx[:navigationResults][:rval].flatten
+                producer.p_variable_definition( nameSexp, initSexp )
+              end
+            },
+
+
+            # expression rval
+            :rval => {
+              :debug => false,
+              :navigations => [ { :rule => ->(node) do
+                                    nodeType = node[:type]
+                                    case nodeType
+                                    when :constant_expression
+                                      [:rval, :rval_constant ]                                      
+                                    when :reference_expression
+                                      [:rval, :rval_reference ]                                      
+                                    when :binary_expression
+                                      [:rval, :rval_binary_expression ]                                      
+                                    when :unary_expression
+                                      [:rval, :rval_unary_expression ]                                      
+                                    when :tla_expression
+                                      [:rval, :rval_tla_expression ]                                      
+                                    when :simple_reference
+                                      [:rval, :rval_simple_reference ]                                      
+                                    # 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] }
+            },
+            :rval_reference =>  {
+              :translator => ->( ctx ) {
+                reference = ctx[:rval_reference].reference
+                producer.p_reference( reference )
+                
+                # # Reference makes sense only in context of [:transaction, :macro, :operator] for parameters
+                # if ctx[:rval_reference].referenceType == :parameter
+                #   if ctx[:transaction]
+                #     producer.p_tx_parameter_reference( ctx[:transaction], ctx[:rval_reference] )
+                #   elsif ctx[:macro]
+                #     # reference implemented as a simple name                  
+                #     producer.p_reference( ctx[:rval_reference] )
+                #   elsif ctx[:operator]
+                #     # reference implemented as a simple name
+                #     producer.p_reference( ctx[:rval_reference] )
+                #   else
+                #     # Error in context: raise exception showing context
+                #     raise "Reference context error: could not find any of [:transaction, :operator, :macro_entry] in [#{ctx.keys.join(',')}]"
+                #   end
+                # elsif ctx[:rval_reference].referenceType == :variable
+                #   producer.p_reference( ctx[:rval_reference] )
+                # else
+                #   raise "Unknown reference type '#{ctx[:rval_reference].referenceType}' in #{ctx[:rval_reference]}"
+                # end
+              }
+            },
+            :rval_binary_expression =>  {
+              :navigations => [
+                { :navigate => :lval, :rule => :lval },
+                { :navigate => :rval, :rule => :rval }
+              ],
+              :translator => ->( ctx ) {
+                lval = producer.unwrap(ctx[:navigationResults][:lval])
+                rval = producer.unwrap(ctx[:navigationResults][:rval])
+                producer.p_binary_expression( lval, ctx[:rval_binary_expression].op, rval )
+              }
+            },
+            :rval_unary_expression =>  {
+              :navigations => [
+                { :navigate => :expr, :rule => :rval }
+              ],
+              :translator => ->( ctx ) {
+                expr = producer.unwrap(ctx[:navigationResults][:rval])
+                producer.p_unary_expression( ctx[:rval_unary_expression].op, expr )
+              }
+            },
+            :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] },
+            },
+            :rval_constant =>  {
+              :translator => ->( ctx ) { producer.p_constant_expression( ctx[:rval_constant].value ) }
+            },
+            :rval_simple_reference =>  {
+              :translator => ->( ctx ) { producer.p_reference_to_simple( ctx[:rval_simple_reference].name ) }
+            },
+            :rval_tla_expression =>  {
+              # TlaExpression
+              :navigations => [ { :navigate => :args, :rule => :tla_rval } ],
+              # :navigations => [ { :navigate => :args, :rule => :rval } ],              
+              :translator => ->( ctx ) {
+                templateEval = ctx[:rval_tla_expression].templateEval
+                # args = ctx[:rval_tla_expression].args
+                # args = producer.unwrap(ctx[:navigationResults][:tla_rval]) # .flatten(1)
+                args = ctx[:navigationResults][:tla_rval].flatten(1)
+                # args = ctx[:navigationResults][:rval].flatten(1)                                
+                producer.p_tla_expression( templateEval, args )
+              }
+            },
+            :tla_rval =>  {
+              # :navigations => [ { :rule => :rval } ],
+              :navigations => [
+                { :rule => ->(node) do
+                    # for Al objects use rule :rval
+                    return [ :tla_rval, :rval] if node.is_a?(Sbuilder::Al::Model::RootObject)
+                    # prune traslation for non  Al-objects
+                    [ :tla_rval, nil ]
+                  end
+                }
+              ],
+              # :translator => ->( ctx ) {
+              #   ctx[:navigationResults][:tla_rval].flatten(1)
+              # },
+              :translator => ->( ctx ) {
+                if ctx[:tla_rval].is_a?(Sbuilder::Al::Model::RootObject)
+                  # Transated Al object
+                  ctx[:navigationResults][:tla_rval].flatten(1)
+                else
+                  # Non (pruned) Al object - no change
+                  [ctx[:tla_rval]]
+                end
+              }
+            },
+          } # rules hash
+        end
+
+      end
+    end
+  end
+end