Class: Sbuilder::Resolver

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

Constant Summary collapse

PROGNAME =

mixer

nil

Constants included from Utils::MyLogger

Utils::MyLogger::LOGFILE

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Utils::MyLogger

#getLogger, #logfile

Constructor Details

#initialize(options = {}) ⇒ Resolver

constrcutore



17
18
19
20
21
 
# File 'lib/sbuilder/resolver.rb', line 17

def initialize( options = {} )
  @logger = getLogger( PROGNAME, options )
  @logger.info( "#{__method__} initialized" )
  @rules = []
end

Instance Attribute Details

#matcher ⇒ Object (readonly)

String or Regexp to match



8
9
10
 
# File 'lib/sbuilder/resolver.rb', line 8

def matcher
  @matcher
end

#name ⇒ Object (readonly)

identity



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

def name
  @name
end

#rules ⇒ Object (readonly)

array of rules:ResolverRule



7
8
9
 
# File 'lib/sbuilder/resolver.rb', line 7

def rules
  @rules
end

Instance Method Details

#add_rule(rule) ⇒ Object

add to @rules, return @rule



27
28
29
30
 
# File 'lib/sbuilder/resolver.rb', line 27

def add_rule( rule )
  rules << rule
  rules
end

#applyRule(parameter, model) ⇒ Object

iterate rules and find a match, must find one that matches



62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/sbuilder/resolver.rb', line 62

def applyRule( parameter, model )
  # No need resolve referenced paramters
  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

end

#resolveDomains(paramSet, model) ⇒ Object

resolve



51
52
53
54
55
56
57
58
59
 
# File 'lib/sbuilder/resolver.rb', line 51

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

#setMatch(matcher) ⇒ Object

match is ‘String’ or ‘Regexp’



45
46
47
 
# File 'lib/sbuilder/resolver.rb', line 45

def setMatch( matcher )
  @matcher = matcher
end

#setName(name) ⇒ Object

identify right matcher



35
36
37
 
# File 'lib/sbuilder/resolver.rb', line 35

def setName( name )
  @name = name
end