tla-sbuilder 0.1.0

data/lib/sbuilder/param_set_step.rb

@@ -0,0 +1,62 @@
+module Sbuilder
+
+  # interface paramter set extending interface
+  class ParamSetStep < ParamSet
+
+    attr_reader :bindExact                    # return return boolead
+    attr_reader :interfaceReference           # return interface:paramSet referenced
+    attr_reader :inputs                       # array of inputs
+    
+    # ------------------------------------------------------------------
+    # mixer
+    PROGNAME = "ParamSetStep"                 # progname for logger
+    include Sbuilder::Utils::MyLogger         # mix logger
+
+    # constrcutore
+    def initialize( options = {} )
+      super( options )
+      @logger = getLogger( PROGNAME, options )
+      @logger.info( "#{__method__} initialized" )
+
+      # default - use rule
+      @bindExact = false
+      @inputs = []
+    end
+
+    # ------------------------------------------------------------------
+    # setInterfaceRefence
+
+    # configure
+    def setInterfaceReference( interfaceParamSet )
+      @interfaceReference = interfaceParamSet
+      self
+    end
+
+    # identity - deletegate to reference
+    def doGetId
+      interfaceReference.getId
+    end
+
+    # ------------------------------------------------------------------
+    # build
+    # def setInputs( inputs )
+    #    @inputs = inputs
+    # end
+
+    def addInput( input )
+      @inputs <<  input
+      self
+    end
+
+    # ------------------------------------------------------------------
+    # bindExact
+    def setBindExact( bindExact )
+      @bindExact = bindExact.nil? ? false : bindExact
+      self
+    end
+    
+  end
+
+end
+
+

data/lib/sbuilder/param_sets.rb

@@ -0,0 +1,54 @@
+require 'tsort'       # to sort paramset in correct order 
+
+module Sbuilder
+
+  class ParamSets < Hash
+
+    attr_reader :model                       # to resolve paramSets
+    
+    include TSort                            # sort in correct order
+
+    # ------------------------------------------------------------------
+    # constructore
+    
+    class << self
+
+      def create( model )
+        new( model )
+      end
+
+      private :new
+      
+    end # class methods
+
+    def initialize( model )
+      @model = model
+    end
+
+    # ------------------------------------------------------------------
+    # tsort
+
+    alias tsort_each_node each_key
+    
+    def tsort_each_child( paramSetName, &block)
+
+      # # no depencies if no name ??
+      # return unless key?( paramSetName )
+      
+      # access the object to sort
+      # puts "fetch(#{paramSetName}) in #{keys}"
+      paramSet = fetch(paramSetName)
+      
+      # find dependencies amongst the refenced paramSets (TestCase)
+      paramSet.parameters.
+        select do |parameter|
+        parameter.isReference
+      end.                                                      # consider only refences
+        map do |parameter|
+        parameter.getResolvedReference( model ).getId
+      end.                                                      # resolve paramSet referenced
+        each(&block)                                            # process tsort block for each paramSetname
+    end
+    
+  end
+end

data/lib/sbuilder/parameter.rb

@@ -0,0 +1,97 @@
+
+module Sbuilder
+
+  class Parameter
+
+    attr_reader  :name
+    attr_reader  :isArray                     # defaults 'false'
+
+
+    # ------------------------------------------------------------------
+    # mixer
+    PROGNAME = "Parameter"                    # progname for logger
+    include Sbuilder::Utils::MyLogger         # mix logger
+
+    # ------------------------------------------------------------------
+    # constrcutore
+    def initialize( options = {} )
+      @logger = getLogger( PROGNAME, options )
+      @logger.info( "#{__method__} initialized" )
+      # default is not an arrays
+      @isArray = false
+    end
+
+    # def self.create( name )
+    #   p = Parameter.new
+    #   p.setName( name )
+    # end
+
+    # ------------------------------------------------------------------
+    # build identity
+
+    def setName( name )
+      @name = name
+      self
+    end
+
+    def getName()
+      return name.
+              gsub( / /, "" )   # remove spaces
+    end
+
+    def setIsArray( isArray = true )
+      @isArray = isArray
+      self
+    end
+
+    # is NOT reference (override in sub-class if is a reference)
+    def isReference
+      false
+    end
+
+    
+
+    # ------------------------------------------------------------------
+    # generate (build model)
+
+    # domain or reference parameter set
+    def getType
+      return doGetType
+    end
+
+    def doGetType
+      msg = "Sub class should implement doGetType -method"
+      @logger.error( "#{__method__} #{msg}" )        
+      raise NoMethodError.new( msg  )
+    end
+
+    # ------------------------------------------------------------------
+    # create patermeter definition
+    
+    def parameter_definition( model )
+      {
+        :parameter_name => getName,
+        :isArray => isArray,
+      }.merge!( do_parameter_definition( model ) )
+    end
+
+    
+    def do_parameter_definition( model )
+      msg = "Sub class should implement do_parameter_definition -method"
+      @logger.error( "#{__method__} #{msg}" )        
+      raise NoMethodError.new( msg  )
+    end
+
+    # ------------------------------------------------------------------
+    # resolve
+
+    # resolve parametSet reference in 'model': simple parameter
+    # resolves to 'self'
+    def getResolvedReference( model )
+      self
+    end
+    
+    
+  end # class
+  
+end

data/lib/sbuilder/parameter_container.rb

@@ -0,0 +1,72 @@
+
+module Sbuilder
+
+  class ParameterContainer < Parameter
+
+    attr_reader :domainElement                # access configured domain Id
+                                              # TODO: refractor domainElement to a sub-class
+    attr_reader :parameter                    # parameter-->domain-->(check cardinality)->domainElement
+    attr_reader :parameters                   # array of hash names: modeling hash
+    attr_reader :rows                         # modeling array
+    
+    # ------------------------------------------------------------------
+    # mixer
+    PROGNAME = "ParameterContainer"                # progname for logger
+    include Sbuilder::Utils::MyLogger         # mix logger
+
+    # ------------------------------------------------------------------
+    # constrcutore
+    def initialize( options = {} )
+      super( options )
+      @logger = getLogger( PROGNAME, options )
+      @logger.info( "#{__method__} initialized" )
+    end
+
+    # ------------------------------------------------------------------
+    # build
+    
+    def setDomainElement( domainElement )
+      @domainElement = domainElement
+      self
+    end
+
+    # set a reference
+    def setParameter( parameter )
+      @parameter = parameter
+      self
+    end
+
+    # add to collection
+    def addParameter( parameter )
+      @parameters = [] if @parameters.nil?
+      @parameters << parameter
+      self
+    end
+    
+    # add to collection
+    def addParameter( parameter )
+      @parameters = [] if @parameters.nil?
+      @parameters << parameter
+      self
+    end
+    
+    # add to collection
+    def addRow( parameter )
+      @rows = [] if @rows.nil?
+      @rows << parameter
+      self
+    end
+
+    # ------------------------------------------------------------------
+    # genarate phase
+    def do_parameter_definition( model )
+      
+      # ret = parameters.inject( [] ) { |arr, parameter| arr << { :parameter_name[parameter.name] = "value for #{parameter.name}" }
+      ret
+    end
+
+    
+  end
+end
+
+

data/lib/sbuilder/parameter_dom.rb

@@ -0,0 +1,70 @@
+
+module Sbuilder
+
+  class Parameter_Dom < Parameter
+
+    attr_reader  :domain                      # name resolved
+    attr_reader  :resolvedDomain              # pointer to Domain-object
+
+    # ------------------------------------------------------------------
+    # mixer
+    PROGNAME = "ParameterDom"                 # progname for logger
+    include Sbuilder::Utils::MyLogger         # mix logger
+
+    
+    # ------------------------------------------------------------------
+    # constrcutore
+    def initialize( options = {} )
+      super( options )
+      @logger = getLogger( PROGNAME, options )
+      @logger.info( "#{__method__} initialized" )
+    end
+
+    def self.create( name, domain )
+      p = Parameter_Dom.new
+      p.setName( name )
+      p.setDomain( domain )
+    end
+
+    def to_s
+      "#{PROGNAME}: name: '#{getName}', domain='#{ domain }'"
+    end
+
+    # ------------------------------------------------------------------
+    # build domain
+
+    def setDomain( domain )
+      @domain = domain
+      self
+    end
+
+    # ------------------------------------------------------------------
+    # resolve
+    def resolveDomain( model )
+      # access domain(name) from model, exception if not found
+      @resolvedDomain = model.getDomain( domain )
+    end
+    
+
+    # ------------------------------------------------------------------
+    # build model
+    
+    def doGetType
+      domain
+    end
+
+    def do_parameter_definition( model )
+      {
+        # :name => name,
+        :type => domain,
+        :namespace => Constants::TYPE_NAMESPACE_DOM,   # in TLA code prefix with 'd_',
+        :composite_parameters => false,
+      }
+    end
+    
+    
+    
+    
+  end
+  
+end

data/lib/sbuilder/parameter_ref.rb

@@ -0,0 +1,71 @@
+
+module Sbuilder
+
+  class Parameter_Ref < Parameter
+
+    attr_reader   :reference                  # name of paramSet being pointed
+
+    # ------------------------------------------------------------------
+    # mixer
+    PROGNAME = "ParameterRef"                 # progname for logger
+    include Sbuilder::Utils::MyLogger         # mix logger
+
+    # ------------------------------------------------------------------
+    # constrcutore
+    def initialize( options = {} )
+      super( options )
+      @logger = getLogger( PROGNAME, options )
+      @logger.info( "#{__method__} initialized" )
+    end
+
+    def self.create( name, paramSetName )
+      p = Parameter_Ref.new
+      p.setName( name )
+      p.setReference( paramSetName )
+    end
+    
+
+    # ------------------------------------------------------------------
+    # configure
+    def setReference( paramSetName )
+      @reference = paramSetName
+      self
+    end
+
+    # is reference && valid reference configured
+    def isReference
+      ! @reference.nil?
+    end
+
+    # ------------------------------------------------------------------
+    # resolve
+
+    # resolve parametSet reference in 'model'
+    def getResolvedReference( model )
+      model.getParamset( reference )
+    end
+
+
+    # ------------------------------------------------------------------
+    # build model
+
+    def doGetType
+      reference
+    end
+
+    def do_parameter_definition( model )
+      {
+        # :name => name,
+        :type => reference,
+        :namespace => Constants::TYPE_NAMESPACE_REF,   # in TLA code prefix with 't_'
+        :composite_parameters => getResolvedReference(model).parameter_definitions( model ),
+      }
+    end
+
+    def to_s
+      reference ? reference.to_s : ""
+    end
+
+  end
+  
+end

data/lib/sbuilder/resolver.rb

@@ -0,0 +1,78 @@
+
+module Sbuilder
+
+  class Resolver
+
+    attr_reader :name                         # identity
+    attr_reader :rules                        # array of rules:ResolverRule
+    attr_reader :matcher                      # String or Regexp to match
+
+    # ------------------------------------------------------------------
+    # mixer
+    PROGNAME = "Resolver"                       # progname for logger
+    include Sbuilder::Utils::MyLogger         # mix logger
+
+    # ------------------------------------------------------------------
+    # constrcutore
+    def initialize( options = {} )
+      @logger = getLogger( PROGNAME, options )
+      @logger.info( "#{__method__} initialized" )
+      @rules = []
+    end
+
+    # ------------------------------------------------------------------
+    # build it
+
+    # add to @rules, return @rule
+    def add_rule( rule )
+      rules << rule
+      rules
+    end
+
+    # ------------------------------------------------------------------
+    # identify right matcher
+
+    def setName( name )
+      @name = name
+    end
+
+    # # use attribute 'matcher' for string comparison or regepx comparisin
+    # def matchesWithParamSet( paramSet )
+    #   matcher.is_a?( String ) ? paramSet.getId == matcher  : (paramSet.getId =~ matcher) != nil
+    # end
+
+    # match is 'String' or 'Regexp' 
+    def setMatch( matcher )
+      @matcher = matcher
+    end
+
+    # ------------------------------------------------------------------
+    # resolve
+    def resolveDomains( paramSet, model )
+      @logger.info( "#{__method__} start paramSet.getId= #{paramSet.getId}, rules=#{rules.size}" )
+      paramSet.parametersToResolve.each do |parameter|
+        @logger.debug( "#{__method__} resolving '#{parameter}'" )
+        if ! applyRule( parameter, model ) then
+          raise ResolverException, "Could not resolve domain for parameter '#{parameter.getName}' in parameter set #{paramSet} #{ parameter.isReference ? '(with reference to ' + parameter.reference + ')' : '' }" 
+        end
+      end
+    end
+
+    # iterate rules and find a match, must find one that matches
+    def applyRule( parameter, model )
+      # No need resolve referenced paramters
+      return true if parameter.isReference
+      rules.each do |rule|
+        if rule.applyRule( parameter, model ) then
+          return true
+        end
+      end
+      return false
+
+    end
+    
+    
+  end
+  
+end
+