sbuilder-al 0.0.8

data/lib/model/builders.rb

@@ -0,0 +1,603 @@
+module Sbuilder
+  module Al
+    module Model
+      # ==================================================================
+      # Builder classes called from {Sbuilder::Al::Model::Api}
+      
+      module Builders
+        
+        # ------------------------------------------------------------------
+        # @!group Domain
+
+        class DomainBuilder
+          def name(v=nil); @name=v; self;end
+          def value( v=nil) values( Sbuilder::Al::Model::Api::constantExpression{ value v } ); self; end
+          def literal( v=nil) values( Sbuilder::Al::Model::Api::tlaPlainname( v ) ); self; end          
+          def values( v = [] )
+            @values ||= []
+            @values += v.is_a?(Array) ? v : [v]
+            self
+          end
+          def build
+            Domain.new( type: :domain, name: @name, values: @values )
+          end
+        end
+
+        # @!endgroup
+
+        # ------------------------------------------------------------------
+        # @!group Statements
+
+        class BlockBuilder
+          
+          # block statemetns
+          def nop
+            statements( Sbuilder::Al::Model::Api::skipStatement  )
+          end
+          # add a labeled statement
+          def label( lab=nil )
+            statements( Sbuilder::Al::Model::Api::skipStatement{ labeled lab }  )
+          end
+
+          def jump( lab )
+            statements( Sbuilder::Al::Model::Api::jumpStatement( lab ) )
+          end
+
+          # Add jump statement to end label
+          # @param interfaceOperation [String] interfaceOperation to fail name(operation) 
+          def done( interfaceOperation )
+            statements( Sbuilder::Al::Model::Api::jumpStatement( Sbuilder::Al::Model::Api::strLabelEnd(interfaceOperation) ) )
+          end
+
+          # Add jump statement to Abort failure label
+          # @param interfaceOperation [String] interfaceOperation to fail name(operation) 
+          def failure( interfaceOperation )
+            statements( Sbuilder::Al::Model::Api::jumpStatement( Sbuilder::Al::Model::Api::strLabelFail(interfaceOperation) ) )
+          end
+
+          # Add jump statement to Abort label
+          # @param interfaceOperation [String] interfaceOperation to fail name(operation)           
+          def aborted( interfaceOperation )
+            statements( Sbuilder::Al::Model::Api::jumpStatement( Sbuilder::Al::Model::Api::strLabelAbort(interfaceOperation) ) )
+          end
+
+          # @param expression [Expression] TLA-expresion to set on 
+          #      reponse value to, no expresion --> set only status
+          #
+          def ret( status, expression = nil )
+            statements( Sbuilder::Al::Model::Api::returnStatement do
+                          status( status )
+                          expression( expression ) unless expression.nil?
+                        end
+                      )
+          end
+
+          # Create {ReturnStatement} to set 'expression' to variable 'variableName'
+          #
+          # @param variableName [String] name of return variable to set
+          #      
+          # @param expression [Expression] Expression to set to return
+          #        variable
+          #
+          def returnValue( variableName, expression )
+            statements( Sbuilder::Al::Model::Api::returnStatement do
+                          variable( variableName )
+                          expression( expression )
+                        end
+                      )
+          end
+          
+          def output( *msg  )
+            msg = "" if msg.nil?
+            # msg = [ msg ] unless msg.is_a?(Array)
+            statements( Sbuilder::Al::Model::Api::outputStatement( msg )  )
+          end
+          def assignTo( &blk )
+            stmt = Sbuilder::Al::Model::Api::assignStatement(&blk) 
+            statements( stmt )
+          end
+          
+          def callMacro( meta, svc=nil, &blk )
+            # support callMacro( svc ) 
+            if svc.nil?
+              svc = meta
+              meta = nil
+            end
+            stmt = Sbuilder::Al::Model::Api::callStatement do
+                callType :macro
+                meta meta unless meta.nil?
+                name svc
+                yield self if blk
+            end
+            statements( stmt )
+          end
+          def callService( meta, svc, operation, &blk )
+            stmt = Sbuilder::Al::Model::Api::callStatement do
+                callType :service
+                meta meta
+                operation( operation )
+                name svc
+                yield self if blk
+            end
+            statements( stmt )
+          end
+          def ifThen( condExpression, &blk )
+            stmt =  Sbuilder::Al::Model::Api::conditionalStatement() do
+              condition Sbuilder::Al::Model::Api::expression(condExpression)
+              ifBlock &blk
+            end
+            statements( stmt )
+            stmt
+          end
+          
+          # Build block
+          def statements( v = [] )
+            @statements = @statements || []
+            @statements += v.is_a?( Array ) ? v : [v]
+            self
+          end
+          def build
+            Block.new( type: :block, statements: @statements )
+          end
+        end
+
+        class StatementBuilder
+        end
+        
+        class SkipStatementBuilder < StatementBuilder
+          def labeled(v=nil) @labeled= v.nil? ? true : v; self; end          
+          def build
+            SkipStatement.new( type: :skipStatement, labeled: @labeled )
+          end
+        end
+
+        class ReturnStatementBuilder
+          def status(v=nil) @status=Sbuilder::Al::Model::Api::expression(v); self; end          
+          def expression(v=nil) @expression=Sbuilder::Al::Model::Api::expression(v); self; end
+          def variable(v=nil) @variable=v; self; end
+          def build
+            type =
+              if !@status.nil? && !@expression.nil?
+                :returnStatement
+              elsif !@status.nil?
+                :returnStatus
+              elsif !@variable.nil?
+                :returnValue
+              else
+                raise "Shuld define: variable+expression/status+expression/status"
+              end
+            ReturnStatement.new( type: type, status: @status, expression: @expression, variable: @variable )
+          end
+        end
+
+        class JumpStatementBuilder
+          def label(v=nil) @label=v; self; end          
+          def build
+            JumpStatement.new( type: :jumpStatement, label: @label )
+          end
+        end
+        
+        class ConditionalStatementBuilder
+          def condition(v=nil) @condition=Sbuilder::Al::Model::Api::expression(v); self; end
+          def ifBlock( &blk) @ifBlock=Sbuilder::Al::Model::Api::block( &blk ); self; end
+          def elseBlock( &blk ) @elseBlock=Sbuilder::Al::Model::Api::block( &blk ); self; end
+          def build
+            ConditionalStatement.new( type: :conditionalStatement, condition: @condition, ifBlock: @ifBlock, elseBlock: @elseBlock )
+          end
+        end
+
+        class AssignStatementBuilder
+          # variable referce v1/v2, parameter reference v2
+          def variable(v1=nil, v2=nil); @variable=Sbuilder::Al::Model::Api::reference(v1,v2); self;end
+          def rval(v=nil); @rval=Sbuilder::Al::Model::Api::expression(v); self;end          
+          def build
+            AssignStatement.new( type: :assignStatement, variable: @variable, rval: @rval )
+          end
+        end
+
+        class CallStatementBuilder
+          def callType(v=nil); @callType=v; self;end
+          def meta(v=nil); @meta=v; self;end          
+          def name(v=nil); @name=v; self;end
+          def operation(v=nil); @operation=v; self;end
+          def parameters( v = [] )
+            @parameters = @parameters || []
+            @parameters += v.is_a?( Array ) ? v : [v]
+            self
+          end
+          # convinience methods
+          def parameter( v )
+            parameters( Sbuilder::Al::Model::Api::expression(v) )
+          end
+          def build
+            CallStatement.new( type: :callStatement,
+                               meta: @meta, name: @name, operation: @operation,
+                               callType: @callType, 
+                               parameters:  @parameters
+                             )
+          end
+        end
+        
+
+        class OutputStatementBuilder
+          def expression(v=nil)
+            @expression=Sbuilder::Al::Model::Api::expression(v)
+            self
+          end
+          def build
+            OutputStatement.new( type: :outputStatement, expression: @expression )
+          end
+        end
+
+
+        # @!endgroup        
+
+        # ------------------------------------------------------------------
+        # @!group Parameter set
+
+        class ParameterSetBuilder
+
+          def parameter( name, isArray, domain=nil  )
+            raise "Expect boolean for isArray, isArray='#{isArray}'" unless isArray.is_a?(TrueClass) || isArray.is_a?(FalseClass)
+            v = Sbuilder::Al::Model::Api::property do
+              name( name )
+              isArray( isArray )
+              domain( domain ) unless domain.nil?
+            end
+            properties(v)
+          end
+
+          def reference( name, isArray, definition )
+            v = Sbuilder::Al::Model::Api::property do
+              name( name )
+              isArray( isArray )
+              definition( definition )
+            end
+            properties(v)
+          end
+
+          def properties(v=[])
+            @properties = @properties || []
+            @properties += v.is_a?( Array ) ? v : [v]
+            self
+          end
+
+          # @return [Int] number of elements in @properties
+          def propertiesLength
+            @properties.nil? ? 0 : @properties.length 
+          end
+          
+        end
+
+        class ApiDefinitionBuilder < ParameterSetBuilder
+          def name(v=nil); @name=v; self;end
+        end
+        
+        class DefinitionBuilder < ApiDefinitionBuilder
+          def build( meta=nil)
+            Definition.new( type: :definition, name: @name, properties: @properties )
+          end
+        end
+
+        # Build FunctionDefition using 'inputParameter' and
+        # 'outputParameter' methods, which accept DOMAIN names and
+        # create constant function paramater names, which can
+        # (SHOULD!) be mapped to domain names at some point.
+        class FunctionDefinitionBuilder < ApiDefinitionBuilder
+          # Create parameter 'P{propertiesLength}' with domain assiaction
+          def inputParameter( isArray, domain = nil )
+            # Create names p1, p2, ...
+            # name = "p#{propertiesLength + 1}"
+            name = Sbuilder::Al::Model::Api::inputParameterName(propertiesLength + 1)
+            parameter( name, isArray, domain )
+          end
+          def outputParameter( isArray, domain = nil )
+            # create names ret1, ret2, ...
+            # name = "ret#{ (@returns || []).length + 1 }"
+            name = Sbuilder::Al::Model::Api::outputParameterName( (@returns || []).length + 1)
+            parameter( name, isArray, domain )
+          end
+          # Create parameter 'RET{propertiesLength}' with domain assiaction          
+          def returns( v=[])
+            @returns = @returns || []
+            @returns += v.is_a?( Array ) ? v : [v]
+            self
+          end
+          def build( meta=nil)
+            # Append @returns to last
+            FunctionDefinition.new( type: :function_definition, name: @name, properties: (@properties||[]) + (@returns||[]) )
+          end
+        end
+        
+        class RequestBuilder < ParameterSetBuilder
+          def name(v=nil); @name=v; self;end
+          def build( meta=nil)
+            Request.new( type: :request, name: @name, properties: @properties )
+          end
+        end
+        
+        class ResponseBuilder < ParameterSetBuilder
+          def name(v=nil); @name=v; self;end
+          def build( meta=nil)
+            Response.new( type: :response, name: @name, properties: @properties )
+          end
+        end
+        
+        class PropertyBuilder
+          def name(v=nil); @name=v; self;end
+          def definition(v=nil); @definition=v; self;end
+          def isArray(v=nil); @isArray=v; self;end
+          def domain(v=nil); @domain=v; self;end                    
+          def build( meta=nil)
+            Property.new( type: :property, name: @name,  isArray: @isArray, domain: @domain, definition: @definition  )
+          end
+        end
+        
+
+        
+        # @!endgroup
+        
+        # ------------------------------------------------------------------
+        # @!group Storage
+
+        class LocalBuilder
+          def name(v=nil); @name=v; self;end
+          def build( meta=nil)
+            Local.new( type=:local, name=@name, meta=meta )
+          end
+        end
+
+        class VariableBuilder
+          def name(v=nil); @name=v; self;end
+          def init(v=nil); @init=v; self;end
+          def build( meta=nil)
+            Variable.new( type=:variable, name=@name, meta=meta, init=@init )
+          end
+        end
+
+        class ParameterBuilder
+          def name(v=nil); @name=v; self;end
+          def build( meta=nil)
+            Parameter.new( type=:parameter, name=@name, meta=meta )
+          end
+        end
+        
+        # @!endgroup    
+        # ------------------------------------------------------------------
+        # @!group Expressions
+
+        class ConstantExpressionBuilder
+          def value(v=nil); @value=v; self;end
+          def build( meta=nil)
+            ConstantExpression.new( type: :constant_expression, value:  @value )
+          end
+        end
+
+        class BinaryExpressionBuilder
+          def lval(v=nil); @lval=Sbuilder::Al::Model::Api::expression(v); self;end
+          def op(v=nil); @op=v; self;end
+          def rval(v=nil); @rval=Sbuilder::Al::Model::Api::expression(v); self;end                    
+          def build( meta=nil)
+            BinaryExpression.new( type: :binary_expression, lval:  @lval, op: @op, rval: @rval )
+          end
+        end
+
+        class UnaryExpressionBuilder
+          def expr(v=nil); @expr=Sbuilder::Al::Model::Api::expression(v); self;end
+          def op(v=nil); @op=v; self;end
+          def build( meta=nil)
+            UnaryExpression.new( type: :unary_expression, expr:  @expr, op: @op )
+          end
+        end
+        
+        
+
+        # Valid template names for TlaExpressionBuilder 
+        TLA_TEMPLATES = {
+          :set => ->(gen, *args) { gen.gen_set( args ) },
+          :sequence => ->(gen, *args) { gen.gen_sequence( args ) },
+          :nil => ->(gen, *args) { gen.gen_nilElement( args ) },
+          :parenthesis => ->(gen, expr)  { gen.gen_parenthesis( expr ) },
+          :set_iterate => ->(gen, variable, set ) { gen.gen_set_iterate( variable, set ) },          
+          :set_generate => ->(gen, map, variable, set ) { gen.gen_set_map( map, gen.gen_set_iterate( variable, set )) },
+          :set_select => ->(gen, variable, set, select ) { gen.gen_set_map( gen.gen_set_iterate( variable, set ), select ) },
+          :plainname => ->(gen, name ) { gen.gen_plainname( name ) },          
+          :record_field => ->(gen, record, field ) { gen.gen_record_field( record, field ) },
+          :record_index => ->(gen, record, index ) { gen.gen_record_named_field( record, index ) },
+          :IF_expression => ->(gen, condExpr, thenExpr, elseExpr) { gen.gen_IF( condExpr, thenExpr, elseExpr ) },
+          :operator_call => ->(gen, operator, *arguments ) { gen.gen_operator_call( operator, arguments ) },          
+          :EXCEPT_expression => ->(gen, variable, *excepts) { gen.gen_EXCEPT( variable, excepts ) },
+          # :procedure_call => ->( gen, txName, operationName, params ) { gen.gen_procedure_call( gen.txName2ServiceProcedure( txName, operationName ), params ) },
+          :record_field_definition => ->( gen, name, value ) { gen.gen_record_field_definition( name, value ) },
+          :record => ->( gen, *arrOfFields ) { gen.gen_record_definition( arrOfFields ) },
+        }
+
+        class ParameterizedExpressionBuilder
+          def args(v=nil);
+            @args=@args|| []
+            @args += v.is_a?( Array ) ? v : [v]
+            self;
+          end
+          # convenience builder
+          def arg( v )
+            args( Sbuilder::Al::Model::Api::expression(v) )
+          end
+          
+        end
+
+        class ReferenceExpressionBuilder
+          def reference(v=nil); @reference=Sbuilder::Al::Model::Api::reference(v); self;end
+          def build
+            ReferenceExpression.new( meta: @meta, reference: @reference )
+          end
+        end
+
+        class ReferenceBuilder
+          def fields( fld=nil)
+            if !fld.nil?
+              @fields = @fields||[]
+              @fields << fld
+            end
+          end
+          def name(v=nil); @name=v; self;end          
+        end
+
+        class SimpleReferenceBuilder < ReferenceBuilder
+          def build
+            SimpleReference.new( type: :simple_reference, name: @name, fields:@fields )
+          end
+        end
+        class TxParameterReferenceBuilder < ReferenceBuilder
+          def meta(v=nil); @meta=v; self;end
+          def operation(v=nil); @operation=v; self;end                    
+          def build
+            TxParameterReference.new( type: :tx_parameter_reference, meta: @meta, name: @name, operation: @operation, fields:@fields )
+          end
+        end
+        class VariableReferenceBuilder < ReferenceBuilder
+          def meta(v=nil); @meta=v; self;end          
+          def build
+            VariableReference.new( type: :variable_reference, meta: @meta, name: @name, fields:@fields )
+          end
+        end
+
+        class TlaExpressionBuilder < ParameterizedExpressionBuilder 
+          def getTemplates
+            TLA_TEMPLATES
+          end
+          
+          def template(v=nil); @template=v; self;end
+          def build( meta=nil)
+            raise Sbuilder::Al::Model::Api::ApiError, "Missing 'template' property in tlaExpression - must give one of valid templates: #{getTemplates.keys.join(',')}" if @template.nil?          
+            raise Sbuilder::Al::Model::Api::ApiError, "Unsupported tla template '#{@template}' - valid templates: #{getTemplates.keys.join(',')}" if getTemplates[@template].nil?
+            TlaExpression.new( type: :tla_expression, template: @template, templateEval: getTemplates[@template], args: @args )
+          end
+        end
+        
+        
+        # @!endgroup
+
+        # ------------------------------------------------------------------
+        # @!group Transaction, function, macros etc
+
+        class CallableBuilder
+          def name(v=nil); @name=v; self;end
+        end
+
+        class FunctionCallableBuilder  < CallableBuilder
+          def request(v=nil); @request=v; self;end
+          def locals(v=nil)
+            @locals = @locals || []
+            @locals += v.is_a?( Array ) ? v : [v]
+            self
+          end          
+          def response(v=nil); @response=v; self;end
+          # Convenience methods:
+          def local( v) locals(v);self; end
+          def block(v=nil, &blk )
+            if block_given?
+              @block = Sbuilder::Al::Model::Api::block( &blk )
+            else
+              @block=v
+            end
+            self
+          end          
+        end
+
+        class SnippetBuilder < FunctionCallableBuilder
+          def txt(v) @txt=v; self; end
+          def build(meta)
+            Snippet.new( type: :snippet, meta: meta, name: @name, txt: @txt )
+          end
+        end
+
+        class TransactionBuilder < FunctionCallableBuilder
+          def operation(v=nil) @operation=v; self; end
+          def interfaceOption(v=nil) @interfaceOption=v; self; end
+          def returnOption(v=nil) @returnOption=v; self; end
+          def sourceModule( v ) @sourceModule = v; self; end
+          def sourceLine( v ) @sourceLine = v; self; end
+          def sourceColumn( v ) @sourceColumn = v; self; end                    
+          def build(meta)
+            Transaction.new(
+              type: :transaction, meta: meta, name: @name, operation: @operation, locals: @locals,
+              request: @request, response: @response, block: @block,
+              interfaceOption: @interfaceOption,  returnOption: @returnOption,
+              sourceModule: @sourceModule, sourceLine: @sourceLine, sourceColumn: @sourceColumn )
+          end
+        end
+
+        class FunctionBuilder < FunctionCallableBuilder
+          def build( meta=nil)
+            Function.new( type: :function, meta: meta, name: @name, locals: @locals,
+                             request: @request, response: @response, block: @block  )
+          end
+        end
+
+        class OperatorBuilder
+          def name(v=nil); @name=v; self;end
+          def parameters(v=nil)
+            @parameters = @parameters || []
+            @parameters += v.is_a?( Array ) ? v : [v]
+            self
+          end
+          def rval(v=nil); @rval= v; self; end
+          # Convenience methods:
+          def parameter( v) parameters(v);self; end
+          def expression( e )
+            @rval = Sbuilder::Al::Model::Api::expression( e )            
+            self
+          end
+          # Build action
+          def build( meta=nil)
+            Operator.new( type: :operator, meta: meta, name: @name,
+                          parameters: @parameters,
+                          # rval: @rval || Sbuilder::Al::Model::Api::constantExpression{ value true }
+                          rval: @rval || Sbuilder::Al::Model::Api::expression( true )
+                        )
+          end
+        end
+
+        # Map appName to specName without implementation
+        class AliasBuilder
+          def name(v=nil); @name=v; self;end
+          def specName(v=nil); @specName=v; self;end          
+          # Build action
+          def build( meta=nil )
+            Sbuilder::Al::Model::Alias.new( type: :alias, meta: meta, name: @name, specName: @specName )
+          end
+        end
+        
+        
+        class MacroBuilder
+          def name(v=nil); @name=v; self;end
+          def parameters(v=nil)
+            @parameters = @parameters || []
+            @parameters += v.is_a?( Array ) ? v : [v]
+            self
+          end
+          def block(v=nil, &blk )
+            if block_given?
+              @block = Sbuilder::Al::Model::Api::block( &blk )
+            else
+              @block=v
+            end
+            self
+          end
+          
+          # Convenience methods:
+          def parameter( v) parameters(v);self; end          
+          # Build action
+          def build( meta=nil)
+            Macro.new( type: :macro, meta: meta, name: @name, parameters: @parameters, block: @block )
+          end
+        end
+        
+
+        # @!endgroup        
+        
+        
+      end # builders
+    end # module Model
+  end # module Al
+end  # module Sbuilder