Class: Sbuilder::StepGenerator

Inherits:
Object
  • Object
show all
Includes:
Utils::MyLogger
Defined in:
lib/sbuilder/extension_loader_step_generator.rb

Constant Summary collapse

PROGNAME =

progname for logger default class name

nil
RULES = 
{
  # triggers on all fields
  'default' => -> (parameter, path, rule_value) { true },
  # triiggers on field with 'path' matching 'rule_value'
  'path' => -> (parameter, path, rule_value ) { path == rule_value },
}
ACTIONS = 
{
  # all domain values are used in value binding, does not yield
  # fixed value
  'all' => {
    :func => -> (index,domValue,validator_value) { true },
    :fixedValue => false,
  },
  # no  domain values are used in value binding, fixed value (no values)
  'none' => {
    :func => -> (index,domValue,validator_value) { false },
    :fixedValue => true,
  },
  # only domain value in "action_value" is used in value binding,
  # fixed value (one domain element)
  'domain' => {
    :func => -> (index,domValue,validator_value) { index==validator_value },
    :fixedValue => true,
  },
}
RULE_VALIDATION =

known rules have an entry here

required in validator

allowed in validator

on ‘validator’ when recurding down paramter sets

{
  'path' =>{
    :required => %w( rule_value ),
    :allowed => [],
  },
  'default' =>{
    :required => [],
    :allowed => [],
  }
}
ACTION_VALIDATION =

known actions have an entry here

{
  'domain' =>{
    :required => %w( action_value ),
    :allowed => []
  },
  'all' =>{
    :required => [],
    :allowed => [],
  },
  'none' =>{
    :required => [],
    :allowed => [],
  }
}
@@validator_required =

check validator hash properties

%w( rule action )
@@validator_allowed = 
%w( action_value rule_value )

Constants included from Utils::MyLogger

Utils::MyLogger::LOGFILE

Instance Attribute Summary collapse

Constructor & build collapse

Build values set collapse

Implement set of valid values collapse

Methods included from Utils::MyLogger

#getLogger, #logfile

Constructor Details

#initialize(options = {}) ⇒ StepGenerator 



275
276
277
278
279
280
 
# File 'lib/sbuilder/extension_loader_step_generator.rb', line 275

def initialize( options = {} )
  if !defined?(@@logger )
    @@logger =getLogger( PROGNAME, options )
  end
  @@logger.info( "#{__method__} initialized, options=#{options}" )        
end

Instance Attribute Details

#domainValues ⇒ Object (readonly) 



204
205
206
 
# File 'lib/sbuilder/extension_loader_step_generator.rb', line 204

def domainValues
  @domainValues
end

#paramSet ⇒ Object 



201
202
203
 
# File 'lib/sbuilder/extension_loader_step_generator.rb', line 201

def paramSet
  @paramSet
end

Class Method Details

.logger ⇒ Object

Allow the one logger to be accessed via class method (within module)



283
284
285
 
# File 'lib/sbuilder/extension_loader_step_generator.rb', line 283

def self.logger
  @@logger
end

.maxPowerSet(size) ⇒ Integer

Returns max elements in set used to generate powerset.

Parameters:

  • size (Integer) —

    of set used to generate powerset

Returns:

  • (Integer) —

    max elements in set used to generate powerset



468
469
470
 
# File 'lib/sbuilder/extension_loader_step_generator.rb', line 468

def self.maxPowerSet( size )
  self.maxSet( 2 ** size, nil )
end

.maxSet(cardinality, parameter, maxElements = 32) ⇒ Object

againts, normally use default value,

Parameters:

  • cardinality (Integer) —

    number of elemets in a set

  • parameter (Sbuilder:Parameter) —

    where cardinality violated

  • maxElements (Integer) (defaults to: 32) —

    number of elements to check



481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
 
# File 'lib/sbuilder/extension_loader_step_generator.rb', line 481

def self.maxSet( cardinality, parameter, maxElements=32)
  if ( cardinality > maxElements )
    msg =  <<-EOS
    Set cardinality '#{cardinality}' too large, max allowed( #{maxElements}).

    EOS
    msg += <<-EOS  if parameter

    when considering domains for parameter '#{parameter.name}'
    EOS
    
    Sbuilder::StepGenerator.logger.error msg 
    raise StepGeneratorException.new, msg
  end
end

Instance Method Details

#currentValue ⇒ Hash

Retrieve current value (stepped)

Returns:

  • (Hash) —

    current value if valid value found, nil if no current value found



410
411
412
413
414
415
416
417
418
419
420
421
422
 
# File 'lib/sbuilder/extension_loader_step_generator.rb', line 410

def currentValue
  memo={}
  # toggle true - if at least one memo element gets generated
  anyValueFound = false
  domainValues.each do |domainValue|
    valueFound,memo = domainValue.currentValue( memo )
    anyValueFound = anyValueFound || valueFound
  end
  # # if value found
  # anyValueFound ? memo : nil
  memo

end

#doValues ⇒ Object 



450
451
452
453
454
455
456
457
458
 
# File 'lib/sbuilder/extension_loader_step_generator.rb', line 450

def doValues
  val = currentValue
  return nil unless val
  vals = [val]
  while nextValue
    vals << currentValue
  end
  vals
end

#initParamSet(initSet, validators = [ {"rule"=>'default', "action"=>'none'} ], parameter_path = []) ⇒ Object

Public service to associate step generator with parameter set, activate validator lamdb for each parameter in parameter set.

Parameters:



296
297
298
299
300
301
302
303
304
 
# File 'lib/sbuilder/extension_loader_step_generator.rb', line 296

def initParamSet( initSet, validators=[ {"rule"=>'default', "action"=>'none'} ], parameter_path=[] )
  # validator congiruation ok wrt initSet
  validateValidators( initSet, validators )

  # no path yet
  parameter_path = []
  startGenerator( initSet, validators, parameter_path )
  
end

#isArray ⇒ Object 



287
288
289
290
 
# File 'lib/sbuilder/extension_loader_step_generator.rb', line 287

def isArray
  paramSet.respond_to?( :isArray ) && paramSet.isArray

end

#nextValue ⇒ Boolean

Iterate all parmeters and return with ‘true’ for the first parameter, which can be advanced. If none of the parameter can be advances, return false. Advancing a parameter cycles a pointer to the next value in an array for valid value bindings for the paramter.

Returns:

  • (Boolean) —

    true is next value generated, false when no more values to return



398
399
400
401
402
403
404
405
 
# File 'lib/sbuilder/extension_loader_step_generator.rb', line 398

def nextValue()
  goon = false
  domainValues.each do |domainValue|
    goon = goon || domainValue.nextValue
    break if goon
  end
  goon
end

#startGenerator(initSet, validators, parameter_path) ⇒ Object

Module internal service, which actually implemented ‘initParamSet’



307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
 
# File 'lib/sbuilder/extension_loader_step_generator.rb', line 307

def startGenerator( initSet, validators, parameter_path )

  Sbuilder::StepGenerator.logger.info "#{__method__}, parameter.length = #{initSet.parameters.length}, validators=#{validators.join(',')}"

  self.paramSet= initSet

  @domainValues = []
  paramSet.parameters.each do |parameter|

    case [parameter.class]
    when [Sbuilder::Parameter_Dom]
      validator, action_value, fixedValue = chooseValidator( parameter, validators, parameter_path )
      domainValue = StepGeneratorValueDomain.new( parameter, validator, action_value, parameter_path, fixedValue  )
      @domainValues << domainValue
    when [Sbuilder::Parameter_Ref]
      referenceValue = StepGeneratorValueRef.new( parameter, validators, parameter_path )
      @domainValues << referenceValue
    else
      msg = "Unknown class #{parameter.class}"
      Sbuilder::StepGenerator.logger.error msg 
      raise msg
    end # case
  end # each

  # # if somethig generated
  # val = currentValue

  # # return empty array else nil
  # return val.nil? ? val : [ ]

end

#validatePath(initSet, path) ⇒ Object

Parameters:

  • paramSet (Sbuilder::ParamSet) —

    where path should be exist

  • array (String:Array) —

    of parameter names



582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
 
# File 'lib/sbuilder/extension_loader_step_generator.rb', line 582

def validatePath( initSet, path )

  # init loop
  currentSet = initSet

  # each path element must find define a path in the tree defined
  # by parameter set
  path.each do |parameterName|
    parameter = currentSet.lookupParameter( parameterName )
    if parameter.nil?
      msg= <<-EOS.unindent
      Path element '#{parameterName}' does not match any valid parameter name: #{currentSet.parameters.map{|p|p.name}.join(',')}

      Error occurred when trying to resolve path #{path} starting from parameter set 
      with parameter names: #{initSet.parameters.map{|p|p.name}.join(',')}
      EOS
      Sbuilder::StepGenerator.logger.error msg 
      raise StepGeneratorException.new, msg
    end
    # advance to next if possible
    currentSet = parameter.respond_to?( :getResolvedReference ) ? parameter.getResolvedReference : nil
  end
end

#validateValidators(initSet, validators) ⇒ Object

“action_value” -properties.



527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
 
# File 'lib/sbuilder/extension_loader_step_generator.rb', line 527

def validateValidators( initSet, validators )

  validators.each do |validator|

    # mantatory properties
    Sbuilder::Utils::Validate.validateProperties( validator, @@validator_required, @@validator_allowed )

    # known rule
    if RULES[validator["rule"]].nil?
      msg= <<-EOS
          Unknown validator rule '#{validator["rule"]}' 

          Valid validator rules:  #{RULES.keys.join(',')}

      EOS
      Sbuilder::StepGenerator.logger.error msg 
      raise StepGeneratorException.new, msg

    end

    # known actions
    if ACTIONS[validator["action"]].nil?
      msg= <<-EOS
          Unknown validator action '#{validator["action"]}' 

          Valid validator rules:  #{ACTIONS.keys.join(',')}

      EOS
      Sbuilder::StepGenerator.logger.error msg 
      raise StepGeneratorException.new, msg

    end

    # rule configuration ok?
    Sbuilder::Utils::Validate.validateProperties(
      validator,
      RULE_VALIDATION[validator['rule']][:required],
      @@validator_required +  @@validator_allowed + RULE_VALIDATION[validator['rule']][:allowed] )        

    # action validation configuration ok?
    Sbuilder::Utils::Validate.validateProperties(
      validator,
      ACTION_VALIDATION[validator['action']][:required],
      @@validator_required +  @@validator_allowed + ACTION_VALIDATION[validator['action']][:allowed] )

    if validator['rule'] == 'path'
      validatePath( initSet, validator['rule_value'] )
    end
    
  end
end

#validValuesSetCardinality ⇒ Integer

Multiply cardinalities of referenced parameters for the cardinality of generator (base set i.e. WITHOUT considering isArray property in @paramSet).

Returns:

  • (Integer) —

    cardinality of the generated set



502
503
504
505
506
507
508
509
510
511
 
# File 'lib/sbuilder/extension_loader_step_generator.rb', line 502

def validValuesSetCardinality

  totalCardinality = 1
  domainValues.each do |domainValue|
    totalCardinality *= domainValue.validValuesSetCardinality
  end
  Sbuilder::StepGenerator.logger.info "#{__method__}, totalCardinality=#{totalCardinality}"      
  totalCardinality
  
end

#values ⇒ nil|Values

Return (cached) value set generated by this generated

Returns:

  • (nil|Values) —

    return (cached) value set generated by this generated



430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
 
# File 'lib/sbuilder/extension_loader_step_generator.rb', line 430

def values

  Sbuilder::StepGenerator.logger.info "#{__method__}, @values=#{@values}, lengh=#{ @values.is_a?(Array) ? @values.length : 'undefined' }"

  return @values if @values

  # ensure that we do not return sets too large
  Sbuilder::StepGenerator.maxSet( validValuesSetCardinality, nil )
  
  baseSet = doValues
  
  Sbuilder::StepGenerator.logger.info "#{__method__}, isArray=#{isArray}, baseSet.length=#{baseSet.length}, validValuesSetCardinality=#{validValuesSetCardinality}"
  
  # ensure that powerset does not grow too large
  Sbuilder::StepGenerator.maxPowerSet( baseSet.length ) if isArray
  @values = isArray ? Sbuilder::Powerset.powerset( baseSet ) :  baseSet

  return @values
end