Class: Sbuilder::ResolverRuleMatch

Inherits:
ResolverRule show all
Includes:
Utils::MyLogger
Defined in:
lib/sbuilder/resolver_rule_match.rb

Constant Summary collapse

PROGNAME =

mixer

nil

Constants included from Utils::MyLogger

Utils::MyLogger::LOGFILE

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Utils::MyLogger

#getLogger, #logfile

Methods inherited from ResolverRule

#applyRule

Constructor Details

#initialize(options = {}) ⇒ ResolverRuleMatch

constrcutore



15
16
17
18
19
 
# File 'lib/sbuilder/resolver_rule_match.rb', line 15

def initialize(  options = {} )
  @logger = getLogger( PROGNAME, options )
  @logger.debug( "#{__method__} initialized" )
  super( options )
end

Instance Attribute Details

#domain ⇒ Object (readonly)

Returns the value of attribute domain.



6
7
8
 
# File 'lib/sbuilder/resolver_rule_match.rb', line 6

def domain
  @domain
end

#matchRule ⇒ Object (readonly)

string or regexp



5
6
7
 
# File 'lib/sbuilder/resolver_rule_match.rb', line 5

def matchRule
  @matchRule
end

Class Method Details

.setDomain(parameter, domain, model) ⇒ Object 



53
54
55
56
 
# File 'lib/sbuilder/resolver_rule_match.rb', line 53

def self.setDomain( parameter, domain, model )
    parameter.setDomain( domain )
    parameter.resolveDomain( model )
end

Instance Method Details

#config(matchRule, domain) ⇒ Object

set properties when loading



22
23
24
25
 
# File 'lib/sbuilder/resolver_rule_match.rb', line 22

def config( matchRule, domain )
  @matchRule = matchRule
  @domain = domain
end

#doApplyRule(parameter, model) ⇒ Object

return true if domain resolved



34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/sbuilder/resolver_rule_match.rb', line 34

def doApplyRule( parameter, model )
  @logger.debug( "#{__method__} matchRule=#{matchRule}, matchRule.class=#{matchRule.class} on parameter.getName=#{parameter.getName}" )
  
  # no need to resolve domain  - Paramter_Ref?
  return true unless parameter.respond_to?( :domain )

  # its already read
  return true if parameter.domain
  if  match(  parameter ) then
    @logger.info( "#{__method__} setDomain '#{domain}' on parameter '#{parameter.getName}' based on rule '#{matchRule}'" )
    #
    self.class.setDomain( parameter, domain, model )
    # parameter.setDomain( domain )
    # parameter.resolveDomain( model )
    return true
  end
  return false
end

#match(parameter) ⇒ Object

resolve domain



29
30
31
 
# File 'lib/sbuilder/resolver_rule_match.rb', line 29

def match( parameter )
  matchRule.is_a?( String ) ? parameter.name == matchRule  : (parameter.name =~ matchRule) != nil
end