tla-sbuilder 0.2.2 → 0.3.4

data/lib/sbuilder/resolver.rb

@@ -9,7 +9,7 @@ module Sbuilder
 
     # ------------------------------------------------------------------
     # mixer
-    PROGNAME = "Resolver"                       # progname for logger
+    PROGNAME = nil                            # progname for logger defaults class name
     include Sbuilder::Utils::MyLogger         # mix logger
 
     # ------------------------------------------------------------------
@@ -61,13 +61,18 @@ module Sbuilder
     # 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
+      if parameter.isReference
+        return parameter.resolveReference( model )
+      else
+
+        # paramter_dom
+        rules.each do |rule|
+          if rule.applyRule( parameter, model ) then
+            return true
+          end
         end
+        return false
       end
-      return false
 
     end
     

data/lib/sbuilder/resolver_loader.rb

@@ -8,7 +8,7 @@ module Sbuilder
 
     # ------------------------------------------------------------------
     # mixer
-    PROGNAME = "ResolverLoader"                 # progname for logger
+    PROGNAME = nil                            # progname for logger default class name
     include Sbuilder::Utils::MyLogger         # mix logger
 
 

data/lib/sbuilder/resolver_loader_yaml.rb

@@ -4,7 +4,7 @@ module Sbuilder
 
     # ------------------------------------------------------------------
     # mixer
-    PROGNAME = "ResolverLoaderYAML"             # progname for logger
+    PROGNAME = nil                            # progname for logger default class name
     include Sbuilder::Utils::MyLogger         # mix logger
 
     # ------------------------------------------------------------------

data/lib/sbuilder/resolver_rule.rb

@@ -6,7 +6,7 @@ module Sbuilder
 
     # ------------------------------------------------------------------
     # mixer
-    PROGNAME = "ResolverRule"                   # progname for logger
+    PROGNAME = nil                            # progname for logger default class name
     include Sbuilder::Utils::MyLogger         # mix logger
 
     # ------------------------------------------------------------------

data/lib/sbuilder/resolver_rule_match.rb

@@ -7,7 +7,7 @@ module Sbuilder
 
     # ------------------------------------------------------------------
     # mixer
-    PROGNAME = "ResolverRuleMatch"              # progname for logger
+    PROGNAME = nil                            # progname for logger default class name
     include Sbuilder::Utils::MyLogger         # mix logger
 
     # ------------------------------------------------------------------
@@ -41,14 +41,20 @@ module Sbuilder
       return true if parameter.domain
       if  match(  parameter ) then
         @logger.info( "#{__method__} setDomain '#{domain}' on parameter '#{parameter.getName}' based on rule '#{matchRule}'" )
-        # 
-        parameter.setDomain( domain )
-        parameter.resolveDomain( model )
+        #
+        self.class.setDomain( parameter, domain, model )
+        # parameter.setDomain( domain )
+        # parameter.resolveDomain( model )
         return true
       end
       return false
     end
 
+    def self.setDomain( parameter, domain, model )
+        parameter.setDomain( domain )
+        parameter.resolveDomain( model )
+    end
+
 
 
   end

data/lib/sbuilder/resolver_rule_ref.rb

@@ -6,7 +6,7 @@ module Sbuilder
     attr_reader :ref                         # reference to mapper
     # ------------------------------------------------------------------
     # mixer
-    PROGNAME = "ResolverRuleRef"                # progname for logger
+    PROGNAME = nil                            # progname for logger default class name
     include Sbuilder::Utils::MyLogger         # mix logger
 
     # ------------------------------------------------------------------

data/lib/sbuilder/setup_loader.rb

@@ -0,0 +1,49 @@
+module Sbuilder
+
+
+  # Abstaract base class
+  class SetupLoader
+
+    # ------------------------------------------------------------------
+    # mix logger
+    
+    PROGNAME = nil                    # progname for logger default class name
+    include Sbuilder::Utils::MyLogger # mix logger
+
+    # @attr [Sbuilder:Controller] controller managing generation
+    attr_accessor :controller
+
+    # @attr [String] setupName setter & getter
+    attr_accessor :setupName
+    
+
+    def initialize( options = {} )
+      @logger = getLogger( nil, options )
+      @logger.info( "#{__method__} initialized options=#{options}" )
+      
+    end
+
+    # @return [Sbuilder::StepGenerator] generator to create input
+    def getStepGenerator
+      controller.factory.getStepGenerator
+    end
+
+
+    #  Method called from extension-loder. Delegate actual load
+    #  operation to sub-class.
+    #
+    # @param [Hash] extensionDef configuration defining loading
+    def load( extensionDef )
+      doLoad( extensionDef )
+    end
+
+    # Should override
+    #
+    # @param [Hash] extensionDef configuration defining loading    
+    def doDoload( extensionDef )
+      raise "Missing implementation in sub-class"
+    end
+
+  end
+  
+end

data/lib/sbuilder/setup_loader_env.rb

@@ -0,0 +1,478 @@
+module Sbuilder
+
+
+  # Abstaract base class
+  class SetupLoaderEnv < SetupLoader
+
+    # ------------------------------------------------------------------
+    # Validation
+
+    @@validEnvExtension_required = %w( interface  )
+    @@validEnvExtension_allowed =  %w( validators  input inputs bindExact )
+    
+
+    # ------------------------------------------------------------------
+    # mix logger
+    
+    PROGNAME = nil                    # progname for logger default class name
+    include Sbuilder::Utils::MyLogger # mix logger
+
+    @@extensionDomainProperties = ['domain', 'cardinality']
+
+    # ------------------------------------------------------------------
+    # @!group Construct & configure
+
+
+    def initialize( options = {} )
+      @logger = getLogger( nil, options )
+      @logger.info( "#{__method__} initialized options=#{options}" )
+
+      super( options )
+    end
+
+
+    # @!endgroup        
+
+    # ------------------------------------------------------------------
+    # @!group Abstract methods from parent class
+
+    # @param [Hash:Array] extensionDef configuration defining loading
+    def doLoad( extensionDefs )
+
+      @logger.info "#{__method__}, extensionDefs=#{extensionDefs}"
+
+      extensionDefs && extensionDefs.each do |stepExtensionDef|
+        Sbuilder::Utils::Validate.validateProperties( stepExtensionDef, @@validEnvExtension_required, @@validEnvExtension_allowed )
+        begin 
+          doLoadStep( stepExtensionDef )
+        rescue SbuilderException => e
+          msg = <<-EOS.unindent
+
+          #{e} 
+
+          Error occurred, when applying step extension:
+          #{stepExtensionDef.to_yaml}
+          EOS
+          @logger.error "#{__method__} #{msg}" 
+          raise Sbuilder::ExtensionException.new, msg, e.backtrace
+        end
+      end
+
+    end
+
+    # @!endgroup
+
+    # ------------------------------------------------------------------
+    # @!group Implement load
+    
+
+    # @param [Hash]  stepExtensionDef one step to take
+    # @option stepExtensionDef [String] interface
+    # @option stepExtensionDef [String] bindExact
+    # @option stepExtensionDef [String] 
+    def doLoadStep ( stepExtensionDef )
+
+      # access interface (paramSet) to invoke in step
+      interface = controller.getInterface( stepExtensionDef['interface'] )
+
+      # create new param-set && configure it
+      stepParamSet = controller.createParamSet( Sbuilder::Constants::PARAM_SET_STEPS )
+      stepParamSet.setInterfaceReference( interface )
+      stepParamSet.setBindExact( stepExtensionDef["bindExact"] )
+
+      # set if 'stepExtensionDef' configuration defines
+      inputsValues = nil
+      if stepExtensionDef['validators']
+        inputsValues = doLoadGenerator( stepExtensionDef, interface )
+
+      elsif stepExtensionDef['input'] || stepExtensionDef['inputs']
+        inputsValues = doLoadInputs( stepExtensionDef, interface )
+      else
+        # msg =<<-EOS.unindent
+        # Extension must define 'validators' or 'input'/'inputs' properties.
+
+        # Erroneous extension definition #{stepExtensionDef}
+        # EOS
+        # @logger.error( "#{__method__} #{msg}" )        
+        # raise ExtensionException.new,  msg
+      end
+
+      if !inputsValues.nil?
+        
+        # convert step inputs to mustache template data
+        mustacheTemplateDatas, mustacheTemplateDatasTypes = toTemplateData( inputsValues )
+
+        # add mustache data to param set to pass to model
+        mustacheTemplateDatas.each do |mustacheTemplateData|
+          stepParamSet.addInput( mustacheTemplateData )
+        end
+        
+      end
+
+
+      # pass step extension to controller
+      controller.extendStep( stepParamSet )      
+      
+    end
+
+    # Generate input values
+    #
+    # @param [Hash]  stepExtensionDef one step to take
+    #
+    # @param [Sbuilder::ParamSet] interface parameter for which
+    # generatio takes place
+    #
+    #
+    # @return [Hash:Array] array of input hashes  to 'interface' operation
+    def doLoadGenerator( stepExtensionDef, interface )
+      # access rules used to generate step input
+      stepValidators = stepExtensionDef['validators']
+      @logger.info "#{__method__}, inputs=#{stepValidators.join(',')}"
+
+      # use generator to create inputs for the step
+      inputsValues = generateInputs( interface, stepValidators  )
+      @logger.info "#{__method__}, inputsValues=#{inputsValues.join(',')}"      
+
+
+      inputsValues      
+      
+    end
+
+    # Expand & maps 'input'/'inputs' in 'stepExtensionDef' to array of hashes
+    # 
+    #
+    # @return [Hash:Array] array of input hashes  to 'interface' operation
+    def doLoadInputs( stepExtensionDef, interface )
+
+      raise ExtensionException.new  <<-EOS if stepExtensionDef['input'] && stepExtensionDef['inputs'] 
+      Property 'input' cannot be defined together with 'inputs' in #{stepExtensionDef.to_yaml}
+
+      Use 
+
+        inputs:
+           - input: 
+                ...
+           - input: 
+                ...
+
+      or for a single input
+
+        input:
+           ....
+      EOS
+
+      # use either 'input' or 'inputs/input'
+      inputs = stepExtensionDef['input'] ?  [ stepExtensionDef['input'] ]  :  stepExtensionDef['inputs'].map { |i| i['input'] }
+      @logger.info "#{__method__}, inputs=#{inputs.join(',')}"
+      
+      # use generator to create inputs for the step
+      inputsValues = expandInputs( inputs, interface   )
+      @logger.info "#{__method__}, inputsValues=#{inputsValues.join(',')}"      
+
+      inputsValues
+      
+    end
+
+    # @!endgroup
+
+    # ------------------------------------------------------------------
+    # @!group Map inputs to domaina
+
+    # Expand domain reference in 'input' domain values in
+    # 'paramSet'. If '_default' parameter given in 'input', add
+    # missing all fields in 'input' with parameters in 'paramSet'
+    #
+    # @param [Sbuilder::ParamSet] paramSet used in expanion
+    #
+    # @param [Hash|Array] input to expand
+    def expandInputs( inputs, paramSet )
+
+      @logger.info "#{__method__} paramSet=#{paramSet}, isArray=#{paramSet.respond_to?(:isArray) ? paramSet.isArray : 'non-array' }"      
+
+      inputs = inputs.kind_of?( Array ) ? inputs : [inputs]
+
+      ret = inputs.map  { |input| expandHash( input, paramSet ) }
+      ret
+      
+    end
+
+
+    #
+    #
+    # @param [Hash] memo which has been expanded so far
+    #
+    # @param [Array] default domain values for _default
+
+    def expandHash( input, paramSet, defaultValues=[], memo={} )
+
+      @logger.debug "#{__method__}: paramSet=#{paramSet}, isArray=#{paramSet.respond_to?(:isArray) ? paramSet.isArray : 'non-array' }, parameters=#{paramSet.parameters.join(',')}"
+
+      # Expect Hash as input
+      if !input.kind_of?( Hash )
+          msg = <<-EOS.unindent
+          Expect 'Hash' as an input,  value '#{input}' is of type '#{input.class}'
+
+          Hash should define values for parameters: #{paramSet.parameters.map {|p| p.name}.join('n') }
+          EOS
+          @logger.error "#{__method__}: #{msg}"
+          raise ExtensionException.new, msg
+      end
+
+      # default is last non nil value on 'defaultValues' stack
+      defaultValues <<  input['_default']
+      defaultValue = defaultValues.reverse.find { |v| !v.nil? }
+      
+
+      # iterate each hash key
+      input.each do |k,v|
+        next if k == '_default'
+        @logger.debug "#{__method__}: k=#{k}, v=#{v}"
+        parameter = paramSet.lookupParameter( k )
+        if parameter.nil?
+          msg = <<-EOS.unindent
+          Unknown parameter name '#{k}'
+
+          Valid names: #{paramSet.parameters.map {|p| p.name}.join(',')}
+          EOS
+          @logger.error "#{__method__} #{msg}"
+          raise ExtensionException.new, msg
+        end
+
+        # Error in array type
+        if parameterIsArray( parameter ) != v.kind_of?( Array )
+          msg = <<-EOS.unindent
+          Expect parameter '#{parameter.name}' #{ parameterIsArray(parameter) ? 'to be an array' : 'not to be an array' }.
+
+          However, input value '#{v}' is '#{ v.kind_of?( Array ) ?  'an array' : 'not an array' }'
+
+          EOS
+          @logger.error "#{__method__} #{msg}"
+          raise ExtensionException.new, msg
+        end
+        
+
+        # Create value for key 'k'
+        case [parameter.class]
+        when [Sbuilder::Parameter_Dom]
+          # validateDomain( parameter, v )
+          memo[k] = v.kind_of?(Array) ?
+                         v.map { |ve| parameterValue( parameter, ve ) } :
+                         parameterValue( parameter, v )
+        when [Sbuilder::Parameter_Ref]
+          memo[k] =  v.kind_of?(Array) ?
+                      v.map { |ve| expandHash( ve, parameter.getResolvedReference, defaultValues ) } :
+                      expandHash( v, parameter.getResolvedReference, defaultValues )
+                      
+        else
+          msg = "Unknown class #{parameter.class}"
+          raise msg
+        end # case
+
+      end # each k,v
+
+      # add defaults to memo - only if defult defined && key not set
+      
+      if !defaultValue.nil?
+        paramSet.parameters.each do |parameter|
+          # add only if value not given
+          if !memo.key?( parameter.name )
+            # add default - unless given
+            case [parameter.class]
+            when [Sbuilder::Parameter_Dom]
+              # use domain value for domain parameters
+              memo[parameter.name] = parameterValue( parameter, defaultValue )
+            when [Sbuilder::Parameter_Ref]
+              # use empty hash as input 
+              subHash = expandHash( {}, parameter.getResolvedReference, defaultValues )
+              memo[parameter.name] = subHash
+            else
+              msg = "Unknown class #{parameter.class}"
+              raise msg
+            end # case
+            
+          end
+        end # parameters
+      end
+      
+      memo
+      
+    end
+
+    # @return [Boolean|String] domain values surrounded by quotoes ,
+    # false = nil value
+    private def parameterValue( parameter, domainId )
+      pv = retriveParameterValue( parameter, domainId )
+      # pv = '"' + pv  + '"' if pv
+      pv 
+    end
+
+    # @return [Boolean|String] domain values, false = nil
+    private def retriveParameterValue( parameter, domainId )
+       parameter.resolvedDomain.render_entry( domainId )
+    end
+
+    # @return [Boolean] true if parameter is array or parameter.refernce is array
+    private def parameterIsArray( parameter )
+      parameter.isArray || ( parameter.isReference && parameter.getResolvedReference.isArray )
+    end
+    
+
+    # @!endgroup    
+    
+
+    # ------------------------------------------------------------------
+    # @!group Generator
+    
+
+    # @return [Array] values respecting 'validators' as input to  'interfaceParamset'
+    def generateInputs( interfaceParamset, validators )
+
+      @logger.info "#{__method__}, interfaceParamset=#{interfaceParamset}, validators=#{validators}"      
+
+      begin
+        step_generator = getStepGenerator
+        step_generator.initParamSet( interfaceParamset, validators )
+        step_values = step_generator.values
+      rescue StepGeneratorException => ee
+
+        msg =<<-EOS.unindent
+        #{ee} 
+
+        Error occurred, when evaluating interface 
+
+        #{interfaceParamset}
+        EOS
+        
+        @logger.error( "#{__method__} #{msg}" )        
+        raise ExtensionException.new,  msg, ee.backtrace
+      end
+
+      @logger.debug "#{__method__}, step_values=#{step_values}"  if @logger.debug?
+
+      return step_values      
+    end
+    
+    
+    # @!endgroup        
+
+    # ------------------------------------------------------------------
+    # @!group Convert ruby containers  to template data
+
+    # param [Array] datas elements (Hashes or single values) to map to
+    # template data
+    #
+    # @return [Array, 'hashes'|'singletons'] templateEntry elements array
+    # for templateData elements, template data type 'hashes' or 'singletons'
+    
+    def toTemplateData( datas )
+
+      @logger.info "#{__method__}, datas=#{datas} #{datas == [] }"
+
+      templateData = []
+      if datas 
+        if datas.any? && datas.first.is_a?( Hash )
+          templateDataType = 'hashes'
+          templateData = datas.map { |data|  { 'rows'=>false, 'columns' => toTemplateEntry( data ), "_comma" =>','} }
+        elsif datas == [] 
+          templateDataType = 'singletons'
+          templateData = [ singleValue( false ) ]
+          @logger.debug "#{__method__}, templateData empty array ret =#{templateData.to_yaml}"          
+        else
+          templateDataType = 'singletons'
+          templateData = datas.map { |data|  singleValue( data ) }
+        end
+
+      end
+      templateData.last['_comma'] = '' if templateData && templateData.any?          
+      @logger.debug "#{__method__}, templateData ret =#{templateData.to_yaml}"
+      return templateData, templateDataType
+      
+    end
+
+    # @param [Hash] hash to convert to template data
+    #
+    # @return [Hash] templateData mapped hash
+    # @option templateData [String] parameter_name key in data
+    # @option templateData [String] domain_element value in data (if singleton value element)
+    # @option templateData [Array] rows array of row elements (if array value )
+    # @option templateData [Array] columns aray (if hash value)
+    # @option templateData [String] _comma
+    # @option templateData [Interger] _index
+    # 
+    # @return [Array] array with one element for each hash key
+    def toTemplateEntry( hash )
+
+      # should not occurr!
+      raise ExtensionException.new, "Error not a hash #{hash}" unless hash.is_a?( Hash )
+
+      recurseHash( hash ) do |memo, t,h,key,val,indx|
+        # common values, _comma will be overridden for the last entry
+        entry = { "parameter_name" => key, '_index'=> indx, "_comma" => ',' }
+        case t
+        when 'v'
+          entry["columns"] = false
+          entry["domain_element"] = false
+          entry["domain_value"] = val   
+          entry["rows"] = false
+        when 'h'                   # hash valuees
+          entry["columns"] = val 
+          entry["domain_element"] = false
+          entry["domain_value"] = false
+          entry["rows"] = false
+        when 'hashes', 'singletons' # array types
+          entry["columns"] = false
+          entry["domain_element"] = false
+          entry["domain_value"] = false
+          entry["row_types"] = t
+          entry["rows"] = val 
+        end # case
+        memo << entry
+      end # recurse
+    end # toTemplateEntry
+
+    # Recurse hash 
+    # 
+    # @return [] 
+    private def recurseHash( hash, memo=[],  &block )
+
+      hash && hash.each_with_index do |(k,v),index|
+        if  v.is_a?( Hash )  then
+          hashVal = toTemplateEntry( v )
+          memo = yield  memo, 'h', hash, k, hashVal, index
+        elsif v.is_a?( Array )  then
+          arrVals, dataTypes = toTemplateData( v )
+          memo = yield  memo, dataTypes, hash, k, arrVals, index             
+        else
+          if !v.nil?
+            # Nil values are omitted,
+            # NB: false is mapped to 'Nil' in spec.code
+            memo = yield memo, 'v', hash, k, v, index
+          end
+        end
+      end
+      # mustache template is logic less, last element in the array
+      # does not have '_comma'
+      memo.last['_comma'] = '' if memo && memo.any?
+      memo 
+    end
+
+    private def singleValue( val, name=false )
+
+      entry = {}
+      entry = { "parameter_name" => name }
+      entry["columns"] = false
+      entry["domain_element"] = false
+      entry["domain_value"] = val
+      entry["_comma"] = ','      
+      entry["rows"] = false
+      @logger.debug "#{__method_}: entry=#{entry}" if @logger.debug?
+      return entry
+      
+    end
+    
+    # @!endgroup    
+
+
+  end # class
+  
+end # module