sbuilder-al 0.0.8

data/lib/meta/meta.rb

@@ -0,0 +1,106 @@
+module Sbuilder
+
+  module Al
+    module Meta
+
+      # For patter to create use modules to define class methods
+      # https://stackoverflow.com/questions/10692961/inheriting-class-methods-from-modules-mixins-in-ruby
+
+      def self.included( base)
+        base.extend( Sbuilder::Al::Meta::MetaClassMethods )
+        base.send( :include, Sbuilder::Al::Meta::MetaInstanceMethods ) 
+      end
+
+
+      module MetaInstanceMethods
+      end
+      
+      module MetaClassMethods
+
+        # For implementing descendants
+        # http://www.eq8.eu/blogs/13-ruby-ancestors-descendants-and-other-annoying-relatives update 1
+        def inherited(klass)
+          @descendants ||= []
+          @descendants << klass
+        end
+
+        def descendants
+          @descendants || []
+        end
+        
+        def descendants?
+          descendants.any?
+        end
+
+        def demodulize
+          self.class_name.split("::").last
+        end
+        def class_name
+          self.to_s
+        end
+
+        # Ancestor in meta hierarchy
+        #
+        # @return [Array<Class>] classe in superclass hierarchy
+        # implementing module Sbuilder::Al::Meta, ordered from
+        # top-most class
+        def metaAncestors( hierarchy = [] )
+          hierarchy = self.superclass.metaAncestors(hierarchy) if ( self.superclass.respond_to?( :metaAncestors) )
+          hierarchy << self 
+          hierarchy
+        end
+
+
+        # @return [Array<Symbol>] services symbols added using addService
+        def services
+          @services || []
+        end
+
+        # Define method +op+ implemented by  +proc+ and +block+
+        #
+        # @param op [Symbol] instance method to define
+        #
+        # @param proc [Proc, lambda] method implementation, if nil
+        # use +&blok+ for method implementation
+        #
+        # @param args [Object] arguments curryed to +proc+ or
+        # +&block+
+        #
+        # @param block [Bloc] method implementation, used unless
+        # +proc+ given
+        def addService( op, proc=nil, *args, &block )
+          proc = proc || block
+          if  args.count > 0 then
+            proc = proc.curry[*args]
+          end
+          define_method( op, proc )
+          @services = (@services || [])  << op
+        end
+
+        # @return [Array<Symbol>] attribute names added by +addAttribute+
+        def attributes
+          @attributes||[]
+        end
+
+        # Add attribute +attr+ and 'attr_reader'
+        def attribute_reader( attr )
+          attr_reader( attr )
+          @attributes = ((@attributes || [])  << attr).uniq
+        end
+        # Add attribute +attr+ and 'attr_writer'        
+        def attribute_writer( attr )
+          attr_writer( attr )
+          @attributes = ((@attributes || [])  << attr).uniq
+        end
+        # Add attribute +attr+ and 'attribute_reader' and 'attribute_writer'
+        def attribute_accessor( attr )
+          attribute_reader( attr )
+          attribute_writer( attr )
+          # @attributes = ((@attributes || [])  << attr).uniq
+        end
+
+
+      end
+    end
+  end # Al
+end # Sbuilder

data/lib/model/api.rb

@@ -0,0 +1,678 @@
+require 'docile'
+
+module Sbuilder
+  module Al
+    module Model
+      
+      ##
+      # Api module to include into API object to add privitives to
+      # construct {Sbuilder::Al::Model} application model
+      # objects. Implementation uses docile -Gem and builders classess
+      # in {Sbuilder::Al::Model::Builder}
+      #
+      # Api object primitives includes a configuration, which allows
+      # mapping one "appName" (=name in application namespace) to
+      # several application model elements, each corresponding to a #
+      # unique "specName" (=name in tla- model name space).
+      # 
+      #
+      # Primitives included into an API object fall into the following
+      # categories:
+      #
+      #   * class methods to construct an Api object for building
+      #     {Sbuilder::Al::Model} application model objects
+      #
+      #   * instance attribute to manage appName/specName mapping
+      #
+      #   * instance methods to construct building application model
+      #     objects (using Ruby domain specific language (DSL) implmented
+      #     using Docile GEM.
+      #
+      #
+      module Api
+
+        # not catched
+        class ApiException < Sbuilder::Al::Util::AlException; end
+        # to be catched
+        class ApiError < Sbuilder::Al::Util::AlError; end      
+
+
+        # @!group Class methods
+
+        # For the pattern to use modules in defining class methods
+        # https://stackoverflow.com/questions/10692961/inheriting-class-methods-from-modules-mixins-in-ruby
+
+        def self.included( base)
+          base.extend( ClassMethods )
+          # base.send( :include, Sbuilder::Al::Meta::MetaInstanceMethods ) 
+        end
+
+        module ClassMethods
+
+
+          
+          def create( metaDefs={} )
+            warn "Sbuilder::Al::Model.create depracted - use Sbuilder::Al::Model.start, instead"
+            start( metaDefs  )
+            # o = self.new
+            # o.metaDefs = metaDefs
+            # o
+          end
+
+          # Construct an api object with and initialize 'metaDefs' attribute
+          #
+          # @param metaDefs [Hash] see {Sbuilder::Al::Model::Api#metaDefs} meta
+          #     definition configuration to set
+          #
+
+          def start(  metaDefs  )
+            o = self.new
+            o.metaDefs = metaDefs
+            o
+          end
+          
+        end
+
+        # @!endgroup
+
+        # ------------------------------------------------------------------
+        # @!group Attributes
+
+        # @!attribute metaDefs [Hash]
+        #
+        # Allow mapping "appName" in application namespace to several
+        # "specNames" in tla-model namespace. Application build
+        # methods 'meta' -attribute to be a key in 'metaDefs' hash.
+        # 
+        # * key [String] application build method 'meta' attribute
+        #                must be a valid key in 'metaDefs'
+        #
+        # * value [Hash] metatype definition
+        #     * :description [String] a short summary of the metatype
+        #
+        #     * :prefix [String] optional, allow fixed string to be
+        #                        prefixed to 'appName' to create an
+        #                        unique 'specName', normally nil/not
+        #                        defined to allow sbuilder facade to
+        #                        choose prefix
+        attr_writer :metaDefs
+
+        def metaDefs
+          return @metaDefs || {}
+        end
+
+        # @!endgroup
+
+        # ------------------------------------------------------------------
+        # @!group Private methods
+        def lookupMeta( meta )
+          return meta if Sbuilder::Al::Plugin::Plugin.sbuilderMetatype?( meta )
+          raise ApiError, "Unknown meta '#{meta}', valid metas=#{metaDefs.keys.join(',')}" unless metaDefs.key?( meta )
+          meta
+        end
+        
+        # @!endgroup
+        
+        # ------------------------------------------------------------------
+        # @!group  defines & parameter sets
+
+
+        def domain( &block )
+          Docile.dsl_eval( Sbuilder::Al::Model::Builders::DomainBuilder.new, &block ).build
+        end
+
+        def definition( &block )
+          Docile.dsl_eval( Sbuilder::Al::Model::Builders::DefinitionBuilder.new, &block ).build
+        end
+        def functionDefinition( &block )
+          Docile.dsl_eval( Sbuilder::Al::Model::Builders::FunctionDefinitionBuilder.new, &block ).build
+        end
+        def property( &block )
+          Docile.dsl_eval( Sbuilder::Al::Model::Builders::PropertyBuilder.new, &block ).build
+        end
+        module_function :property
+        public :property
+
+        def request( &block )
+          Docile.dsl_eval( Sbuilder::Al::Model::Builders::RequestBuilder.new, &block ).build
+        end
+        
+        def response( &block )
+          Docile.dsl_eval( Sbuilder::Al::Model::Builders::ResponseBuilder.new, &block ).build
+        end
+
+        # @!endgroup
+
+        
+        # ------------------------------------------------------------------
+        # @!group tx, macro function, operator
+
+        
+
+        def transaction( meta, &block )
+          Docile.dsl_eval( Sbuilder::Al::Model::Builders::TransactionBuilder.new, &block ).build(lookupMeta(meta))
+        end
+
+        def snippet( meta, &block)
+          # block = Proc.new{
+          #   expression msg
+          # } if block.nil?
+          Docile.dsl_eval( Sbuilder::Al::Model::Builders::SnippetBuilder.new, &block ).build(lookupMeta(meta))
+        end
+        
+        # def function( meta, &block )
+        #   Docile.dsl_eval( Sbuilder::Al::Model::Builders::FunctionBuilder.new, &block ).build(lookupMeta(meta))
+        # end
+        
+        def operator( meta, &block )
+          Docile.dsl_eval( Sbuilder::Al::Model::Builders::OperatorBuilder.new, &block ).build(lookupMeta(meta))
+        end
+        
+        def macro( meta, &block )
+          Docile.dsl_eval( Sbuilder::Al::Model::Builders::MacroBuilder.new, &block ).build(lookupMeta(meta))
+        end
+
+        def aliased( meta, &block )
+          Docile.dsl_eval( Sbuilder::Al::Model::Builders::AliasBuilder.new, &block ).build(lookupMeta(meta))
+        end
+        # storage
+
+        def local( meta,  &block )
+          Docile.dsl_eval( Sbuilder::Al::Model::Builders::LocalBuilder.new, &block ).build( lookupMeta(meta) )
+        end
+
+        def variable( meta,  &block )
+          Docile.dsl_eval( Sbuilder::Al::Model::Builders::VariableBuilder.new, &block ).build( lookupMeta(meta) )
+        end
+
+        def parameter( meta,  &block )
+          Docile.dsl_eval( Sbuilder::Al::Model::Builders::ParameterBuilder.new, &block ).build( lookupMeta(meta) )
+        end
+
+
+        # @!endgroup
+
+
+        # ------------------------------------------------------------------
+        # @!group expression
+
+        
+
+
+        # 
+
+        def expression( e )
+          if ( e.is_a?(Symbol) && Constants::CONSTANT_EXPRESSIONS[e] )
+            constantExpression do
+              value e
+            end
+          else
+            case e
+            when String, Numeric, TrueClass, FalseClass
+              constantExpression do
+                value e
+              end
+            when Array
+              e.map{ |arrayElement| expression(arrayElement) }
+            when Sbuilder::Al::Model::Expression
+              e
+            when Sbuilder::Al::Model::Reference
+              referenceExpression do
+                reference e
+              end
+            else
+              raise raise ApiError, "Missing implementation for #{e.class}: #{e}"
+            end
+          end
+          end
+        module_function :expression
+        public :expression
+
+        def constantExpression(val=nil, &block )
+          block = Proc.new{
+            value val
+          } if block.nil? || !val.nil?
+          
+          Docile.dsl_eval( Sbuilder::Al::Model::Builders::ConstantExpressionBuilder.new, &block ).build
+        end
+        module_function :constantExpression
+        public :constantExpression
+
+        def referenceExpression( &block )
+          Docile.dsl_eval( Sbuilder::Al::Model::Builders::ReferenceExpressionBuilder.new, &block ).build
+        end
+        module_function :referenceExpression
+        public :referenceExpression
+        
+
+        def binaryExpression( &block )
+          Docile.dsl_eval( Sbuilder::Al::Model::Builders::BinaryExpressionBuilder.new, &block ).build
+        end
+        module_function :binaryExpression
+        public :binaryExpression
+
+        def unaryExpression( &block )
+          Docile.dsl_eval( Sbuilder::Al::Model::Builders::UnaryExpressionBuilder.new, &block ).build
+        end
+        module_function :unaryExpression
+        public :unaryExpression
+
+        def not( exprission, &block )
+          block = Proc.new{
+            op :not
+            expr exprission
+          } if block.nil? || !val.nil?
+          Docile.dsl_eval( Sbuilder::Al::Model::Builders::UnaryExpressionBuilder.new, &block ).build
+        end
+        module_function :not
+        public :not
+
+        def plus( l, r )
+          binaryExpression do
+            op :plus
+            lval expression(l)
+            rval expression(r)
+          end
+        end
+        module_function :plus
+        public :plus
+        
+        def and( l, r )
+          binaryExpression do
+            op :and
+            lval expression(l)
+            rval expression(r)
+          end
+        end
+        module_function :and
+        public :and
+
+        def or( l, r )
+          binaryExpression do
+            op :or
+            lval expression(l)
+            rval expression(r)
+          end
+        end
+        module_function :or
+        public :or
+
+        def minus( l, r )
+          binaryExpression do
+            op :minus
+            lval expression(l)
+            rval expression(r)
+          end
+        end
+        module_function :minus
+        public :minus
+
+        def equal( l, r )
+          binaryExpression do
+            op :equal
+            lval expression(l)
+            rval expression(r)
+          end
+        end
+        module_function :equal
+        public :equal
+        
+        def unequal( l, r )
+          binaryExpression do
+            op :unequal
+            lval expression(l)
+            rval expression(r)
+          end
+        end
+        module_function :unequal
+        public :unequal
+        
+
+        def tlaExpression( &block )
+          Docile.dsl_eval( Sbuilder::Al::Model::Builders::TlaExpressionBuilder.new, &block ).build
+        end
+        module_function :tlaExpression
+        public :tlaExpression
+
+        def tlaSet( *args, &block )
+          args = args.map{ |a| expression(a) } unless args.nil?
+          tlaExpression do
+            template :set
+            args args
+          end
+        end
+        module_function :tlaSet
+        public :tlaSet
+
+        def tlaNil
+          tlaExpression do
+            template :nil
+          end
+        end
+        module_function :tlaNil
+        public :tlaNil
+        
+        def tlaPlainname( name )
+          tlaExpression do
+            template :plainname
+            args name
+          end
+        end
+        module_function :tlaPlainname
+        public :tlaPlainname
+
+        def tlaParenthesis( expr )
+          tlaExpression do
+            template :parenthesis
+            args expression(expr)
+          end
+        end
+        module_function :tlaParenthesis
+        public :tlaParenthesis
+
+        # @param map [tlaExpressio] expression generatin the set
+        # @param variable [String] to iterate
+        # @param set [String] base set used to generate in map expression 
+        def tlaSetGenerate( map, variable, set  )
+          tlaExpression do
+            template :set_generate
+            args( expression(map) )
+            args( variable )
+            args( set )                        
+          end
+        end
+        module_function :tlaSetGenerate
+        public :tlaSetGenerate
+
+        # @param variable [String] used to iterate
+        # @param set [String]  to iterate 
+        def tlaSetIterate( variable, set  )
+          tlaExpression do
+            template :set_iterate
+            args( variable )
+            args( set )                        
+          end
+        end
+        module_function :tlaSetIterate
+        public :tlaSetIterate
+
+        
+
+        def tlaSetSelect( variable, set, select  )
+          tlaExpression do
+            template :set_select
+            args( variable )
+            args( set )
+            args( select )                        
+          end
+        end
+        module_function :tlaSetSelect
+        public :tlaSetSelect
+        
+
+        def tlaIF( condition, thenExpr, elseExpr  )
+          tlaExpression do
+            template :IF_expression
+            args( condition )
+            args( thenExpr )
+            args( elseExpr )                        
+          end
+        end
+        module_function :tlaIF
+        public :tlaIF
+        
+        
+        def tlaEXCEPT( variable, excepts  )
+          tlaExpression do
+            template :EXCEPT_expression
+            args( variable )
+            args( excepts )
+          end
+        end
+        module_function :tlaEXCEPT
+        public :tlaEXCEPT
+
+        def tlaRecordField( record, field  )
+          tlaExpression do
+            template :record_field
+            args( record )            
+            args( field )
+          end
+        end
+        module_function :tlaRecordField
+        public :tlaRecordField
+
+        
+        def tlaRecordIndex( record, index  )
+          tlaExpression do
+            template :record_index
+            args( record )            
+            args( index )
+          end
+        end
+        module_function :tlaRecordIndex
+        public :tlaRecordIndex
+        
+
+        def tlaRecord( fields  )
+          tlaExpression do
+            template :record
+            args( fields )
+          end
+        end
+        module_function :tlaRecord
+        public :tlaRecord
+
+        def tlaRecordFieldDef( name, value  )
+          tlaExpression do
+            template :record_field_definition
+            args( name )
+            args( value )            
+          end
+        end
+        module_function :tlaRecordFieldDef
+        public :tlaRecordFieldDef
+        
+        def tlaOperatorCall( operator, arguments  )
+          tlaExpression do
+            template :operator_call
+            args( operator )
+            args( arguments )            
+          end
+        end
+        module_function :tlaOperatorCall
+        public :tlaOperatorCall
+
+        
+        def tlaSequence( *args, &block )
+          args = args.map{ |a| expression(a) } unless args.nil?
+          tlaExpression do
+            template :sequence
+            args args
+          end
+        end
+        module_function :tlaSequence
+        public :tlaSequence
+
+        # @!endgroup
+        
+
+        # ------------------------------------------------------------------
+        # @!group references
+
+        
+
+
+        def reference( v1, v2=nil )
+          if v1.is_a?(Sbuilder::Al::Model::Reference )
+            return v1
+          elsif v1.is_a?(String) 
+            simpleReference(v1, v2)
+          elsif v1.is_a?(Array) && v1.length == 1
+            simpleReference( *v1, v2)
+          elsif v1.is_a?(Array) && v1.length == 2
+            variableReference( *v1, v2 )
+          elsif v1.is_a?(Array) && v1.length == 3
+            txParameterReference( *v1, v2 )
+          else
+            raise raise ApiError, "Missing implementation for #{v1.class}: #{v1} and #{v2.class}: #{v2}"
+          end
+        end
+        module_function :reference
+        public :reference
+
+        # refering named 'parameter'
+        def simpleReference( parameterName, fldArray=nil )
+          fldArray = [ fldArray ] unless fldArray.nil? || fldArray.is_a?(Array)
+          # define block for builder
+          block = Proc.new{
+            name parameterName
+            fldArray && fldArray.each do |fld|
+              fields fld
+            end
+          } 
+          Docile.dsl_eval( Sbuilder::Al::Model::Builders::SimpleReferenceBuilder.new, &block ).build
+        end
+        module_function :simpleReference
+        public :simpleReference
+
+        # refering to a state 'variable' in namespace 'meta'
+        def variableReference( meta, variable, fldArray=nil )
+          fldArray = [ fldArray ] unless fldArray.nil? || fldArray.is_a?(Array)
+          # define block for builder
+          block = Proc.new{
+            meta meta
+            name variable
+            fldArray && fldArray.each do |fld|
+              fields fld
+            end
+          } 
+          Docile.dsl_eval( Sbuilder::Al::Model::Builders::VariableReferenceBuilder.new, &block ).build
+        end
+        module_function :variableReference
+        public :variableReference
+        
+        # refering to a state 'variable' in namespace 'meta'
+        def txParameterReference( meta, variable, op, fldArray=nil )
+          fldArray = [ fldArray ] unless fldArray.nil? || fldArray.is_a?(Array)
+          # define block for builder
+          block = Proc.new{
+            meta meta
+            name variable
+            operation op
+            fldArray && fldArray.each do |fld|
+              fields fld
+            end
+          } 
+          Docile.dsl_eval( Sbuilder::Al::Model::Builders::TxParameterReferenceBuilder.new, &block ).build
+        end
+        module_function :txParameterReference
+        public :txParameterReference
+
+        # @!endgroup
+
+        # ------------------------------------------------------------------
+        # @!group statements
+
+
+
+
+        
+        def block( &block )
+          Docile.dsl_eval( Sbuilder::Al::Model::Builders::BlockBuilder.new, &block ).build
+        end
+        module_function :block
+        public :block
+
+        def outputStatement( msg="",  &block )
+          # allow skip without block
+          block = Proc.new{
+            expression msg
+          } if block.nil?
+          Docile.dsl_eval( Sbuilder::Al::Model::Builders::OutputStatementBuilder.new, &block ).build
+        end
+        module_function :outputStatement
+        public :outputStatement
+
+        def returnStatement( &block )
+          Docile.dsl_eval( Sbuilder::Al::Model::Builders::ReturnStatementBuilder.new, &block ).build
+        end
+        module_function :returnStatement
+        public :returnStatement
+        
+        def jumpStatement( lab, &block )
+          block = Proc.new{ label lab } if block.nil?
+          Docile.dsl_eval( Sbuilder::Al::Model::Builders::JumpStatementBuilder.new, &block ).build
+        end
+        module_function :jumpStatement
+        public :jumpStatement
+        
+        def assignStatement( &block )
+          # allow skip without block
+          Docile.dsl_eval( Sbuilder::Al::Model::Builders::AssignStatementBuilder.new, &block ).build
+        end
+        module_function :assignStatement
+        public :assignStatement
+
+        def callStatement( &block )
+          # allow skip without block
+          block = Proc.new{} if block.nil?
+          Docile.dsl_eval( Sbuilder::Al::Model::Builders::CallStatementBuilder.new, &block ).build
+        end
+        module_function :callStatement
+        public :callStatement
+
+        def conditionalStatement( &block )
+          Docile.dsl_eval( Sbuilder::Al::Model::Builders::ConditionalStatementBuilder.new, &block ).build
+        end
+        module_function :conditionalStatement
+        public :conditionalStatement
+
+        def skipStatement( &block )
+          # allow skip without block
+          block = Proc.new{} if block.nil?
+          Docile.dsl_eval( Sbuilder::Al::Model::Builders::SkipStatementBuilder.new, &block ).build
+        end
+        module_function :skipStatement
+        public :skipStatement
+        alias_method :skip, :skipStatement
+        
+        # @!endgroup
+
+        # ------------------------------------------------------------------
+        # @!group str constants
+
+        def self.strLabelEnd( interfaceOperation )
+          "#{interfaceOperation}#{Sbuilder::Al::Translator::TlaGenerator::TLA_LABEL_END}"          
+        end
+        def self.strLabelAbort( interfaceOperation )
+          "#{interfaceOperation}#{Sbuilder::Al::Translator::TlaGenerator::TLA_LABEL_ABORT}"
+        end
+        def self.strLabelFail( interfaceOperation )
+          "#{interfaceOperation}#{Sbuilder::Al::Translator::TlaGenerator::TLA_LABEL_FAIL}"
+        end
+
+        # @return [String] name of i-th input parameter to FunctionDefinition
+        def self.inputParameterName(i=1)
+          "p#{i}"
+        end
+        def inputParameterName(i=1)
+          Api.inputParameterName( i )
+        end
+        
+
+        # @return [String] name of i-th output parameter to FunctionDefinition        
+        def self.outputParameterName(i=1)
+          "ret#{i}"
+        end
+        def outputParameterName(i=1)
+          Api.outputParameterName( i )
+        end
+        
+        # @!endgroup
+
+        
+      end
+    end
+  end
+end