sbuilder-al 0.0.8

data/lib/model/constants.rb

@@ -0,0 +1,24 @@
+module Sbuilder
+  module Al
+    module Model
+      class Constants
+
+        # ------------------------------------------------------------------
+        # @!group Expression values
+
+
+        CONSTANT_EXPRESSION_NIL = :nil
+        CONSTANT_EXPRESSION_EMPTY = :empty
+
+        CONSTANT_EXPRESSIONS = {
+          CONSTANT_EXPRESSION_EMPTY => '{}',
+          CONSTANT_EXPRESSION_NIL => 'Nil',
+        }
+        
+
+        # @!endgroup
+
+      end #  class Constants
+    end
+  end
+end

data/lib/model/model.rb

@@ -0,0 +1,534 @@
+module Sbuilder
+  module Al
+
+    ##
+    # Application model POJO classes
+    module Model
+
+      # not catched
+      class ModelException < Exception; end
+      # to be catched
+      class ModelError < Exception; end      
+
+      ##
+      # Top level class in application object {Sbuilder::Al::Model}
+      # class hierarchy.
+      #
+      # Implementation set instance variable
+      # {Sbuilder::Al::Model::RootObject#type} in initialize to identify
+      # application object class.  Operator
+      # {Sbuilder::Al::Model::RootObject#[]} walk up class hierarchy, when
+      # looking up for a property.
+      #
+      # Implementation includes {Sbuilder::Al::Meta} module to add
+      # primitives such as 'descendants' instance method, a
+      # attribute_reader, attribute_write, and attribute_accessor.
+      # 
+      #
+      #
+      
+      class RootObject
+        # Include meta services available also for
+        # sub.classes. Example of a meta svc 'attribute_reader'
+        include Sbuilder::Al::Meta
+
+        # @!attribute type [Symbol]
+        #     model element type (=class name)
+        # All objects under RootObject -hierarchy define type, 
+        # defined using 'attr_reader', which does not show up 
+       # meta-documentation
+        attr_reader :type
+
+        
+        # @param type [Symbol] model element type (=class name)
+        def initialize( type: nil )
+          @type = type
+        end
+
+        # Lookup instance attribute in object, or in its parent.
+        #
+        # Implementation:
+        # 1) checks if object defines attr_reader :k
+        # 2) delegates to parent ( unless is RootObject of hierarch )
+        # 3) thrown an error 'No property found'
+        #
+        # @param k [Symbol] name of attribute to lookup for
+        #
+        # @return [RootObject] attribute value 'k' found in self or in
+        #          ancestor classes, ModelError if attribute 'k'
+        #          unknown
+        #
+        # @raise [ModelError] "No property found" - for unknown property 
+        #
+        def [](k)
+          # I know how to resolve :k my self
+          return self.public_send( k ) if self.respond_to?( k )
+          # I delegate [] to my parent - if applicable
+          return self.superclass.[](k) unless self..instance_of?( RootObject )
+          # Not found
+          raise ModelError, "No property found '#{k}' in #{self.to_s}"
+        end
+
+        # Dump AL object with indentation indented with level +indent+ 
+        #
+        def strOutput( level=999, indent=0, start=""  )
+          return "" if level <= 0
+          attributeLines = self.class.metaAncestors.map do |kl|
+            kl.attributes.map do |attr|
+
+              if self[attr].is_a?( Array)
+                if !self[attr].empty?
+                  arrPrefix = self[attr][0].respond_to?(:strOutput) ? ( level > 1 ? "\n" : ""  ) : ""
+                  arrSep = self[attr][0].respond_to?(:strOutput) ? "" : ""
+                  arrPostix = self[attr][0].respond_to?(:strOutput) ? ( level > 1 ? "\n" : ""  ) : ","
+                end
+
+              end
+              
+              " " *( (indent +1 )*4) +
+                # name of attribute
+                attr.to_s + "=" +
+                ( self[attr].respond_to?(:strOutput) ?
+                    # recursion would not output anything
+                    ( level > 1 ? "\n" : ""  ) + 
+                    + self[attr].strOutput( level-1,indent + 2) :
+                    ( self[attr].is_a?( Array) ?
+                        (
+                          # empty array printed []
+                          self[attr].empty? ? [].to_s :
+                            # array with some content
+                            # arrPrefix + self[attr].map{ |a| a.respond_to?(:strOutput) ? a.strOutput( level-1,indent + 2) : (" " *( (indent +1 )*4) + a.to_s) }.join(arrPostix)
+                            arrPrefix + self[attr].map do |a|
+                            a.respond_to?(:strOutput) ?
+                              (a.strOutput( level-1,indent + 2, "\n" ) + arrSep ) :
+                              (" " + a.to_s )
+                          end.join(arrPostix)
+                        ) :
+                        # simple ruby attribute
+                        self[attr].to_s
+                    ))
+            end
+          end.flatten
+
+          str =
+            <<~HERE
+          #{start}#{" " *( (indent +0 )*4)}#{self.class.to_s} do
+          #{attributeLines.join("\n" ) }
+          #{" " *( (indent +0 )*4)}end
+          HERE
+          # remove last \n
+          str.rstrip
+        end
+      end
+
+
+      ##
+      # Domain definition
+      #
+      class Domain < RootObject
+        attribute_accessor :name
+        attribute_accessor :values
+        alias_method :appName, :name
+        def initialize( type: nil, name: nil, values: nil )
+          self.name = name
+          self.values = values || []
+          super( type: type )
+        end
+      end
+
+      ## Storage types
+      class Storage < RootObject
+        attribute_accessor :name
+        attribute_accessor :meta
+        attribute_accessor :init
+        def initialize( type=nil, name=nil, meta=nil, init=nil )
+          self.name = name
+          self.meta = meta
+          self.init = init
+          super( type: type )
+        end
+      end
+      class Variable < Storage
+        alias_method :appName, :name
+      end
+      class Parameter < Storage
+      end
+      class Local < Storage
+        def initialize( type=nil, name=nil, meta=nil )
+          super( type=type, name=name, meta=meta )
+        end
+      end
+
+      ## Statements
+
+      class Block < RootObject
+        attribute_accessor :statements
+        def initialize( type: nil, statements: [] )
+          self.statements = statements || []
+          super( type: type )
+        end
+      end
+      
+      class Statement < RootObject
+      end
+      class SkipStatement < Statement
+        attribute_accessor :labeled
+        def initialize( type: nil, labeled: nil )
+          self.labeled = labeled.nil? ? false : labeled
+          super( type: type )
+        end
+      end
+
+      # Return statement types 1) :returnValue (variable && expression
+      # non nil) 2) :returnStatement (status + expression non nil)
+      #
+      class ReturnStatement < Statement
+        attribute_accessor :status
+        attribute_accessor :expression
+        attribute_accessor :variable      
+        def initialize( type: nil, status: nil, expression: nil, variable: nil )
+          self.status = status
+          self.expression = expression
+          self.variable = variable
+          super( type: type )
+        end
+        
+      end
+      class JumpStatement < Statement
+        attribute_accessor :label
+        def initialize( type: nil, label: nil )
+          self.label = label
+          super( type: type )
+        end
+      end
+      
+      class ConditionalStatement < Statement
+        attribute_accessor :condition
+        attribute_accessor :ifBlock
+        attribute_accessor :elseBlock
+
+        # used in build block
+        def elseThen( &blk )
+          self.elseBlock = Sbuilder::Al::Model::Api::block( &blk )
+        end
+        
+        def initialize( type: nil, condition: nil, ifBlock: nil, elseBlock: nil )
+          self.condition = condition
+          self.ifBlock = ifBlock
+          self.elseBlock = elseBlock || false
+          super( type: type )
+        end
+      end
+      class CallStatement < Statement
+        
+        attribute_accessor :meta           # of 'called'
+        attribute_accessor :name           # method bening called
+        attribute_accessor :operation      # for callType :service
+        attribute_accessor :callType       # constant :service
+        attribute_accessor :parameters
+        def parameter( v )
+          self.parameters += v.is_a?( Array ) ? v : [v]
+        end
+        
+        def initialize( type: nil, meta: nil, name:nil, callType: nil, parameters: nil, operation: nil )
+          self.callType = callType
+          self.name = name
+          self.meta = meta
+          self.operation = operation
+          self.parameters = parameters || []
+          super( type: type )
+        end
+      end
+      class OutputStatement < Statement
+        attribute_accessor :expression
+        def initialize( type: nil, expression: nil )
+          self.expression = expression
+          super( type: type )
+        end
+      end
+      class DataManipulationStatement < Statement
+        attribute_accessor :variable # of ReferenceExpresion
+        def initialize( type: nil, variable: nil )
+          self.variable = variable
+          super( type: type )
+        end
+      end
+      class AssignStatement < DataManipulationStatement
+        attribute_accessor :rval
+        def initialize( type: nil, variable: nil, rval: nil )
+          self.rval = rval
+          super( type: type, variable: variable  )
+        end
+      end
+
+      ## Expression
+      class Expression  < RootObject
+        def initialize( type: nil )
+          super( type: type )
+        end
+      end
+
+      class BinaryExpression < Expression
+        attribute_accessor :lval
+        attribute_accessor :op
+        attribute_accessor :rval
+        def initialize( type: nil, lval: nil, op: nil, rval: nil )
+          self.lval = lval
+          self.op = op
+          self.rval = rval
+          super( type: type )
+        end
+      end
+
+      class UnaryExpression < Expression
+        attribute_accessor :op
+        attribute_accessor :expr
+        def initialize( type: nil, expr: nil, op: nil )
+          self.expr = expr
+          self.op = op
+          super( type: type )
+        end
+      end
+      
+
+      class ReferenceExpression < Expression
+        attribute_accessor :reference           # of type Reference
+        def initialize( meta: nil, reference: nil )
+          self.reference = reference
+          super( type: :reference_expression )
+        end
+      end
+
+      class ParameterizedExpression < Expression
+        attribute_accessor :args        
+        def initialize( type: nil, args: nil )
+          self.args = args || []
+          super( type: type )
+        end
+      end
+
+      class TlaExpression < ParameterizedExpression
+        # Lamba not documented
+        attr_accessor :templateEval
+        attribute_accessor :template
+        def initialize( type: nil, template: nil, templateEval: nil, args: nil )
+          self.template = template
+          self.templateEval = templateEval
+          super( type: type, args: args )
+        end
+      end
+      
+      class ConstantExpression < Expression
+        attribute_accessor :value
+        def initialize( type: nil, value: nil )
+          self.value = value
+          super( type: type )
+        end
+        
+      end
+      
+      # References
+      class Reference  < RootObject
+        attribute_accessor :name
+        attribute_accessor :fields
+        def initialize( type: nil, name: nil, fields: nil )
+          self.name = name
+          self.fields = fields 
+          super( type: type )
+        end
+      end
+      class TxParameterReference  < Reference
+        attribute_accessor :meta
+        attribute_accessor :operation        
+        def initialize( type: nil, name: nil, meta: nil, operation: nil, fields: nil )
+          self.meta = meta
+          self.operation = operation
+          super( type: type, name: name, fields: fields )
+        end
+      end
+      class VariableReference  < Reference
+        attribute_accessor :meta
+        def initialize( type: nil, name: nil, meta: nil, fields: nil )
+          self.meta = meta
+          super( type: type, name: name, fields: fields )
+        end
+      end
+      
+      class SimpleReference  < Reference
+        def initialize( type: nil, name: nil, fields: nil )
+          super( type: type, name: name, fields: fields )
+        end
+      end
+      
+      # Callables
+      class Callable < RootObject
+        attribute_accessor :name
+        def initialize( type: nil, name: nil  )
+          self.name = name
+          super( type: type )
+        end
+      end
+
+      # allow free text to entered into tla-code
+      class Snippet < Callable
+        alias_method :appName, :name
+        attribute_accessor :meta
+        attribute_accessor :txt
+        def initialize( type: nil, name: nil, meta: nil, txt: nil )
+          self.meta = meta
+          self.txt = txt
+          super( type: type, name: name )
+        end
+      end
+      
+      class Alias < Callable
+        attribute_accessor :meta
+        alias_method :appName, :name
+        attribute_accessor :specName
+        def initialize( type: nil, name: nil, meta: nil, specName: nil )
+          self.meta = meta
+          self.specName = specName
+          super( type: type, name: name )
+        end
+      end
+      
+      class ParameterizedCallable < Callable
+        attribute_accessor :parameters
+        def initialize( type: nil, name: nil, parameters: nil  )
+          @parameters = parameters || []
+          super( type: type, name: name  )
+        end
+      end
+      class FunctionTypeCallable < Callable
+        attribute_accessor :request
+        attribute_accessor :locals
+        attribute_accessor :response
+        attribute_accessor :block
+        def initialize( type: nil, name: nil, request: nil, response: nil, locals: nil, block: nil  )
+          self.request = request
+          self.response = response
+          self.locals = locals || [] # empty array (of local variables)
+          self.block = block || []  # empty array (of statements)
+          super( type: type, name: name )
+        end
+      end
+      class Transaction < FunctionTypeCallable
+        # alias_method :appName, :name
+        def appName
+          "#{name}(#{operation})"
+        end
+        attribute_accessor :returnOption
+        attribute_accessor :interfaceOption
+        attribute_accessor :meta
+
+        # attribute_accessor :entryBlock        
+        # attribute_accessor :exitBlock
+        attribute_accessor :operation
+
+        # Meta data not shown in documentation
+        attr_accessor :sourceModule
+        attr_accessor :sourceLine
+        attr_accessor :sourceColumn        
+        
+        def initialize( type: nil, meta: nil, name: nil, operation: nil,
+                        request: nil, response: nil, locals: nil, block: nil, interfaceOption: false,  returnOption: false, sourceModule: nil, sourceLine: nil, sourceColumn: nil )
+          self.meta = meta
+          self.operation = operation
+          self.sourceModule = sourceModule
+          self.sourceLine = sourceLine
+          self.sourceColumn = sourceColumn
+          self.returnOption = returnOption
+          self.interfaceOption = interfaceOption
+          super( type: type, name: name, request: request, response: response,
+                 locals: locals, block: block )
+        end
+      end
+      # class Function < FunctionTypeCallable
+      #   alias_method :appName, :name
+      #   attribute_accessor :meta
+      #   def initialize( type: nil, name: nil, meta: nil, request: nil, response: nil, locals: nil, block: nil  )
+      #     self.meta = meta
+      #     super( type: type, name: name, request: request, response: response, locals: locals, block: block  )          
+      #   end
+      # end
+      class Macro < ParameterizedCallable
+        alias_method :appName, :name
+        attribute_accessor :meta
+        attribute_accessor :block
+        def initialize( type: nil, meta: nil, name: nil, parameters: nil, block: nil )
+          self.block = block || []  # empty array (of statements)
+          self.meta = meta
+          super( type: type, name: name, parameters: parameters )
+        end
+      end
+      class Operator < ParameterizedCallable
+        alias_method :appName, :name
+        attribute_accessor :meta
+        attribute_accessor :rval
+        def initialize( type: nil, meta: nil, name: nil, parameters: nil, rval: nil )
+          self.rval = rval
+          self.meta = meta
+          super( type: type, name: name, parameters: parameters )
+        end
+      end
+
+      # Parameter sets
+      class Property < RootObject
+        attribute_accessor :name
+        attribute_accessor :isArray
+        alias_method :appName, :name
+        attribute_accessor :domain
+        attribute_accessor :definition
+        def initialize( type: nil, name: nil, domain: nil, definition: nil, isArray: false)
+          self.name = name
+          self.domain = domain
+          self.isArray = isArray.nil? ? false : isArray
+          self.definition = definition
+          super( type: type )
+        end
+      end
+
+      class ParameterSet < RootObject
+        attribute_accessor :properties
+        def initialize( type: nil, properties: nil )
+          self.properties = properties
+          super( type: type )
+        end
+      end
+
+      class ApiDefinition < ParameterSet
+        attribute_accessor :name
+        alias_method :appName, :name
+        def initialize( type: nil, name: nil, properties: nil )
+          self.name = name
+          super( type: type, properties: properties )
+        end
+      end
+
+      # Api Type Definition
+      class Definition < ApiDefinition
+      end
+      
+      # Api Type Definition
+      class FunctionDefinition < ApiDefinition
+      end
+      
+      class Request < ParameterSet
+        attribute_accessor :name
+        def initialize( type: nil, name: nil, properties: nil )
+          self.name = name
+          super( type: type, properties: properties )
+        end
+        
+      end
+      class Response < ParameterSet
+        attribute_accessor :name
+        def initialize( type: nil, name: nil, properties: nil )
+          self.name = name
+          super( type: type, properties: properties )
+        end
+      end
+      
+    end # module Model
+  end # module Al
+end  # module Sbuilder