sbuilder-ial 0.0.1

data/lib/model/model_dsl.rb

@@ -0,0 +1,1038 @@
+module Sbuilder
+  module Ial
+    module Model
+
+      class ModelDslException < Exception; end
+
+      # ------------------------------------------------------------------
+      # DSL classes
+      
+
+      # DSL elements
+
+      Library = Struct.new( :type, :name, :modules )
+      
+      Domain = Struct.new( :type, :name,  )
+      # Property = Struct.new( :type, :name, Constants::IAL_DOMAIN, :domain_ref )
+      Property = Struct.new( :type, :name )
+      class Property
+        attr_accessor :domain
+        attr_accessor :definition        
+        def [](k)
+          return domain if k == :domain
+          return definition if k == :definition
+          super( k )
+        end
+      end
+
+      # Block
+      Block = Struct.new( :type, :statements )
+      class Block
+        # number of statements
+        def steps
+          (statements || []).length
+        end
+      end
+
+      # Storage
+      Storage = Struct.new( :type, :name, :init )
+      class Variable < Storage
+      end
+      class Local < Storage
+      end
+      class Parameter < Storage
+      end
+
+      # Statement
+      Statement  = Struct.new( :type )
+      class PrintStatement < Statement
+        attr_accessor :expression
+        alias_method :msg, :expression
+        def [](k)
+          return expression if k == :expression || k == :msg
+          super( k )
+        end
+      end
+      class SkipStatement < Statement
+      end
+
+      # data maninpulations 
+      class DataManipulationStatement < Statement
+        attr_accessor :variable
+        def [](k)
+          return variable if k == :variable
+          super( k )
+        end
+      end
+      class AssignStatement < DataManipulationStatement
+        attr_accessor :expression
+        def [](k)
+          return expression if k == :expression
+          super( k )
+        end
+      end
+
+      # other statements
+      
+      class ConditionalStatement < Statement
+        attr_accessor :condition
+        attr_accessor :ifBlock        
+        attr_accessor :elseBlock
+        # called from block ifThen {}.elseThen {}
+        def elseThen( &blk )
+          self.elseBlock = Sbuilder::Ial.block( &blk )
+        end
+        def [](k)
+          return condition if k == :condition
+          return ifBlock if k == :ifBlock
+          return elseBlock if k == :elseBlock
+          super( k )
+        end
+      end
+      class CallStatement < Statement
+        # :macro, :service
+        attr_accessor :target
+        attr_accessor :operation # for targetType :service
+        attr_accessor :targetType
+        attr_accessor :parameters        
+        def [](k)
+          return target if k == :target
+          return operation if k == :operation
+          return targetType if k == :targetType
+          return parameters if k == :parameters
+          super( k )
+        end
+      end
+      
+
+      # Expression
+      Expression  = Struct.new( :type )
+      class Expression
+        def val; raise "Expect sub class to implement"; end
+      end
+
+      # Expression type String, Numeric, TrueClass, FalseClass or
+      # constant values in CONSTANT_EXPRESSIONS
+      #
+      # Properties:
+      #
+      # @property [String|Numeric|TrueClass|FalseClass|CONSTANT_EXPRESSIONS[const]] const
+      # for constant value
+      #
+      class ConstantExpression < Expression
+        attr_accessor :const
+        alias_method :val, :const
+      end
+
+      # Abtract class for TlaExpression and OperatorExpression
+      class ParameterizedExpression < Expression
+        attr_accessor :args
+        def [](k)
+          return args if k == :args
+          super( k )
+        end
+        
+      end
+
+      # Create expressions using TLA templates defined in
+      # Constants::TLA_TEMPLATES. Examples of templates
+      #
+      # - :set => { # e1,e2, ...}
+      #
+      # - :sequence =><<e1,e2,..>>
+      #
+      class TlaExpression < ParameterizedExpression
+        # lambda expression corresponding to :template
+        attr_accessor :templateEval
+        attr_accessor :template
+        def [](k)
+          return template if k == :template
+          super( k )
+        end
+        
+      end
+
+      # Expression 'called( *args )' for operator 'called' with
+      # arguments 'args'.
+      class OperatorExpression < ParameterizedExpression
+        attr_accessor :called
+        attr_accessor :infrastructureService
+        def [](k)
+          return called if k == :called
+          return infrastructureService if k == :infrastructureService
+          super( k )
+        end
+      end
+      
+
+      # Exression referencing ':domain' or ':variable'
+      class ReferenceExpression < Expression
+        attr_accessor :refType # e.g. :domain, :variable, :parameter
+        attr_accessor :ref
+      end
+      class BinaryExpression < Expression
+        attr_accessor :lval
+        attr_accessor :op
+        attr_accessor :rval
+        def [](k)
+          return lval if k == :lval
+          return op if k == :op
+          return rval if k == :rval
+          super( k )
+        end
+      end
+      
+
+      # Parameter set types
+      ParameterSet  = Struct.new( :type, :properties )
+      
+      class Definition  <  ParameterSet
+        attr_accessor :name
+        def [](k)
+          return name if k == :name
+          super( k )
+        end
+        
+      end
+      
+      class Request  <  ParameterSet
+      end
+      class Response  <  ParameterSet
+      end
+
+      # Callables
+      Callable  = Struct.new( :type, :name )
+      
+      class ParameterizedCallable < Callable
+        attr_accessor :parameters
+        def [](k)
+          return parameters if k == :parameters
+          super( k )
+        end
+      end
+
+      class FunctionTypeCallable < Callable
+        # @attr [Request] request
+        attr_accessor :request
+        attr_accessor :locals
+        attr_accessor :response
+        attr_accessor :block        
+        # obj[:locals]
+        def [](k)
+          return locals if k == :locals
+          return response if k == :response
+          return request if k == :request
+          return block if k == :block          
+          super( k )
+        end
+      end
+      
+      class Transaction < FunctionTypeCallable
+        attr_accessor :entryBlock        
+        attr_accessor :exitBlock
+        attr_accessor :operation
+        def [](k)
+          return operation if k == :operation
+          super( k )
+        end
+        
+      end
+
+      class Function < FunctionTypeCallable
+      end
+      
+      class Macro < ParameterizedCallable
+        attr_accessor :block
+        def [](k)
+          return block if k == :block
+          super( k )
+        end
+      end
+
+      class Operator < ParameterizedCallable
+        attr_accessor :body
+        def [](k)
+          return body if k == :body
+          super( k )
+        end
+      end
+      
+
+      # ------------------------------------------------------------------
+      # DSL methods
+      
+      class DomainBuilder
+        def name(v=nil); @name=v; self;end
+        def type(v=:domain); @type=v; self;end        
+        def build
+          Domain.new( :domain, @name )
+        end
+      end
+
+      class PropertyBuilder
+        def name(v=nil); @name=v; self;end
+        def definition(v=nil)
+          @definition= v.is_a?( String ) ? Sbuilder::Ial.definition{ name v } : v          
+          self
+        end
+        def domain(v=nil)
+          @domain= v.is_a?( String ) ? Sbuilder::Ial.domain{ name v } : v
+          self
+        end        
+        def build
+          prop = Property.new( :property, @name )
+          prop.domain = @domain
+          prop.definition = @definition
+          prop
+        end
+      end
+      # ------------------------------------------------------------------
+      # Variable
+      
+      class VariableBuilder
+        def name(v=nil); @name=v; self;end
+        def init(v=nil);
+          @init=Sbuilder::Ial::Model.map2expression(v)
+          self;
+        end
+        def build
+          v = Variable.new( :variable, @name, @init || Sbuilder::Ial.constantExpression(){ const Constants::CONSTANT_EXPRESSION_EMPTY } )
+        end
+      end
+
+      # ------------------------------------------------------------------
+      # Library
+      
+      class LibraryBuilder
+        def name(v=nil); @name=v; self;end
+        def modules( v=nil)
+          if @modules.nil?
+            @modules = v.is_a?( Array ) ? v : [v]
+          else
+            # @modules = [] 
+            if v.is_a?( Array )
+              @modules =  @modules + v
+            else
+              @modules << v
+            end
+          end
+          self
+        end
+        def build
+          Library.new( :library, @name || :default, @modules || [] )
+        end
+      end
+
+      
+
+      # ------------------------------------------------------------------
+      # Local
+      
+      class LocalBuilder
+        def name(v=nil); @name=v; self;end
+        def build
+          Local.new( :local, @name )
+        end
+      end
+
+      class ParameterBuilder
+        def name(v=nil); @name=v; self;end
+        def build
+          Parameter.new( :parameter, @name )
+        end
+      end
+
+
+      # ------------------------------------------------------------------
+      # Block
+      
+      class BlockBuilder
+        def assignTo(  &blk )
+          assignStmt = Sbuilder::Ial.assignStatement( &blk )
+          statements( [ assignStmt ] )
+        end
+
+        # add any statement using a proc
+        def addStatement( stmt=nil, &blk )
+          statements( [ stmt ] ) if stmt
+          if blk 
+            statements( [ blk.call ] )
+          end
+        end
+
+        def addStatements( stmts=[] )
+          stmts = stmts.is_a?( Array ) ? stmts : [ stmts]
+          statements( stmts )
+        end
+        
+        
+        def ifThen( condExpression, &blk )
+          conditional =  Sbuilder::Ial.conditionalStatement() do
+            condition condExpression
+            ifBlock &blk
+          end
+          statements([ conditional ])
+          # return 'conditional' allows chaining ifThen(true) {
+          # }.elseThen {} by
+          conditional
+        end
+        def nop; statements( [ Sbuilder::Ial.skipStatement(){} ] ); end
+        def output(msg=''); statements( [ Sbuilder::Ial.printStatement(){ expression msg } ] ); self; end
+        def callMacro( v=nil, params=[] ); statements( Sbuilder::Ial.callStatement(){ macro v; parameters params } ); self; end
+        def callService( tx=nil, o=nil, params=[] ); statements( Sbuilder::Ial.callStatement(){ service(tx,o) ; parameters params } ); self; end        
+        def statements ( v=[] )
+          if @statements.nil?
+            @statements = v.is_a?( Array ) ? v : [v]
+          else
+            # @statements = [] 
+            if v.is_a?( Array )
+              @statements =  @statements + v
+            else
+              @statements << v
+            end
+          end
+        end
+        def build
+          Block.new( :block, @statements || [] )
+        end
+      end
+
+      # ------------------------------------------------------------------
+      # Statements
+      class StatementBuilder
+      end
+      
+      class PrintStatementBuilder < StatementBuilder
+        def expression(v=nil)
+          @expression=v.is_a?( Array ) ? v.map { |p| Sbuilder::Ial::Model.map2expression(p) } : Sbuilder::Ial::Model.map2expression(v)
+          self
+        end
+        alias_method  :msg,  :expression
+        def build
+          stmt = PrintStatement.new( :printStatement )
+          stmt.expression = @expression
+          stmt          
+        end
+      end
+      
+      class SkipStatementBuilder < StatementBuilder
+        def build
+          SkipStatement.new( :skipStatement )
+        end
+      end
+
+      # Data Maninpulation
+
+      class DataManipulationStatementBuilder < StatementBuilder
+        def variable( v=nil) @variable=Sbuilder::Ial.referenceExpression{ variable v }; self; end
+        def local( v=nil) @variable=Sbuilder::Ial.referenceExpression{ local v }; self; end        
+      end
+
+      class AssignStatementBuilder < DataManipulationStatementBuilder
+        def expression( v=nil) @expression=v; self; end        
+        def build
+          stmt = AssignStatement.new( :assignStatement )
+          stmt.variable =  @variable
+          stmt.expression = Sbuilder::Ial::Model.map2expression(@expression)
+          stmt
+        end
+      end
+
+      # class DataManipulationWhereStatementBuilder < DataManipulationStatementBuilder
+      #   def where( v=nil) @where=v; self; end        
+      # end
+
+      # class DeleteStatementBuilder < DataManipulationWhereStatementBuilder
+      #   def build
+      #     stmt = DeleteStatement.new( :deleteStatement )
+      #     stmt.variable =  @variable
+      #     stmt.where = Sbuilder::Ial::Model.map2expression(@where)
+      #     stmt
+      #   end
+      # end
+
+      # class UpdateStatementBuilder < DataManipulationWhereStatementBuilder
+      #   def build
+      #     stmt = UpdateStatement.new( :updateStatement )
+      #     stmt.variable =  @variable
+      #     stmt.where = Sbuilder::Ial::Model.map2expression(@where)
+      #     stmt
+      #   end
+      # end
+      
+
+      # 
+
+      class ConditionalStatementBuilder < StatementBuilder
+        def condition(v=nil)
+          @condition =  Sbuilder::Ial::Model.map2expression(v)
+          self
+        end
+        def ifBlock( &blk )
+          @ifBlock = Sbuilder::Ial.block( &blk )
+        end
+        def elseBlock( &blk )
+          @elseBlock = Sbuilder::Ial.block( &blk )
+        end
+        def build
+          stmt = ConditionalStatement.new( :conditionalStatement )
+          stmt.condition = @condition || Sbuilder::Ial.constantExpression{ const true }          
+          stmt.ifBlock = @ifBlock || Sbuilder::Ial.block{ nop }
+          # nil causes exception, false flags no else block
+          stmt.elseBlock = @elseBlock || false
+          stmt 
+        end
+      end
+      
+      class CallStatementBuilder < StatementBuilder
+        def parameters(v=nil)
+          if @parameters.nil?
+            @parameters = v.is_a?( Array ) ? v.map { |p| Sbuilder::Ial::Model.map2expression(p) } : [ Sbuilder::Ial::Model.map2expression(v) ]
+          else
+            # @parameters = [] 
+            if v.is_a?( Array )
+              @parameters =  @parameters + v.map { |p| Sbuilder::Ial::Model.map2expression(p) }
+            else
+              @parameters << Sbuilder::Ial::Model.map2expression(v)
+            end
+          end
+          self
+        end
+        def macro( v=nil)
+          @targetType=:macro
+          @target=v
+        end
+        def service( txName=nil, operation=nil)
+          @targetType=:service
+          @target=txName
+          @operation=operation
+        end
+        def build
+          stmt = CallStatement.new( :callStatement )
+          stmt.parameters = @parameters || []
+          stmt.targetType = @targetType
+          stmt.target = @target
+          stmt.operation = @operation          
+          stmt 
+        end
+      end
+      
+
+      # ------------------------------------------------------------------
+      # Expressions
+
+      def map2expression( v )
+        if v.is_a?( Expression ) || v.nil?
+          v
+        elsif v.is_a?( Symbol ) && !Constants::CONSTANT_EXPRESSIONS[v].nil?
+          Sbuilder::Ial.constantExpression() { const v }
+        elsif v.is_a?( String ) || v.is_a?( Numeric ) || v.is_a?( TrueClass )  || v.is_a?( FalseClass ) 
+          Sbuilder::Ial.constantExpression() { const v }
+        elsif v.is_a?( Sbuilder::Ial.variable )
+          v
+        else
+          raise ModelDslException, "Unkwnown type for expression #{v}"
+        end
+      end
+      module_function :map2expression
+      
+      class ExpressionBuilder
+      end
+
+      class ConstantExpressionBuilder < ExpressionBuilder
+        def const(v=nil); @const=v; self;end
+        def build
+          expression = ConstantExpression.new( :constantExpression )
+          expression.const = @const 
+          expression
+        end
+      end
+      class ReferenceExpressionBuilder < ExpressionBuilder
+        def plain( v=nil)
+          @refType=:plain
+          @ref=v
+        end
+        def variable( v=nil)
+          @refType=:variable
+          @ref=v
+        end
+        def parameter( v=nil)
+          @refType=:parameter
+          @ref=v
+        end
+        def local( v=nil)
+          @refType=:local
+          @ref=v
+        end
+        def domain( v=nil)
+          @refType=:domain
+          @ref=v
+        end
+        def build
+          expression = ReferenceExpression.new( :referenceExpression )
+          expression.refType = @refType
+          expression.ref = @ref          
+          expression
+        end
+      end
+
+
+      class BinaryExpressionBuilder < ExpressionBuilder
+        def binary(l=nil, o=nil,r=nil)
+          @lval=l
+          @op=o
+          @rval=r
+          self
+        end
+        alias_method :expression, :binary
+        def build
+          expression = BinaryExpression.new( :binaryExpression )
+          raise ModelDslException, "Invalid or missing expression: #{@lval.nil? ?  ' missing lval' :''} #{@op.nil? ? ' missing operator': ''}#{@rval.nil? ? ' missing rval' :''}'" if @lval.nil? || @op.nil? || @rval.nil?
+          raise ModelDslException, "Unsupported operator '#{@op}' - valid opreators #{Constants::IAL_OPERATORS.keys.join(',')}" if Constants::IAL_OPERATORS[@op].nil?
+          expression.lval = Sbuilder::Ial::Model.map2expression(@lval)
+          expression.op = @op
+          expression.rval = Sbuilder::Ial::Model.map2expression(@rval)
+          expression
+        end
+      end
+
+      class ParameterizedExpressionBuilder < ExpressionBuilder
+        def args(v=nil)
+          if @args.nil?
+            @args = v.is_a?( Array ) ? v.map { |p| Sbuilder::Ial::Model.map2expression(p) } : [ Sbuilder::Ial::Model.map2expression(v) ]
+          else
+            # @args = [] 
+            if v.is_a?( Array )
+              @args =  @args + v.map { |p| Sbuilder::Ial::Model.map2expression(p) }
+            else
+              @args << Sbuilder::Ial::Model.map2expression(v)
+            end
+          end
+          self
+        end
+      end
+
+      class TlaExpressionBuilder < ParameterizedExpressionBuilder
+        def template(v=nil); @template=v; self;end
+        def build
+          expression = TlaExpression.new( :tlaExpression )
+          raise ModelDslException, "Missing template '#{@template}' in tlaExpression - valid templates: #{Constants::TLA_TEMPLATES.keys.join(',')}" if @template.nil?          
+          raise ModelDslException, "Unsupported tla template '#{@template}' - valid templates: #{Constants::TLA_TEMPLATES.keys.join(',')}" if Constants::TLA_TEMPLATES[@template].nil?
+          expression.template = @template
+          expression.templateEval = Constants::TLA_TEMPLATES[@template]
+          expression.args = @args && @args.map{ |e| Sbuilder::Ial::Model.map2expression(e) } || []
+          expression
+        end
+      end
+
+      class OperatorExpressionBuilder < ParameterizedExpressionBuilder
+        def called( v=nil) @called=v; self; end
+        def infrastructureService( v=nil) @infrastructureService=v; self; end        
+        def build
+          expression = OperatorExpression.new( :operatorExpression )
+          expression.called = @called
+          expression.infrastructureService = @infrastructureService.nil? ? false : @infrastructureService
+          expression.args = @args || []
+          expression
+        end
+      end
+      
+      
+
+      # ------------------------------------------------------------------
+      # Transaction
+      class CallableBuilder
+        def name(v=nil); @name=v; self;end
+        def request(v=nil)
+          if v.is_a?( Array )
+            # expect array 'v' of properties
+            @request=Sbuilder::Ial.request() { properties v }
+          else
+            @request=v
+          end
+          self
+        end
+        def block(v=nil, &blk )
+          if block_given?
+            @block = Sbuilder::Ial.block( &blk )
+          else
+            @block=v; self;
+          end
+        end
+        private def map2Local( l )
+          l.is_a?( Local ) ? l : Sbuilder::Ial.local() { name l }
+        end
+      end
+      
+      class FunctionCallableBuilder  < CallableBuilder
+        def response(v=nil)
+          if v.is_a?( Array )
+          # expect array of properties
+            @response=Sbuilder::Ial.response() { properties v }
+          else
+            @response=v
+          end
+          self
+        end # response
+        def locals(v=[])
+          if @locals.nil?
+            @locals = v.is_a?( Array ) ? v.map{ |l| map2Local(l)} : [map2Local(v)]
+          else
+            # @locals = [] 
+            if v.is_a?( Array )
+              @locals =  @locals + v.map{ |l| map2Local(l)}
+            else
+              @locals << map2Local(v)
+            end
+          end
+          self
+        end # locals
+      end
+      
+      class TransactionBuilder  < FunctionCallableBuilder
+        def operation(v=nil); @operation=v; self;end
+        def entryBlock(v=nil, &blk )
+          if block_given?
+            @entryBlock = Sbuilder::Ial.block( &blk )
+          else
+            @entryBlock=v; self;
+          end
+        end
+        def exitBlock(v=nil); @exitBlock=v; self;end                
+        def build
+          transaction = Transaction.new( Constants::IAL_TRANSACTION, @name )
+          transaction.locals = @locals || []
+          transaction.operation = @operation || ""
+          transaction.response = @response || Sbuilder::Ial.response(){ properties [] }
+          transaction.request = @request || Sbuilder::Ial.request() { properties [] }
+          transaction.entryBlock = @entryBlock || BlockBuilder.new.build
+          transaction.block = @block || BlockBuilder.new.build
+          transaction.exitBlock = @exitBlock          
+          transaction
+        end
+      end
+
+      class ParameterizedCallableBuilder < CallableBuilder
+        private def map2Parameter( p )
+          if p.is_a?( Parameter ) then
+            p
+          elsif p.is_a? String
+            Sbuilder::Ial.parameter() { name p }
+          else
+            raise "Invalid parameter #{p} expecting Parameter or String"
+          end
+        end
+        def parameters(v=nil)
+          if @parameters.nil?
+            @parameters = v.is_a?( Array ) ? v.map { |p| map2Parameter(p) } : [map2Parameter(v)]
+          else
+            # @parameters = [] 
+            if v.is_a?( Array )
+              @parameters =  @parameters + v.map { |p| map2Parameter(p) }
+            else
+              @parameters << map2Parameter(v)
+            end
+          end
+          self
+        end # parameters
+      end
+
+      class MacroBuilder  < ParameterizedCallableBuilder
+        def build
+          macro = Macro.new( Constants::IAL_MACRO, @name  )
+          macro.parameters = @parameters || []
+          macro.block =  @block || Sbuilder::Ial.block{ nop }
+          macro
+        end
+      end
+      
+      class OperatorBuilder  < ParameterizedCallableBuilder
+        def body(v=nil); @body=v; self;end
+        def expression(v=""); @body=Sbuilder::Ial::Model.map2expression(v); self;end        
+        def build
+          operator = Operator.new( Constants::IAL_OPERATOR, @name )
+          operator.parameters = @parameters || []
+          operator.body = @body || Sbuilder::Ial.constantExpression(){ const true }
+          operator
+        end
+      end
+      
+
+      # ------------------------------------------------------------------
+      # Paramaeter sets: Definition, Request, Response
+      
+      class ParameterSetBuilder
+        
+        # @param [Property|String|Hash] p
+        #
+        # @return [Property]
+        private def map2Property( p )
+          if p.is_a?( Property ) then
+            p
+          elsif p.is_a? String
+            Sbuilder::Ial.property() { name p }
+          elsif  p.is_a?( Hash)  && p.key?( :name ) && p.key?( :domain )
+            Sbuilder::Ial.property() { name p[:name]; domain p[:domain] }
+          elsif  p.is_a?( Hash)  && p.key?( :name ) && p.key?( :definition )
+            Sbuilder::Ial.property() { name p[:name]; definition p[:definition] }
+          else
+            raise "Invalid property #{p} expecting Property,String, or Hash with :name and :domain/:definition properties"
+          end
+        end
+        def properties ( v=[] )
+          if @properties.nil?
+            @properties = v.is_a?( Array ) ? v.map { |p| map2Property(p) } : [map2Property(v)]
+          else
+            # @properties = [] 
+            if v.is_a?( Array )
+              @properties =  @properties + v.map { |p| map2Property(p) }
+            else
+              @properties << map2Property(v)
+            end
+          end
+          self
+        end
+      end
+      
+      class RequestBuilder < ParameterSetBuilder
+        def build
+          parameterSet = Request.new( :request, @properties || [] )
+          parameterSet
+        end
+      end
+      # response
+      
+      class ResponseBuilder < ParameterSetBuilder
+        def build
+          parameterSet = Response.new( :response, @properties || [] )
+          parameterSet
+        end
+      end
+
+      # definition
+
+      class DefinitionBuilder < ParameterSetBuilder
+        def name(v=nil); @name=v; self;end
+        def build
+          definitionParameterSet = Definition.new( :definition, @properties || [] )
+          definitionParameterSet.name = @name          
+          definitionParameterSet          
+        end
+      end
+
+    end # module Model
+
+    # ------------------------------------------------------------------
+    # Sbuilder::Ial API
+
+    def domain( &block )
+      Docile.dsl_eval( Sbuilder::Ial::Model::DomainBuilder.new, &block ).build
+    end
+    module_function :domain
+
+    def property( &block )
+      Docile.dsl_eval( Sbuilder::Ial::Model::PropertyBuilder.new, &block ).build
+    end
+    module_function :property
+
+    def variable( &block )
+      Docile.dsl_eval( Sbuilder::Ial::Model::VariableBuilder.new, &block ).build
+    end
+    module_function :variable
+
+    def library( &block )
+      Docile.dsl_eval( Sbuilder::Ial::Model::LibraryBuilder.new, &block ).build
+    end
+    module_function :library
+
+    def local( &block )
+      Docile.dsl_eval( Sbuilder::Ial::Model::LocalBuilder.new, &block ).build
+    end
+    module_function :local
+    
+    def block( &block )
+      Docile.dsl_eval( Sbuilder::Ial::Model::BlockBuilder.new, &block ).build
+    end
+    module_function :block
+
+    
+    def printStatement( &block )
+      Docile.dsl_eval( Sbuilder::Ial::Model::PrintStatementBuilder.new, &block ).build
+    end
+    module_function :printStatement
+
+
+    def skipStatement( &block )
+      Docile.dsl_eval( Sbuilder::Ial::Model::SkipStatementBuilder.new, &block ).build
+    end
+    module_function :skipStatement
+
+    def assignStatement( &block )
+      Docile.dsl_eval( Sbuilder::Ial::Model::AssignStatementBuilder.new, &block ).build
+    end
+    module_function :assignStatement
+    
+    # def deleteStatement( &block )
+    #   Docile.dsl_eval( Sbuilder::Ial::Model::DeleteStatementBuilder.new, &block ).build
+    # end
+    # module_function :deleteStatement
+    
+    # def updateStatement( &block )
+    #   Docile.dsl_eval( Sbuilder::Ial::Model::UpdateStatementBuilder.new, &block ).build
+    # end
+    # module_function :updateStatement
+    
+
+    def callStatement( &block )
+      Docile.dsl_eval( Sbuilder::Ial::Model::CallStatementBuilder.new, &block ).build
+    end
+    module_function :callStatement
+
+    def conditionalStatement( &block )
+      Docile.dsl_eval( Sbuilder::Ial::Model::ConditionalStatementBuilder.new, &block ).build
+    end
+    module_function :conditionalStatement
+
+
+    def constantExpression( &block )
+      Docile.dsl_eval( Sbuilder::Ial::Model::ConstantExpressionBuilder.new, &block ).build
+    end
+    module_function :constantExpression
+    
+    
+    def referenceExpression( &block )
+      Docile.dsl_eval( Sbuilder::Ial::Model::ReferenceExpressionBuilder.new, &block ).build
+    end
+    module_function :referenceExpression
+    
+
+    def binaryExpression( &block )
+      Docile.dsl_eval( Sbuilder::Ial::Model::BinaryExpressionBuilder.new, &block ).build
+    end
+    module_function :binaryExpression
+
+    def tlaExpression( &block )
+      Docile.dsl_eval( Sbuilder::Ial::Model::TlaExpressionBuilder.new, &block ).build
+    end
+    module_function :tlaExpression
+
+    def operatorExpression( &block )
+      Docile.dsl_eval( Sbuilder::Ial::Model::OperatorExpressionBuilder.new, &block ).build
+    end
+    module_function :operatorExpression
+    
+
+    def transaction( &block )
+      Docile.dsl_eval( Sbuilder::Ial::Model::TransactionBuilder.new, &block ).build
+    end
+    module_function :transaction
+
+    def macro( &block )
+      Docile.dsl_eval( Sbuilder::Ial::Model::MacroBuilder.new, &block ).build
+    end
+    module_function :macro
+
+    def operator( &block )
+      Docile.dsl_eval( Sbuilder::Ial::Model::OperatorBuilder.new, &block ).build
+    end
+    module_function :operator
+
+    def parameter( &block )
+      Docile.dsl_eval( Sbuilder::Ial::Model::ParameterBuilder.new, &block ).build
+    end
+    module_function :parameter
+    
+
+    def request( &block )
+      Docile.dsl_eval( Sbuilder::Ial::Model::RequestBuilder.new, &block ).build
+    end
+    module_function :request
+
+    def response( &block )
+      Docile.dsl_eval( Sbuilder::Ial::Model::ResponseBuilder.new, &block ).build
+    end
+    module_function :response
+    
+    def definition( &block )
+      Docile.dsl_eval( Sbuilder::Ial::Model::DefinitionBuilder.new, &block ).build
+    end
+    module_function :definition
+    
+
+  end # module Ial
+end
+# ------------------------------------------------------------------
+# Public API
+
+# def Domain( &blk )
+#   Sbuilder::Ial::Model.domain( &blk )
+# end
+
+# def Property( &blk )
+#   Sbuilder::Ial::Model.property( &blk )
+# end
+
+# # Paramater sets
+# def Definition( &blk )
+#   Sbuilder::Ial::Model.definition( &blk )
+# end
+# def Request( &blk )
+#   Sbuilder::Ial::Model.request( &blk )
+# end
+# def Response( &blk )
+#   Sbuilder::Ial::Model.response( &blk )
+# end
+
+# def Variable( &blk )
+#   Sbuilder::Ial::Model.variable( &blk )
+# end
+
+# def Local( &blk )
+#   Sbuilder::Ial::Model.local( &blk )
+# end
+
+# # callables
+
+# def Transaction( &blk )
+#   Sbuilder::Ial::Model.transaction( &blk )
+# end
+
+# # block and statemets
+
+# def Block( &blk )
+#   Sbuilder::Ial::Model.block( &blk )
+# end
+
+
+# def PrintStatement( &blk )
+#   Sbuilder::Ial::Model.printStatement( &blk )
+# end
+
+# def skipStatement( &blk )
+#   if block_given?
+#     Sbuilder::Ial::Model.skipStatement( &blk )
+#   else
+#     Sbuilder::Ial::Model.skipStatement {}
+#   end
+# end
+
+
+# def ConstantExpression( &blk )
+#   Sbuilder::Ial::Model.constantExpression( &blk )
+# end
+
+# def ReferenceExpression( &blk )
+#   Sbuilder::Ial::Model.referenceExpression( &blk )
+# end
+# def BinaryExpression( &blk )
+#   Sbuilder::Ial::Model.binaryExpression( &blk )
+# end
+# def TlaExpression( &blk )
+#   Sbuilder::Ial::Model.tlaExpression( &blk )
+# end
+
+# def Library( &blk )
+#   Sbuilder::Ial::Model.library( &blk )
+# end
+
+