Class: Sbuilder::ParamSet

Inherits:
ParamSetRoot show all
Includes:
Utils::MyLogger
Defined in:
lib/sbuilder/param_set.rb

Direct Known Subclasses

ParamSetDef, ParamSetStep, ParamSet_Db, ParamSet_If

Constant Summary collapse

PROGNAME =

mixer

nil

Constants included from Utils::MyLogger

Utils::MyLogger::LOGFILE

Instance Attribute Summary

Attributes inherited from ParamSetRoot

#parameters

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Utils::MyLogger

#getLogger, #logfile

Methods inherited from ParamSetRoot

#addParameter, #lookupParameter

Constructor Details

#initialize(options = {}) ⇒ ParamSet

constrcutore



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

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

Class Method Details

.cleanUpName(name) ⇒ Object

make it valid identifier



98
99
100
101
102
 
# File 'lib/sbuilder/param_set.rb', line 98

def self.cleanUpName( name )
  return name ?
           name.gsub( /\./, "_" ) :    # . --> _
           name
end

Instance Method Details

#doGetId ⇒ Object 



64
65
66
67
68
69
 
# File 'lib/sbuilder/param_set.rb', line 64

def doGetId
  msg = "Sub class should implement doGetId -method"
  @logger.error( "#{__method__} #{msg}" )
  return msg
  # raise NoMethodError.new( msg  )
end

#getId ⇒ Object 



59
60
61
 
# File 'lib/sbuilder/param_set.rb', line 59

def getId
  doGetId
end

#getName ⇒ Object

getId with invalid-caharacters as underscpce



105
106
107
108
109
110
111
112
113
114
 
# File 'lib/sbuilder/param_set.rb', line 105

def getName
  return getId.
          gsub( /\//, "_" ).   # / --> _
          gsub( /\(/, "_" ).   # ( --> _
          gsub( /\{/, "_" ).   # { --> _
          gsub( /\}/, "_" ).   # } --> _
          gsub( /\./, "_" ).   # . --> _              
          gsub( /\)/, "_" )    # ) --> _
  
end

#locateParameter(key) ⇒ Object

Locate parameter ‘key’, raise on an error if not found



120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
 
# File 'lib/sbuilder/param_set.rb', line 120

def locateParameter( key )
  key = key.first if key.is_a?( Array )
  @logger.debug( "#{__method__} key=#{key}" )


  # locate key in this paramter set
  # puts "parameters=#{parameters}"
  found = parameters.select do |parameter|
    # puts "parameter.name #{parameter.name} == key = #{key}"
    parameter.name == key
  end.first
  @logger.debug( "#{__method__} key=#{key} --> found='#{found}' found.class=#{found.class}" )
  raise "\n  Could not locate parameter '\#{key}' in parameter set '\#{getId}'\n\n  Valid names in parameter set '\#{getId}':  \#{parameters.map {|parameter| parameter.name}.join(',')}\n\n  EOS\n  \n  return found\n\nend\n" if found.nil?

#matchesWithParamSet(matcher) ⇒ Object

identifier for finding domain matche



55
56
57
 
# File 'lib/sbuilder/param_set.rb', line 55

def matchesWithParamSet( matcher )
  matcher.is_a?( String ) ? getId == matcher  : (getId =~ matcher) != nil
end

#parameter_definitions(model, paramArray = parameters) ⇒ Object

return hash for generation phase, false if no paramteers



76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
 
# File 'lib/sbuilder/param_set.rb', line 76

def parameter_definitions( model, paramArray=parameters )
  arra = paramArray.map.with_index do |p,i|
    # puts "p=#{p}"
    parameter_def = p.parameter_definition( model )
    # puts "parameter_def=#{parameter_def}"
    parameter_def[:parameter_name] = ParamSet.cleanUpName( parameter_def[:parameter_name] )
    
    parameter_def['_comma'] = (i < paramArray.length-1 ? "," : "" )   # empty string for last element
    parameter_def
    # {
    #   :name           => p.name,
    #   :parameter_name => ParamSet.cleanUpName( p.name ),
    #   :type           => p.getType,
    #   :
    # }
  end
  # return false if no parameter
  return false if arra.length == 0
  return arra
end

#parametersToResolve ⇒ Object

normally resolve ‘parameter’ sub-classes may override ie. to include also response parameters to the list of parameters to resolve.



30
31
32
 
# File 'lib/sbuilder/param_set.rb', line 30

def parametersToResolve
  parameters
end

#resolveNeeded(controller) ⇒ Boolean

unsersolved. Uses ‘resolveReference’ to resolve a parameter, if parameter implements this method.

Returns:

  • (Boolean) —

    true is some of of ‘parametersToResolve’



37
38
39
40
41
42
43
44
 
# File 'lib/sbuilder/param_set.rb', line 37

def resolveNeeded( controller )
  # TODO - check parametersToResolve
  # return true
  unresolved = parametersToResolve.select { |p| !( p.isResolved || p.respond_to?(:resolveReference) && p.resolveReference(controller.model))  }
  needed = unresolved.any?
  @logger.debug "#{__method__}: #{getId} resolve needed=#{needed},  unresolved=#{unresolved.map {|u| u.name}.join(',')}, parametersToResolve=#{parametersToResolve.map{|p| p.name }.join(',')}" if @logger.debug?
  needed
end

#to_s ⇒ Object 



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

def to_s
  "#{getId}"
end