sbuilder-al 0.0.8

data/lib/translator/module.rb

@@ -0,0 +1,31 @@
+require 'yaml'
+module Sbuilder
+  module Al
+
+    # Module for configurable visitor for hash/struct model for Sbuilder::Al
+    #
+    # Module includes following main classes:
+    #
+    # * Class {Sbuilder::Al::Translator::Translator} visitor
+    #   implementation
+    #   {Sbuilder::Al::Translator::Translator#translate} using
+    #   configuration {Sbuilder::Al::Translator::Translator#rules}
+    #
+    # * Class {Sbuilder::Al::Translator::AlRules} visitor configuration
+    #   for {Sbuilder::Al::Model} model
+    #  
+    # * Class {Sbuilder::Al::Translator::AlProducer} an abstract class defining 
+    #   producer rules for {Sbuilder::Al::Translator::AlRules}
+    #  
+    # 
+    module Translator
+    end
+  end
+end
+
+require_relative( "sexp")
+require_relative( "renderer")
+require_relative( "tlagenerator")
+require_relative( "producer")
+require_relative( "alrules")
+require_relative( "translator")

data/lib/translator/producer.rb

@@ -0,0 +1,580 @@
+module Sbuilder
+  module Al
+    module Translator
+
+      # not catched
+      class ProducerException < Sbuilder::Al::Util::AlException; end
+      # to be catched
+      class ProducerError < Sbuilder::Al::Util::AlError; end
+      
+
+      ##
+      # Produce tla -sexps for {Sbuilder::Al::Translator::Renderer}
+      # template generator using context created by
+      # {Sbuilder::Al::Translator::Translator} with rules in
+      # {Sbuilder::Al::Translator::AlRules}.
+      #
+      # Implementation dispatches sexp production to
+      # {Sbuilder::Al::Translator::TlaGenerator} pointed by
+      # {Sbuilder::Al::Translator::Producer#template_generator}.
+      #
+      #
+      
+      class Producer
+
+        include Sbuilder::Al::Meta              # meta supportt  e.g. attribute accessor
+        include Sbuilder::Al::Util::MyLogger    # mix logger
+        extend Forwardable                      # for easy delegation
+        
+
+        # @!attribute template_generator generator to produce snippets
+        attribute_accessor :template_generator
+
+        # ------------------------------------------------------------------
+        # @!group Framework operator services
+
+        # Macro to set return status && return expression
+        INFRA_MACRO_SET_RETURN = "InfrastructureServiceReturn"
+        INFRA_OPERATOR_GET_RESPONSE = "InfrastructureServiceGetResponse"
+        INFRA_OPERATOR_GET_STATUS = "InfrastructureServiceGetStatus"                   
+        
+
+        # @!endgroup
+
+
+        # ------------------------------------------------------------------
+        # @!group Operators
+        
+        OPERATOR_SET_MINUS = :set_minus
+        OPERATOR_SET_UNION = :union
+        OPERATOR_PLUS = :plus
+        OPERATOR_MINUS = :minus
+        OPERATOR_MULT = :mult
+        OPERATOR_DIV = :div
+        OPERATOR_EQUAL = :equal
+        OPERATOR_UNEQUAL = :unequal        
+        OPERATOR_LE = :le
+        OPERATOR_GE = :ge
+        OPERATOR_GT = :gt        
+        OPERATOR_LT = :lt
+        OPERATOR_AND = :and
+        OPERATOR_OR = :or
+        OPERATOR_NOT = :not
+
+        # map operator names to TLA implementation
+        BINARY_OPERATORS = {
+          OPERATOR_SET_MINUS => '\\',
+          OPERATOR_SET_UNION => '\\union',
+          OPERATOR_PLUS => '+',
+          OPERATOR_MINUS => '-',
+          OPERATOR_MULT => '*',
+          OPERATOR_DIV => '/',
+          OPERATOR_UNEQUAL => "#",
+          OPERATOR_EQUAL => '=',
+          OPERATOR_LT => '<',
+          OPERATOR_GT => '>',
+          OPERATOR_LE => '<=',                    
+          OPERATOR_GE => '>=',
+          OPERATOR_AND => '/\\',
+          OPERATOR_OR => '\\/',                                        
+        }
+
+        UNARY_OPERATORS = {
+          OPERATOR_NOT => '~',
+        }
+        
+        
+        # @!endgroup 
+        
+        # ------------------------------------------------------------------
+        # @!group Delegates to template -generator
+        
+        def_delegators :template_generator,
+                       :partials,              # template generator manages partials
+                       :gen_str,
+                       :gen_constant,
+                       :gen_sequence,                       
+                       :gen_plainname,
+                       :gen_record_field,
+                       :gen_bin_op,
+                       :gen_unary_op,                       
+                       :gen_specname,
+                       :gen_labeled_stmt,
+                       :gen_label,
+                       :gen_state_variable,
+                       # statements
+                       :gen_stmts,
+                       :gen_serviceProcedureLabelStatements,
+                       :gen_skip,
+                       :gen_goto,                       
+                       :gen_print,
+                       :gen_if,
+                       :gen_assign,                                              
+                       :gen_procedure_call,
+                       :gen_macro_call,
+                       # elements in tla-model
+                       :gen_interface_input_variable_name,
+                       :gen_EXCEPT,
+                       # macros,function, operators
+                       :gen_macro,
+                       :gen_operator,
+                       :gen_operator_call,
+                       :gen_service_procedure
+
+
+        # @!endgroup
+
+                
+        # ------------------------------------------------------------------
+        # @!group Constructor
+        private def initialize( options={} )
+          @logger = getLogger( nil, options )
+          @logger.info "#{__method__}: initalized"
+        end
+        
+        #
+        # @param template_generator [TlaGenerator] template generator
+        # to create TlaSexps objects. Thes TlaSexp objects can be
+        # evaluted using partials, also known by template_generator. 
+        def self.start( template_generator, options={} )
+          o = self.new( options )
+          o.template_generator = template_generator
+          o
+        end
+          
+
+        # @!endgroup
+
+        # ------------------------------------------------------------------
+        # @!group Services
+
+        # Peel of array levels until array contains Sexp's - line flatten but
+        # leave Sexps intact.
+        #
+        # @param sArray [Array<Array*<Sexp>>] Array 
+        #
+        # @param level [int] number of levels to pop
+        def unwrap( sArray, level=-1 )
+          return( sArray ) unless sArray.any?
+          return( sArray ) unless sArray[0].is_a?(Array)
+          return( sArray ) unless sArray.length == 1
+          # return( sArray ) if level == 0
+          unwrap( sArray[0], level > 0 ? level -1 : level  )
+        end
+
+        # @!endgroup
+        
+        # ------------------------------------------------------------------
+        # @!group API loader productions
+
+        def p_interface( name, operation, request, response )
+          {
+            :apiType => :interface,
+            :type => :interface,
+            :name => txInterfaceName(name, operation),
+            :operation => operation,
+            :request => request,
+            :response => response,
+          }
+        end
+
+
+        # def p_request_response( paramSet )
+        #   warn "p_request_response missing mplementation  :transaction rule";          
+        # end
+
+        # @return [Hash] with properties :name and :properties
+        def p_definition( name, properties )
+          @logger.info "#{__method__}: name=#{name}, properties=#{properties}"
+          {
+            :apiType => :definition,
+            :type => :definition,
+            :name => name,
+            :properties => properties
+          }
+        end
+
+        # @return [Hash] with properties :name and :properties
+        def p_function_definition( name, properties )
+          @logger.info "#{__method__}: name=#{name}, properties=#{properties}"
+          {
+            :apiType => :function_definition,
+            :type => :function_definition,
+            :name => name,
+            :properties => properties
+          }
+        end
+
+        def p_property( property )
+          @logger.info "#{__method__}: property=#{property}"
+          ret = {
+            :apiType => :definition_property,
+            :type => :definition_property,
+            :isArray => property.isArray,
+            :name => property.name,
+          }
+          if property.domain
+            ret[:domain] = property.domain
+          elsif property.definition
+            ret[:definition] = property.definition
+          else
+            raise ProducerError, "Property must define ':domain' or ':definition' on #{property.strOutput}"
+          end
+
+          ret
+        end
+        
+        def p_domain( domainName, values )
+          @logger.info "#{__method__}: domainName=#{domainName}, values=#{values.join(',')}"
+          {
+            :apiType => :domain,
+            :type => :domain,
+            :name => domainName,
+            :values => values,
+          }
+        end
+
+        # def p_domain_value( value )
+        #   p_constant_expression( value )
+        # end
+
+        # @!endgroup
+
+        # ------------------------------------------------------------------
+        # @!group Snippets (i.e. AL language final entries)
+
+        def p_operator( operator, parameters, rval )
+          @logger.info "#{__method__}: operator.name=#{operator.name}, parameters=#{parameters}, rval=#{rval}"
+          parameters = [] if parameters.nil?          
+          rval = gen_constant( "TRUE" ) if rval.nil?
+          gen_operator( gen_specname( operator.meta, operator.name ), parameters, rval )
+        end
+
+        # @param snippet [Model::Snippet] Snippet to render 
+        def p_snippet( snippet )
+          @logger.info "#{__method__}: snippet.meta=#{snippet.meta}, snippet.name=#{snippet.name}"
+          @logger.debug "#{__method__}: snippet=#{snippet}" if @logger.debug?
+          gen_plainname( snippet.txt )
+        end
+
+        
+        def p_macro( macro, parameters, stmts )
+          @logger.info "#{__method__}: macroName=#{macro.name}, parameters=#{parameters}"
+          @logger.debug "#{__method__}: macroName=#{macro.name} stmts=#{stmts}" if @logger.debug?
+          gen_macro( gen_specname( macro.meta, macro.name ), parameters, gen_stmts(stmts) )
+        end
+
+        # @param tx [Model::Transaction]
+        # @param stmt [Array<tlaSexp>]
+        def p_transaction( tx, locals, stmts )
+          @logger.info "#{__method__}, tx=#{tx}, locals=#{locals}"
+          @logger.debug "#{__method__}, tx stmts=#{stmts}" if @logger.debug?
+          labelPrefix = tx2ServiceProcedure( tx )
+          labeledStmts = gen_stmts(gen_serviceProcedureLabelStatements( stmts, labelPrefix ))
+          @logger.debug "#{__method__}, labeledStmts=#{labeledStmts}" if @logger.debug?
+          gen_service_procedure( tx2ServiceProcedure( tx ), txInterfaceName(tx.name, tx.operation), locals, labeledStmts )          
+        end
+        
+        def p_variable_definition( varName, initExpression )
+          @logger.info "#{__method__}: varName=#{varName}, initExpression=#{initExpression}"
+          gen_state_variable( gen_specname( varName.meta, varName.name ), initExpression )
+        end
+
+        
+        # @!endgroup
+
+        # ------------------------------------------------------------------
+        # @!group Expressions
+
+        def p_reference( alReference )
+          case alReference
+          when Sbuilder::Al::Model::SimpleReference
+            variableRef = gen_plainname( alReference.name )
+          when Sbuilder::Al::Model::VariableReference
+            variableRef = gen_specname( alReference.meta, alReference.name )
+          when Sbuilder::Al::Model::TxParameterReference
+            variableRef = p_reference_to_tx_parameter( alReference.meta, alReference.name, alReference.operation )
+          else
+            raise "Unsupported type '#{alReference.class}' for reference object '#{alReference}'"
+          end
+          # no fields - refence to variable
+          return variableRef if alReference.fields.nil?
+          fieldRef = alReference.fields.reduce( variableRef ) do |memo, fld|
+            memo = gen_record_field( memo, fld )
+            memo
+          end
+          fieldRef
+        end
+
+        # # Expression calling 'operatorName' with argumerns 'args'
+        # #
+        # # @param operatorName [String] name of operator to call
+        # # @param args [Array<TlaSexp>] arguments passed to operator
+        # def p_operatorCall(operatorName, args)
+        #   raise "not tested"
+        #   gen_operator_call( operatorName, args )
+        # end
+
+
+        # def p_tx_parameter_reference( alTx,  parameterName )
+        #   @logger.info "#{__method__}: alTx=#{alTx}, parameterName=#{parameterName}"
+        #    gen_record_field( tx2InputVariable( alTx ),  parameterName.reference )
+        # end
+        #
+
+        #
+        # sTla accessing parameter for opration 'txOperation' in tx
+        # 'txName' in namespace 'txMeta'
+        #
+        # @return [sTla] with name to access input paremeter
+        def p_reference_to_tx_parameter( txMeta, txName, txOperation )
+          tx2InputParameter( txMeta, txName, txOperation )          
+        end
+        
+        def p_reference_to_simple( name )
+          gen_plainname( name )
+        end
+        
+        def p_reference_to_variable( varMeta, varName )
+          gen_specname( varMeta, varName )
+        end
+
+        # @return [sTla] Expand binary expression 'tlaLval' 'symOp' 'tlaRval'
+        def p_binary_expression( tlaLval, symOp, tlaRval )
+            @logger.info "#{__method__}: lval=#{tlaLval}, op=#{symOp}, rval=#{tlaRval}"
+            gen_bin_op( p_op(symOp), tlaLval, tlaRval )
+        end
+        
+        # @return [sTla] Expand unary expression  'symOp' 'tlaExpr'
+        def p_unary_expression( symOp, tlaExpr )
+            @logger.info "#{__method__}: op=#{symOp}, expr=#{tlaExpr}"
+            gen_unary_op( p_unary_op(symOp), tlaExpr )
+        end
+
+        # Evaluate 'template' using 'template_generator' in '*args' context
+        # @param template [lambda] accepting tlaGenerator and 'args'
+        # @param args [Array] argument to pass to 'template' lambda
+        def p_tla_expression( template, args )
+          @logger.info "#{__method__}: template=#{template}, args=#{args.is_a?(Array) ? args.join(',') : args }"
+          template[template_generator, *args]
+        end
+
+        # @param value [String|Numeric|TrueClass|FalseClass] constant expression 
+        def p_constant_expression( value )
+            @logger.info "#{__method__}: val=#{value}"            
+            case value
+            when String
+              gen_str( value )
+            when Numeric
+              gen_constant( value )
+            when TrueClass
+              gen_constant( "TRUE" )
+            when FalseClass
+              gen_constant( "FALSE" )
+            when Symbol
+              # map symbol 'val' to sTla for constant expression
+              p_constant_symbol_expression( value )
+            else
+              raise "Unsupported type #{value.class} for val '#{value}'"
+            end
+        end
+
+        # @param constSymbol [Symbo] well knwon symbol e.g.
+        def p_constant_symbol_expression( constSymbol )
+          constValue = constantExpressions[constSymbol]
+          raise "Unsupported symbol value #{constSymbol}" if constValue.nil?
+          gen_constant(constValue)
+        end
+
+
+        # @!endgroup        
+        
+        # ------------------------------------------------------------------
+        # @!group block and statemetns
+
+        def p_block( arrOfStatements )
+          @logger.info "#{__method__}: arrOfStatements=#{arrOfStatements}:#{arrOfStatements.class}"
+          # arrOfStatements
+          arrOfStatements
+          # gen_stmts(  )
+        end
+
+        # @param tx [Model::Transaction] transaction where to return from
+        # @param status [TlaSexp] expression to set in status
+        # @param expression [TlaSexp] return value
+        def p_returnStatement( tx, status, expression )
+          @logger.info "#{__method__}: tx=#{tx}, status=#{status}, expression=#{expression}"
+          gen_macro_call( INFRA_MACRO_SET_RETURN, [gen_str(txInterfaceName(tx.name, tx.operation)), status, expression] )
+        end
+
+        # Set 'expression' to 'variable' as return value for transaction 'tx'
+        #
+        # @param tx [Model::Transaction] transaction where to return from
+        #
+        # @param variable [String] name of return value to set
+        #      
+        # @param expression [TlaSexp] return value
+        def p_returnValue( tx, variable, expression )
+          operation = gen_str(txInterfaceName(tx.name, tx.operation))
+          setVariableExpression =
+            gen_EXCEPT( 
+              gen_operator_call( INFRA_OPERATOR_GET_RESPONSE, operation ),
+              [ gen_bin_op( "=", gen_record_field( "!", variable ), expression ) ]
+            )
+          gen_macro_call( INFRA_MACRO_SET_RETURN, [ operation, gen_operator_call( INFRA_OPERATOR_GET_STATUS, operation ), setVariableExpression] )
+        end
+
+        # Set return status for transaction 'tx', expression for response is unchanged.
+        #
+        # @param tx [Model::Transaction] transaction where to return from
+        #
+        # @param status [TlaSexp] status value to set
+        def p_returnStatus( tx, status )
+          operation = gen_str(txInterfaceName(tx.name, tx.operation))
+          gen_macro_call( INFRA_MACRO_SET_RETURN, [operation, status, gen_operator_call( INFRA_OPERATOR_GET_RESPONSE, operation ) ] )
+        end
+
+
+        # @param alJump [Model::JumpStatement] statement defininng jump label 
+        def p_jumpStatement( alJump )
+          @logger.info "#{__method__}: alJump=#{alJump}, label=#{alJump.label}"
+          gen_goto( alJump.label )
+        end
+
+        # Generate skip; <genratedLabel>: skip;,  or label: skip;
+        #
+        # @param alSkipS [Model::SkipStatement] skip statemnet to process, possiby nil
+        def p_skipStatement( alSkipStmt=nil )
+          @logger.info "#{__method__}, alSkipStmt.labeled=#{alSkipStmt.nil? ? 'alSkipStmt was nil' : alSkipStmt.labeled}"
+          if ! alSkipStmt.nil? && alSkipStmt.labeled.is_a?( TrueClass )
+            p  = gen_label
+          elsif ! alSkipStmt.nil? && alSkipStmt.labeled
+            p  = gen_labeled_stmt(gen_skip, alSkipStmt.labeled )
+          else
+            p  = gen_skip
+          end
+          @logger.info "#{__method__}: p=#{p} respod_to?(:sexp_type)=#{p.respond_to?(:sexp_type)}" if @logger.debug?
+          p
+        end
+
+        # @param alServiceCall [Model::CallStatement] AL language call statement
+        # @param tlaParams [Array<TlaSexp>] Evaluated call parameters
+        def p_callServiceStatement( alCallStmt, tlaParams )
+          @logger.info "#{__method__} alCallStmt=#{alCallStmt}"
+          @logger.debug "#{__method__} #{alCallStmt.meta}:#{alCallStmt.name} tlaParams=#{tlaParams.join(',')}" if @logger.debug?
+          gen_procedure_call( tx2ServiceProcedure( alCallStmt), tlaParams )
+        end
+
+        def p_callMacroStatement( alCallStmt, tlaParams )
+          @logger.info "#{__method__} alCallStmt=#{alCallStmt}"
+          @logger.debug "#{__method__} #{alCallStmt.meta}:#{alCallStmt.name}  op=#{alCallStmt.operation}, tlaParams=#{tlaParams.join(',')}" if @logger.debug?
+          tlaMacroName = alCallStmt.meta.nil? ? gen_plainname( alCallStmt.name) : gen_specname( alCallStmt.meta, alCallStmt.name)
+          gen_macro_call( tlaMacroName, tlaParams )
+        end
+        
+
+        # @param [Array<TlaSexp>] Expressions to output
+        def p_outputStatement( alExpressions )
+          @logger.info "#{__method__}, alExpression=#{alExpressions}"
+          gen_print( gen_sequence(alExpressions) )
+        end
+
+        # @param tlaCondition [TlaSexp] evaluated condition
+        #
+        # @param tlaIfBlock [TlaSexp] evaluated block to exectute when condition true
+        #
+        # @param tlaEleseBlock [TlaSexp,Boolean] evaluated block to
+        # exectute when condition not met, Boolean false if no else block given
+        
+        def p_conditionalStatement( tlaCondition, tlaIfBlock, tlaElseBlock )
+            @logger.info "#{__method__}: tlaCondition=#{tlaCondition}"
+            @logger.debug "#{__method__}: ifBlock=#{tlaIfBlock}" if @logger.debug?
+            @logger.debug "#{__method__}: elseBlock=#{tlaElseBlock}" if @logger.debug?            
+            gen_if( tlaCondition, tlaIfBlock, tlaElseBlock )
+        end
+
+        # Assign 'tlaRval' to 'tlaLval'
+        #
+        # @param tlaVariable [TlaSexp] evaluated lval
+        # @param tlaRval [TlaSexp] evaluates rval
+        def p_assignTo( tlaLval, tlaRval)
+          @logger.info "#{__method__}: assignTo=#{tlaLval}, rval=#{tlaRval}"            
+          gen_assign( tlaLval, tlaRval )
+        end
+
+        # @!endgroup Production rules
+
+        # ------------------------------------------------------------------
+        # @!group Internal helpers
+
+        # Map 'symOp' to 'tlaOperator' using hash table 'ialOperators'
+        private def p_op( symOp )
+          tlaOperator = binaryOperators[symOp]
+          raise "Unsupported operator '#{symOp}' - known operators:#{binaryOperators.keys.join(',')}" if tlaOperator.nil?
+          tlaOperator
+        end
+
+        private def p_unary_op( symOp )
+          tlaOperator = unaryOperators[symOp]
+          raise "Unsupported operator '#{symOp}' - known operators:#{unaryOperators.keys.join(',')}" if tlaOperator.nil?
+          tlaOperator
+        end
+
+        
+
+        # @return [Hash] mapping operator symbol to tla symbols
+        private def binaryOperators
+          BINARY_OPERATORS
+        end
+
+        # @return [Hash] mapping operator symbol to tla symbols        
+        private def unaryOperators
+          UNARY_OPERATORS
+        end
+        
+
+        # @return [Hash] constanExpressions from
+        # 'Sbuilder::Ial::Model::Constants::CONSTANT_EXPRESSIONS'
+        #
+        # @option constanExpressions [:symbol] key constant
+        #
+        # @option constanExpressions [String] value constant in tla
+        # language
+        
+        def constantExpressions
+          Sbuilder::Al::Model::Constants::CONSTANT_EXPRESSIONS
+        end
+
+
+        # @return [sTla] TlaSexp for accessing transaction input variable
+        private def tx2InputVariable( tx )
+          # gen_interface_input_variable_name( txInterfaceName( tx.name, tx.operation), tx.meta )
+          tx2InputParameter( tx.meta, tx,name, tx.operation )
+        end
+
+        # @return [sTla] TlaSexp for accessing transaction input variable        
+        private def tx2InputParameter( txMeta, txName, txOperation )
+          gen_interface_input_variable_name( txInterfaceName( txName, txOperation), txMeta )
+        end
+        
+
+        # @return [sTla] TlaSexp for service procedure of transaction 'tx'
+        private def tx2ServiceProcedure( tx  )
+          gen_specname( tx.meta, txInterfaceName( tx.name, tx.operation ))
+        end
+        
+        # private def tx2appName( tx )
+        #   "#{tx.name}(#{tx.operation})"            
+        # end
+
+        private def txInterfaceName( name, operation )
+          "#{name}(#{operation})"            
+        end
+
+        # @!endgroup
+        
+      end
+    end
+  end
+end
+