Class: Sbuilder::Controller

Inherits:
Object
  • Object
show all
Extended by:
Forwardable
Includes:
ControllerUtils, Utils::MyLogger
Defined in:
lib/sbuilder/controller.rb

Constant Summary collapse

DEFAULT_PREFERENCES = 
{
  "debug-output" => true,                     # print debug output e.g. in interface processes
}
PROGNAME =

mixer

nil
@@validSetups_required = 
[ "setupDirectory", ]
@@validSetups_allowed = 
@@validSetups_required + [ 'extensions', "desc", "preferences", "possibilities", 'assumptions', 'configuration']
@@validSetupConfiguration_required = 
[]
@@validSetupConfiguration_allowed = 
['allow_domain_nil_values']
@@extensionLoaderDef_required = 
[ ]
@@extensionLoaderDef_oneof = 
["url", "file",]
@@extensionLoaderDef_defaults = 
{
  'type' => Sbuilder::Constants::EXTENSION_LOADER_YAML
}
@@extensionLoaderDef_allowed = 
@@extensionLoaderDef_required + @@extensionLoaderDef_oneof + ['type']
@@snippetLoader_required = 
[  'metatype', 'appName', 'file' ]
@@snippetLoader_allowed = 
@@snippetLoader_required  + []
@@resolverLoader_required = 
[ ]
@@resolverLoader_oneof = 
["url", "file",]
@@resolverLoader_defaults = 
{
  'type' => Sbuilder::Constants::MAPPER_YAML
}
@@resolverLoader_allowed = 
@@resolverLoader_required + @@resolverLoader_oneof + ['type']
@@validConfig = 
%w( generate )
@@allowConfig = 
@@validConfig + %w( extend extensions setups preferences resolvers interfaces invariants snippets )
@@extend_required = 
%w(  )
@@extend_allowed = 
@@extend_required + %w( loaders )
@@validGenerateConfigs = 
["output", "inputs"]
@@allowedGenerateConfigs = 
@@validGenerateConfigs + ['category']
@@validGenerateDef_required = 
[ "template", "desc", "modelData" ]
@@validGenerateDef_allowed = 
@@validGenerateDef_required + [ "templateParameters", 'type', 'symbols' ]

Constants included from Utils::MyLogger

Utils::MyLogger::LOGFILE

Instance Attribute Summary collapse

processing steps collapse

Public services collapse

Used by resolveExtensionPartials collapse

Access sbuilder.yaml configuration collapse

Access symbol table collapse

output collapse

Instance Method Summary collapse

Methods included from ControllerUtils

#dispatchExtendDomain, #extendDomainRange, #extendDomainWithCardinality, #extendDomainWithType, #extendDomainWithValues, #setApplicationDomainValues

Methods included from Utils::MyLogger

#getLogger, #logfile

Constructor Details

#initialize(factory, options = {}) ⇒ Controller

constructore



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

def initialize( factory, options = {} )
  
  @logger = getLogger( PROGNAME, options )
  @logger.info( "#{__method__} initialized, options=#{options}" )

  # init configs
  @opts = { :gen_dir => options[:gen_dir] || Sbuilder::Constants::GEN_DIR,
            # :src_dir => options[:src_dir] || Sbuilder::Constants::SRC_DIR,
            :cnf_dir => options[:cnf_dir] || Sbuilder::Constants::CNF_DIR,
            :cache_dir => options[:cache_dir] || Sbuilder::Constants::CACHE_DIR,
            :cnf_file => options[:cnf_file] || Sbuilder::Constants::CNF_FILE,
            :verbosity => options[:verbosity].nil? ? Sbuilder::Constants::OPT_VERBOSITY : options[:verbosity],
            :filter_src => options[:filter_src] || false,
            :templates => options[:templates] || [ Sbuilder::Constants::SRC_PATH],
            :default_templates => options[:default_templates] || [Sbuilder::Constants::TEMPLATE_GEM],
          } #.merge( options[PROGNAME] || {} )
  setFactory( factory )

  # populated in 'resolveExtensionPartials'
  @partials = initPartials

  # reset controller state (for each setup)
  start
end

Instance Attribute Details

#factory ⇒ Object (readonly) 



12
13
14
 
# File 'lib/sbuilder/controller.rb', line 12

def factory
  @factory
end

#mappers ⇒ Object (readonly)

@əttr [Resolver] mappers array of loader ‘Resolver’ objects



15
16
17
 
# File 'lib/sbuilder/controller.rb', line 15

def mappers
  @mappers
end

#model ⇒ Object (readonly) 



31
32
33
 
# File 'lib/sbuilder/controller.rb', line 31

def model
  @model
end

#partials ⇒ Object (readonly) 



20
21
22
 
# File 'lib/sbuilder/controller.rb', line 20

def partials
  @partials
end

#updatedSetups ⇒ Object (readonly)

configuration



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

def updatedSetups
  @updatedSetups
end

Instance Method Details

#addPartials(resolved_partials, extensionPoint, deprecated = false) ⇒ Array

Add ‘resolved_partials’ found in extensionTemplate to ‘extension_point( extensionTemplate )`

(e.g. const, see src/extend/extend_*.tla)

‘extensionTemplate’

‘extensionTemplate’ file

Parameters:

  • extensionPoint (String) —

    name of extension point

  • depracted (Boolean) —

    true when adding partials included using {>partial} syntax

  • partials (Hash) —

    a customizable set of options

Returns:

  • (Array) —

    partials collected



789
790
791
792
793
794
795
796
797
798
799
800
 
# File 'lib/sbuilder/controller.rb', line 789

def addPartials( resolved_partials, extensionPoint, deprecated=false )
  raise "extensionPoint is nil" if extensionPoint.nil?
  raise "@partials[extensionPoint] is  nil" if @partials[extensionPoint].nil?
  @logger.info( "#{__method__} extensionPoint=#{extensionPoint}:#{extensionPoint.class} added #{resolved_partials.join(',')}" )
  @partials[extensionPoint] += resolved_partials
  if deprecated
    @logger.warn "Using DEPRACTED extension point '#{extensionPoint}' for partials: #{resolved_partials.join(', ')}"
    @partials["DEPRECATED-#{extensionPoint}"] = resolved_partials
  end
  # @logger.debug "#{__method__} partials=#{partials}"
  @partials
end

#baseExtensionDefine ⇒ Object

define base/common domains for model

See Also:



713
714
715
716
717
718
 
# File 'lib/sbuilder/controller.rb', line 713

def  baseExtensionDefine
  Constants::BASE_EXTENSIONS_DOMAIN.each do |domainDef|
    model.domainEncountered( domainDef['domain'] )
  end
  
end

#baseExtensionSetup ⇒ Object

extend sbuilder domains, and application domains (literal values) before setup extensions are loader

See Also:



690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
 
# File 'lib/sbuilder/controller.rb', line 690

def  baseExtensionSetup

  # literal in application 
  model.applicationDomainValues.each do |domainDef|
    @logger.info "#{__method__}: application-domainDef=#{domainDef}"        
    dispatchExtendDomain( domainDef )        
  end

  # defined in sbuilder - sbuilder knows these better than application
  # howver setup may override
  Constants::BASE_EXTENSIONS_DOMAIN.each do |domainDef|
    @logger.info "#{__method__}: sbuilder-domainDef=#{domainDef}"
    dispatchExtendDomain( domainDef )
  end

  
  
end

#baseMetatypes ⇒ Hash:Array

Returns baseMetatype definitions.

Parameters:

  • baseMetatype (Hash) —

    a customizable set of options

Returns:

  • (Hash:Array) —

    baseMetatype definitions



553
554
555
 
# File 'lib/sbuilder/controller.rb', line 553

def baseMetatypes
  Sbuilder::Constants::META_MODEL
end

#decorateRenderData(renderData, mustache) ⇒ Hash

Add functions used in mustache rendering sections to ‘renderData’

mustache rendering.

Parameters:

  • renderData (Hash) —

    to decorate

  • mustache (Mustache) —

    template tool to reander section text

Returns:

  • (Hash) —

    renderData decorated with functions uses in



1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
 
# File 'lib/sbuilder/controller.rb', line 1322

def decorateRenderData( renderData, mustache )

  # META
  renderData['META'] =
    {
      :version => Sbuilder::version,
      :model_version => Sbuilder::model_version,            
      :timestamp => Time.new.strftime( "%Y-%m-%d %H:%M:%S" ),
      # :desc => generateDef['desc'],
      
      # :modelData => generateDef['modelData'],
      # :template => template,
      # :setup => setupName,
      # :outputDirectory => File.dirname( outputPath ),            
      # :outputFile => File.basename( outputPath ),
      # :outputModule => File.basename( outputPath, ".*" ),
    }

  
  
  renderData['SPEC_NAME'] = lambda do |type_appName|
    key = mustache.render( type_appName, renderData )
    keys = key.split( '.' )
    begin 
      ret = getSymbolTable.lookupSymbol( keys[1], keys[0] )
    rescue Exception => ee
      msg =<<-EOS
          Error 

               #{ee} 

          Error encounterd, when accessing symbol table using key '#{type_appName}' in SPEC_NAME -lambda
      
          EOS
      @logger.error( "#{__method__} #{msg}" )        
      raise ControllerException.new,  msg, ee.backtrace
    end
    ret
  end

  renderData
  
end

#extensionTemplate2Name(extensionTemplate) ⇒ String

Extract extension point name from ‘extensionTemplate’

template name e.g. const

Parameters:

  • extensionTemplate (String) —

    e.g. extend/extend_const.mustache

Returns:

  • (String) —

    extension point name extracted from extesion



808
809
810
811
812
 
# File 'lib/sbuilder/controller.rb', line 808

def extensionTemplate2Name( extensionTemplate )
  name = extensionTemplate[/.*\/extend_([^.]+)/,1]
  # @logger.debug "#{__method__}, name=#{name}:#{name.class}, extensionTemplate=#{extensionTemplate}:#{extensionTemplate.class}"
  return name
end

#findResolver(name) ⇒ first

Returns resolver with ‘name’.

Parameters:

  • name (String) —

    resolver to find

Returns:

  • (first) —

    resolver with ‘name’



345
346
347
 
# File 'lib/sbuilder/controller.rb', line 345

def findResolver( name )
  @mappers.select{  |mapper| mapper.name == name }.first
end

#findResolverForParameterSet(paramSet) ⇒ Object

resolve



849
850
851
852
853
854
855
856
 
# File 'lib/sbuilder/controller.rb', line 849

def findResolverForParameterSet( paramSet )
  mappers.each do |mapper|
    if paramSet.matchesWithParamSet( mapper.matcher ) then
      return mapper
    end
  end
  return nil
end

#generateCase(setupName, directoryPath, generateCategory, mustache, &blk) ⇒ Object

Output setup for ‘setupName’ to ‘extensionDirectory’.

outputting files

‘generateCategory’, Nil = no category defined. Intended usage for to generate possibitilies.

Parameters:

  • setupName (String) —

    identitying setup to process

  • directoryPath (String) —

    path to directory under which

  • generateCategory (Nil|String) —

    choose templates in

  • mustache (Sbuilder::Template) —

    generator to render

  • blk (Block) —

    to use indirection in output files stuff



1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
 
# File 'lib/sbuilder/controller.rb', line 1023

def generateCase( setupName, directoryPath, generateCategory, mustache, &blk )
  
  @logger.info( "#{__method__} directoryPath=#{directoryPath}" )

  # configs in 'generate' -property with correct 'category'
  generateConfigs = getGenerateConfig( generateCategory )

  # create all files defined in 'generateConfigs'
  generateConfigs.each do |generateFile|

    # validate generate configuration 
    validateProperties( generateFile, @@validGenerateConfigs, @@allowedGenerateConfigs )

    # use 'output' config or indirection using blk
    outputDefinitions = blk ?
                         yield(  generateFile['output'] ) :
                         [
                           {
                             :possibility => nil,
                             :outputFile => generateFile['output'],
                           }
                         ]
    @logger.debug( "#{__method__}: outputDefinitions=#{outputDefinitions}" )

    # one config in 'generateFile['output']' may result to sevaral files (possiblity)
    outputDefinitions.each do |outputDefinition|

      # set model data - to be able to access in template
      model.setPossibility( outputDefinition[:possibility] )
      
      # Ensure directory for 'outputFile' exists
      outputFile = outputDefinition[:outputFile]
      outputPath = "#{directoryPath}/#{outputFile}"
      # create sub directory for output if it does not exist
      outputDirectory = File.dirname( outputPath )
      Dir.mkdir( outputDirectory ) unless File.exist?( outputDirectory )

      # header for file
      output( 2, "--> generate: #{outputPath}" )
      
      # open file and output in 'generateTemplate'
      f = File.open( outputPath, "w" )
      begin
        # one output file get generates using multiple 'inputs'
        generateFile['inputs'].each do |generateDef|
          generateTemplate( setupName, outputPath, f, generateDef, mustache )
        end
      ensure
        f.close
      end
      output( 3, "\n" )
    end # each outputFiles

  end
  
end

#generateSetup(setupName = "default", extensionDirectory = "default") ⇒ Object

start, load, resolve, extend && render

Parameters:

  • setupName (String) (defaults to: "default") —

    name of setup, currently = extensionDirectory

  • extensionDirectory (String) (defaults to: "default") —

    directory where setup generated



897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
 
# File 'lib/sbuilder/controller.rb', line 897

def generateSetup( setupName="default", extensionDirectory="default" )
  @logger.info( "#{__method__} setupName=#{setupName}, extensionDirectory=#{extensionDirectory}" )

  processSetup( setupName )  do |name, setupConf, possibilities|
  
    # config && get renderer
    mustache = prepareRender( setupName )

    # path to directory where setup output is done
    directoryPath = prepareSetupDir( extensionDirectory )
    
    # output 'normal templates' - one generate def/one output
    generateCase( setupName, directoryPath, nil, mustache )

    # For 'possibities': map array of possibilities to array
    # of filenames created using an output -property on
    # 'generate' definition
    possibilities && possibilities.any? && generateCase( setupName, directoryPath, 'possibility', mustache ) do |output|
      # use output as template rendering
      possibilities.map do |p|
        {
          :possibility => p,
          :outputFile => mustache.render_str( output, { "possibility" =>  p } ),
        }
      end # map
    end
  
  end
  
end

#generateTemplate(setupName, outputPath, fileHandle, generateDef, mustache) ⇒ Object

Expand template ‘generateDef’ using ‘templateData’

Create templateData to pass to rendering: (CONFIG,META, PARAMETERS,PREFERENCES, filter), render template(s) named in ‘generateDef.template’, output to ‘fileHandle’.

:template,:desc,:modelData,:templateParameters controlling output

Parameters:

  • outputPath (String) —

    path of file to output

  • f (File) —

    file handle (for ‘outputPath’ to output )

  • mustache (Sbuilder::Template) —

    mustache template generator

  • generateDef (Hash) —

    configuration



1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
 
# File 'lib/sbuilder/controller.rb', line 1096

def generateTemplate( setupName, outputPath, fileHandle, generateDef, mustache )

  # validate configuration
  validateProperties( generateDef, @@validGenerateDef_required, @@validGenerateDef_allowed )

  # access data to output - and filter it
  renderData = templateData( generateDef['modelData'] )
  # e.g. prune interfaces not used in setup
  renderData = setupFilter( generateDef['modelData'], renderData )
  
  # # Iterate each 'template' in one 'generateDef' array (most often just one template)
  # templates = generateDef['template'].is_a?( Array ) ? generateDef['template'] : [ generateDef['template'] ]
  template = getGenerateTemplate( generateDef )
  # @todo: remove array
  templates = [template]

  # Support template paramaters
  templateParameters = generateDef['templateParameters'].nil? ? {} : generateDef['templateParameters']
  
  # optional parameters added in generate -section
  renderData['PARAMETERS'] = templateParameters

  # META-data added to data to render
  templates.each do |template|

    renderData['CONFIG'] = @opts

    renderData['META'] =
      {
        :desc => generateDef['desc'],
        :modelData => generateDef['modelData'],
        :template => template,
        :version => Sbuilder::version,
        :model_version => Sbuilder::model_version,            
        :timestamp => Time.new.strftime( "%Y-%m-%d %H:%M:%S" ),
        :setup => setupName,
        :outputDirectory => File.dirname( outputPath ),            
        :outputFile => File.basename( outputPath ),
        :outputModule => File.basename( outputPath, ".*" ),
      }

    renderData['ACTIONS'] = {
      :cat => lambda do |path_template|
        path = mustache.render_str( path_template, renderData )
        File.readlines( path.strip ).join('')
      end,
      :dump_partials => lambda do |partial_type|
        partialNames = partials[partial_type] || []
        "#{partial_type} --> #{partialNames.join( ',' )}"
      end,
    }

    # specName <- SPEC_NAME( metatype, appName ) 
    renderData['SPEC_NAME'] = lambda do |type_appName|
        key = mustache.render_str( type_appName, renderData )
        keys = key.split( '.' )
        begin 
          ret = getSymbolTable.lookupSymbol(keys[1], keys[0] )
        rescue Exception => ee
          msg =<<-EOS
          Error 

               #{ee} 
          when accessing symbol table using key #{type_appName}
      
          EOS
          @logger.error( "#{__method__} #{msg}" )        
          raise ControllerException.new,  msg, ee.backtrace
        end
        ret
    end
    

    # support 'PREFERENCES'
    renderData.merge!( getSetupPREFERENCES(setupName) )

    # finally render i.e. create string to output
    begin
      str = mustache.to_str( template, renderData )
    rescue Exception => ee
      msg =<<-EOS
      Error

      #{ee} 

      when rendering template '#{template} using data
      
      #{renderData.to_yaml}
      
      EOS
      @logger.error( "#{__method__} #{msg}" )        
      raise ControllerException.new,  msg, ee.backtrace
    end
      
    
    # output to file
    @logger.info( "#{__method__} templateName=#{template}" )
    output( 3, "    ---> #{generateDef['desc']} (#{template})" )
    fileHandle.puts str
    
  end # templates.each

end

#getCacheDir ⇒ String

Return cache directory location from opitions

Returns:

  • (String) —

    path to cache -directory



1512
1513
1514
 
# File 'lib/sbuilder/controller.rb', line 1512

def getCacheDir
  getOpt(:cache_dir)
end

#getCodeRepository ⇒ String

Currently uses first element in template as code repostirory

Returns:

  • (String) —

    path to code repository



1505
1506
1507
 
# File 'lib/sbuilder/controller.rb', line 1505

def getCodeRepository
  getOpt( :templates ).first
end

#getCommonPreferences ⇒ Object

Get preferences for default+common



1485
1486
1487
 
# File 'lib/sbuilder/controller.rb', line 1485

def getCommonPreferences
  DEFAULT_PREFERENCES.merge( getPreferences )
end

#getCommonPreferencesData ⇒ Hash

default preferences, and common preference from sbuilder.yaml

Returns:

  • (Hash) —

    render data with ‘PREFERENCES’ -property with



1474
1475
1476
 
# File 'lib/sbuilder/controller.rb', line 1474

def getCommonPreferencesData
  getPreferencesDataHash( getCommonPreferences() )
end

#getConfig ⇒ Object

cache ‘@controller_config’ read ‘getConfigFilePath’ and ‘getInternalConfigFilePath’, merge ‘generate’



1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
 
# File 'lib/sbuilder/controller.rb', line 1373

def getConfig

  return @controller_config if @controller_config
  
  @logger.info( "#{__method__} loading config from #{getConfigFilePath}" )
  yaml_lines = Sbuilder::Utils::NetIo.read_lines( getConfigFilePath )
  @controller_config = YAML.load( yaml_lines )
  # allow empty generate section
  @controller_config = {} if @controller_config.nil?
  @controller_config['generate'] = [] unless @controller_config['generate']
  @logger.debug( "#{__method__} config in #{getConfigFilePath} controller_config= #{@controller_config.to_yaml}" )

  yaml_lines = Sbuilder::Utils::NetIo.read_lines( getInternalConfigFilePath )
  internal_config = YAML.load( yaml_lines )
  internal_config['generate'] = [] unless internal_config['generate']
  @logger.debug( "#{__method__} internal_config= #{internal_config.to_yaml}" )      

  @logger.debug( "#{__method__} config in #{getInternalConfigFilePath} internal_config= #{internal_config.to_yaml}" )      
  @controller_config['generate'] = @controller_config['generate'] + internal_config['generate']
  @logger.debug( "#{__method__} @controller_config=#{@controller_config.to_yaml}" )
  validateProperties( @controller_config, @@validConfig, @@allowConfig  )
  @controller_config
end

#getEntryPoints ⇒ String:Array

Return ‘implementation’ and ‘complation’ for interfaces, which are referenced on steps.

Return also

Returns:



1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
 
# File 'lib/sbuilder/controller.rb', line 1266

def getEntryPoints
  setup_operations = {}
  
  steps = model.templateData( "steps" )['steps']
  interfaces = model.templateData( "interfaces" )['interfaces']
  
  steps.each { |s| setup_operations[s[:interface_operation]] = true }
  @logger.debug( "#{__method__}:  setup_operations= #{setup_operations}" )
  entry_points = interfaces.
                  select {|i| setup_operations[i[:interface_operation]] }.
                  map { |i|  [ i[:implementation], i[:completion]] }.
                  flatten.
                  select {|e| e }
                        
  @logger.info( "#{__method__}:  entry_points= #{entry_points}" )      
  entry_points
  
end

#getExtensionPointPartials(template_name, deprecated = false) ⇒ String

Retrun list of template partials in extension points for template_name.

using {>partial} syntax, in this case return all depracted partials

Parameters:

  • template_name (String) —

    to map extension point key

  • depracted (Boolean) —

    true when accessing partials included

Returns:

  • (String) —

    partials for extension point



831
832
833
834
835
836
837
838
839
840
841
842
843
 
# File 'lib/sbuilder/controller.rb', line 831

def getExtensionPointPartials( template_name, deprecated=false )

  if ( deprecated ) then
    ret = partials.keys.select { |k| k.start_with?( "DEPRECATED" )}.
          map { |k| partials[k] }.flatten
    @logger.warn "Returning DEPRACTED extension point partials: #{ret.join(', ')}"
    return ret
  end
  
  extension_point = extensionTemplate2Name( template_name )
  @logger.debug "#{__method__} lookup partials #{template_name}->#{extension_point} -> "
  return partials[extension_point] 
end

#getMetaTypeDefinition(metatype) ⇒ Object 



1561
1562
1563
 
# File 'lib/sbuilder/controller.rb', line 1561

def getMetaTypeDefinition( metatype )
  getSymbolTable.getMetaTypeDefinition( metatype )
end

#getModelInvariants ⇒ String:Array

Return model invariant defined in sbuilder

Returns:

  • (String:Array) —

    of invariant names



1299
1300
1301
1302
1303
1304
 
# File 'lib/sbuilder/controller.rb', line 1299

def getModelInvariants
  names = []
  getInvariantConfig.each { |invariant| names += invariant.keys }
  @logger.info "#{__method__} invariants=#{names.join(',')}"
  return names
end

#getModelNames ⇒ String:Array

Return names (e.g. definitions, domains) defined in the specification model.

Returns:

  • (String:Array) —

    of names in defined in model



1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
 
# File 'lib/sbuilder/controller.rb', line 1246

def getModelNames
  ret = []
  
  # definition map to types 't_:defintion_name'
  ret += templateData( "definitions" )['definitions'].map { |d| "t_#{d[:definition_name]}"}

  # domain --> 'd_:domain_name'
  ret += templateData( "domains" )['domains'].map { |d| "d_#{d[:domain_name]}"}      
  
  @logger.debug( "#{__method__}: ret=#{ret.join(',')}" )
  ret
end

#getPreferences ⇒ Object

Access preferences in main configuration file ‘sbuilder.yaml’

non-nil)



1493
1494
1495
 
# File 'lib/sbuilder/controller.rb', line 1493

def getPreferences
  getConfig()['preferences'] || {}
end

#getSetup(setupName) ⇒ Hash

For ‘setupName’ return configuration, which may be overridden from setup extension loaders. (@see updateSetup)

Parameters:

  • setupName (String) —

    name of setup to get

Returns:

  • (Hash) —

    hash of set in sbuilder configuration



1409
1410
1411
 
# File 'lib/sbuilder/controller.rb', line 1409

def getSetup( setupName )
  (initialGetSetup( setupName ) || {} ).merge( updatedSetups[setupName] || {} )
end

#getSetupAssumes ⇒ String:Array

‘setups.supet.assumptions’ property

Returns:

  • (String:Array) —

    names of setup assumes from



1309
1310
1311
 
# File 'lib/sbuilder/controller.rb', line 1309

def getSetupAssumes
  model.assumptions.map{|a| a[:name] }
end

#getSetupAssumptionList(setupDef) ⇒ String:Array

Returns name of assumption in setup, [] if none.

Parameters:

  • setupDef (Hash) —

    setup configuration

Returns:

  • (String:Array) —

    name of assumption in setup, [] if none



1453
1454
1455
 
# File 'lib/sbuilder/controller.rb', line 1453

def getSetupAssumptionList( setupDef )
  return setupDef['assumptions'] || []
end

#getSetupExtensions(setupName) ⇒ Hash:Array

Returns of ‘type’, ‘url’|‘file’ properties.

Returns:

  • (Hash:Array) —

    of ‘type’, ‘url’|‘file’ properties



1440
1441
1442
1443
 
# File 'lib/sbuilder/controller.rb', line 1440

def getSetupExtensions( setupName )
  @logger.debug( "#{__method__} setupName=#{setupName}" )            
  getSetup( setupName )['extensions'] || []
end

#getSetupPossibilities ⇒ String:Array

Return possibilities for current setup.

Returns:

  • (String:Array) —

    of possibiliy operator names



1288
1289
1290
1291
1292
 
# File 'lib/sbuilder/controller.rb', line 1288

def getSetupPossibilities
  setupPossis = model.possibilities
  @logger.info( "#{__method__}:  setupPossis= #{setupPossis}" )
  return setupPossis
end

#getSetupPossibilitiesList(setupName) ⇒ String:Array

Returns of setup possibilities.

Returns:

  • (String:Array) —

    of setup possibilities



1446
1447
1448
1449
 
# File 'lib/sbuilder/controller.rb', line 1446

def getSetupPossibilitiesList( setupName )
  @logger.debug( "#{__method__} setupName=#{setupName}" )            
  getSetup( setupName )['possibilities'] || []
end

#getSetupPrefences(setupName) ⇒ Hash

Returns preferences in setup or {}.

Parameters:

  • setupName (String) —

    name of setup in ‘setups’ propertys

Returns:



1499
1500
1501
 
# File 'lib/sbuilder/controller.rb', line 1499

def getSetupPrefences( setupName )
  getSetup(setupName)['preferences'] || {}
end

#getSetups ⇒ Object 



1397
1398
1399
 
# File 'lib/sbuilder/controller.rb', line 1397

def getSetups
  getConfig()['setups']
end

#getSetupStepInterfaceOperations ⇒ String:Array

Read model#templateData(‘steps’) and return array interface operations reference in model steps.

Returns:

  • (String:Array) —

    of interface operation names



1234
1235
1236
1237
1238
1239
1240
 
# File 'lib/sbuilder/controller.rb', line 1234

def getSetupStepInterfaceOperations
  interface_operations = {}
  model.templateData( "steps" )['steps'].each  {|s| interface_operations[s[:interface_operation]] = true }
  ret = interface_operations.keys
  @logger.info( "#{__method__}: interface_operations=#{ret}" )
  return ret
end

#initialGetSetup(setupName) ⇒ Hash

Return data for setup as configured in main-configuration file

Parameters:

  • setupName (String) —

    name of setup to get

Returns:

  • (Hash) —

    hash of set in sbuilder configuration



1419
1420
1421
1422
1423
 
# File 'lib/sbuilder/controller.rb', line 1419

def initialGetSetup( setupName )
  setup = getSetups.select { |setup| setup['setupDirectory'] == setupName }.first
  @logger.debug( "#{__method__} setupName=#{setupName}, setup=#{setup} " )      
  setup
end

#initializeSymbolTable ⇒ Object

Add initial symbols to symbol table from generate definition producing module ‘tla/model.tla`



568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
 
# File 'lib/sbuilder/controller.rb', line 568

def initializeSymbolTable
  @logger.info "#{__method__} start"

  # Access (cached) symbol table for the specification model 
  symbolTable = getSymbolTable

  # Generate definition used to render tla/model.tla
  modeltemplate = getModelTemplate

  # iterate inputs used to generate 'tla/model.tla', and
  # locate entries defining 'symbols', and use the
  # label to generate symbol table entries

  # process all input definitions & consider only templates defining `modelData`
  modeltemplate['inputs']. reject{ |i| i['modelData'].nil? }.each do |input|

    # lamdba function to map element in modelData -array to symbol
    # table definitions. Lamda on input definition takes
    # precedence.  Notice that input['symbols'] is actually a
    # string which we have to convert to proc
    
    next unless input['symbols']
    

    # access model data, data array in 
    modelData = templateData( input['modelData'] )
    d = modelData[input['modelData']]
    @logger.debug  "#{__method__} input['modelData']=#{input['modelData']}--> #{d}"
    next unless d && d.any? 

    # allow one entry to define multiple symnbols
    symbols = input['symbols'].is_a?( Array )  ? input['symbols'] : [ input['symbols']]
    
    symbols.each do |symbol|

      # it is a string, which needs to be evaluated to Proc
      symbolsProc =   eval  symbol

      # Add symbols to symbol table if 'symbols' lambda defined &&
      # array modelData contains some symbols to add to symbol table
      d.each_with_index do |element, index|

        # Use lambda to  map data model to symbol definition
        symbolDefinition = symbolsProc.call( element )
        # puts  "symbolDefinition=#{symbolDefinition}"
        @logger.debug  "#{__method__} #{element} --> symbolDefinition #{symbolDefinition ? symbolDefinition.join(',') : 'nil' }"

        # symbol definition is an array which can be unarrayd to define symbols, nil means no symbols found 
        symbolTable.addSymbol( *symbolDefinition ) unless symbolDefinition.nil?
        
      end # iterata modelData
    end # each - possible mutliple symbol defs
    
  end
end

#initializeSymbolTableMetaModel ⇒ Object

Create metamodel definitions in symbol table



535
536
537
538
539
540
541
542
543
544
545
546
547
548
 
# File 'lib/sbuilder/controller.rb', line 535

def initializeSymbolTableMetaModel

  @logger.info "#{__method__}, symbol table meta model inialization starts"
  
  # Sbuilder::Constants::META_MODEL.each do |metatypeDef|
  baseMetatypes.each do |metatypeDef|

    @logger.info "#{__method__}, initiazlie symbol table metatypeDef=#{metatypeDef}"

    # add metatype to symbol table
    registerMetatype( metatypeDef )
    
  end
end

#is_extension_point(template_name) ⇒ Boolean

Returns true if.

Returns:

  • (Boolean) —

    true if



816
817
818
 
# File 'lib/sbuilder/controller.rb', line 816

def is_extension_point( template_name )
  return template_name.match( /extend\/.*\.mustache/ )
end

#load ⇒ Object

TODO:

move implementation extension to model construct phase and

This means that symbol table cannot be initalized here (because it load implementation names, which are defines in setup extesion).

initalize symbol table herre



450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
 
# File 'lib/sbuilder/controller.rb', line 450

def load
  @logger.info( "#{__method__} load started" )      
  loadResolvers( getResolversConfig )
  loadInterfaces( getInterfaceConfig   )
  loadInvariants( getInvariantConfig )

  # extract static partial calls in mustache templates into an array
  resolveExtensionPartials

  # create sbuilder (e.g. domain BOOLEAN) + application model
  # extension (literals identified in application)
  
  baseExtensionDefine
  
  # create domain model i.e. resolve domains
  resolve

  # snippet may refer to symbol table -> init before snippet ldr
  initializeSymbolTableMetaModel

  # init symbol table with names in sbuilder & interface model
  initializeSymbolTable

  # snippet load extension point
  loadSnippets( getSnippetConfig )

  # topological sort 
  sortPartials
  
end

#loadExtensions(setupName) ⇒ Object

Load setup specific extensions (e.g. possibilities, extend domains, extend implementation)

def loadExtensions( arrayOfExtensionDefs )

Parameters:

  • setupName (String) —

    name of setup, currently = extensionDirectory



655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
 
# File 'lib/sbuilder/controller.rb', line 655

def loadExtensions( setupName )

  # extension common for all setups
  baseExtensionSetup

  # access sbuilder.yaml configuration
  arrayOfExtensionDefs = getSetupExtensions( setupName )

  # iterate
  arrayOfExtensionDefs && arrayOfExtensionDefs.each do |extensionLoaderDef|
    validateProperties( extensionLoaderDef, @@extensionLoaderDef_required, @@extensionLoaderDef_allowed )
    validateOne( extensionLoaderDef, @@extensionLoaderDef_oneof )
    # ensure defaults in properties
    extensionLoaderDef = defaultProps( extensionLoaderDef, @@extensionLoaderDef_defaults )
    

    @logger.info( "#{__method__} extensionLoaderDef=#{extensionLoaderDef}" )
    loader = factory.getExtensionLoader( extensionLoaderDef['type'], setupName )
    begin
      loader.load( getFileUrlOrPath( extensionLoaderDef ), self  )
    rescue Exception => ee
      msg = "Error #{ee} caused by #{ee.backtrace.join("\n")} when loading '#{extensionLoaderDef['url']}'\n\n"
      @logger.error( "#{__method__} #{msg}" )        
      raise ControllerException.new,  msg, ee.backtrace
    end
  end
  # domainLoader = factory.get
end

#loadInterfaces(arrOfparamsetTypePath) ⇒ Object

Parameters:

  • arrOfparamsetTypePath (Hash:Array) —

    of :type,:file|:url,:cache properties



354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
 
# File 'lib/sbuilder/controller.rb', line 354

def loadInterfaces( arrOfparamsetTypePath )
  !arrOfparamsetTypePath.nil? && arrOfparamsetTypePath.each do |interfaceParamsetDef|

    begin
      Utils::Validate.validateProperties( interfaceParamsetDef, Constants::VALIDATION[:api_loader_instantiate][:required], Constants::VALIDATION[:api_loader_instantiate][:allowed] )
      Utils::Validate.oneOf( interfaceParamsetDef, Constants::VALIDATION[:api_loader_instantiate][:one_of_class_or_object] )
      Utils::Validate.oneOf( interfaceParamsetDef, Constants::VALIDATION[:api_loader_instantiate][:one_of_file_or_url] )          
      
      # validateProperties( interfaceParamsetDef, @@interfaceLoaderDef_required, @@interfaceLoaderDef_allowed )
      # validateOne( interfaceParamsetDef, @@interfaceLoaderDef_oneof )
      # validateOne( interfaceParamsetDef, @@interfaceLoaderDef_oneof2 )
    rescue ControllerException => e
      msg = <<-EOS
      Error:

      #{e} 

      in

      #{interfaceParamsetDef.to_yaml}


      EOS
      @logger.error( "#{__method__} #{msg}" )                    
      raise ControllerException.new,  msg, e.backtrace
    end
    warn <<-EOS if interfaceParamsetDef['type']
    Interface loader configuration 

    #{interfaceParamsetDef.to_yaml}

    uses property 'type', which is depracted.



    Use property 'className' instead.

    Particularly 

       type: #{Sbuilder::Constants::LOADER_SWAGGER}

    should be replaced with

       className: Sbuilder::ParamSetLoaderSwagger

    EOS

    # configure facade which get passed to loader
    facade = factory.getApiFacade(self)
    # generate support for returning 'response' 
    facade.configureInfrastructureService( interfaceParamsetDef['infrastructureServices'] == true )
    # generate interface process (allowing environment to call to the interface)
    facade.configureInterfaceService( interfaceParamsetDef['interfaceServices'] == true ) if interfaceParamsetDef['interfaceServices']
    # facade creates definitions in 'namespace' (default nil = no group)
    facade.configureNamespace( interfaceParamsetDef['namespace'] ) 
    facade.setInterfaceCacheFilePath(getParamsetCacheFilePath(interfaceParamsetDef))

    # find correct loader based on type & configure it
    loader = factory.getLoaderPlugin( getParamsetType( interfaceParamsetDef ), interfaceParamsetDef['configuration'], interfaceParamsetDef['objectName'])
    loader.setFacade( facade )
    
    # load an put array
    loader.load( getFileUrlOrPath( interfaceParamsetDef ),  )
    # @paramSets = paramSets.concat( loaded ) if loaded && loaded.any?
  end
end

#loadInternalSnippets(snippetFacade) ⇒ Object

Add fixed platform snippets using ‘loadSnippet’ interface

Parameters:



203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
 
# File 'lib/sbuilder/controller.rb', line 203

def loadInternalSnippets( snippetFacade )

  root = File.join( File.dirname( __FILE__), "../../mustache/resources" )
  internalSnippets = {
    "className" => "Sbuilder::SnippetLoaderSimple",
    "snippets" => [
      {
        'metatype' => Sbuilder::Constants::META_MODEL_FRAMEWORK_SVC,
        'appName'  => 'schedule_throw',
        'url' =>  File.join( root, "schedule_throw.tla" )
      },
      {
        'metatype' => Sbuilder::Constants::META_MODEL_FRAMEWORK_SVC,
        'appName'  => 'schedule_process_mac',
        'url' =>  File.join( root, "schedule_process_macro.tla" )
      },
      {
        'metatype' => Sbuilder::Constants::META_MODEL_FRAMEWORK_SVC,
        'appName'  => 'NewStep',
        'url' => File.join( root, "schedule_operator_new_step.tla" )
      },
      {
        'metatype' => Sbuilder::Constants::META_MODEL_FRAMEWORK_SVC,
        'appName'  => 'schedule_process_proc',
        'url' => File.join( root, "schedule_process_procedure.tla" )
      }
    ]
  }

  loadSnippet( snippetFacade, internalSnippets )      

end

#loadInvariants(invariants) ⇒ Object

Iterate ‘invariants’ and add to model invariant descritptions. Isse a warning if invarients not defined

Parameters:

  • invariants (Hash:Array) —

    with properties ‘key’=>‘description’



284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
 
# File 'lib/sbuilder/controller.rb', line 284

def loadInvariants( invariants )

  if invariants.nil? then
    msg = <<-EOS
    No invariants section defined in #{getConfigFilePath}. 

    Suggestion add section 'invariants' defining invariants.
    For example:

    invariants:
    - MustNotHappen: Invariant 'MustNotHappen' verified in the model
  
    EOS
    warn msg
  else
    @logger.info "#{__method__}: invariants=#{invariants}"
    invariants = [invariants] if invariants.is_a?( Hash )
    invariants.each do |invariant|
      invariant.each do |k,v|
        model.addInvariant( { :name => k, :desc => v } ) 
      end
    end
  end # else - not nil
end

#loadResolvers(arrOfmappersTypePath) ⇒ Object

build controller: load (domain) resolvers

Parameters:

  • arrOfmappersTypePath (Hash:Array) —

    of :type,:url



313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
 
# File 'lib/sbuilder/controller.rb', line 313

def loadResolvers( arrOfmappersTypePath )
  !arrOfmappersTypePath.nil? && arrOfmappersTypePath.each do |mapperDef|

    # validate configuration
    
    mapperDef = defaultProps( mapperDef, @@resolverLoader_defaults )
    validateProperties( mapperDef, @@resolverLoader_required, @@resolverLoader_allowed )
    validateOne( mapperDef, @@resolverLoader_oneof )
    
    
    @logger.debug( "#{__method__} mapperDef=#{mapperDef} " )      
    
    # find correct loader based on type
    # loader  = factory.getResolverLoader( getResolverDefType( mapperDef ) )
    loader  = getResolverLoader( getResolverDefType( mapperDef ) )
    
    # load an put array (calls mapperCreated)
    loaded = loader.load( getFileUrlOrPath( mapperDef ), self )        
    # @mappers= mappers.concat(loaded) if loaded && loaded.any?
    @logger.info( "#{__method__} @mappers.length=#{@mappers.length}" )              
    @logger.debug( "mappers=#{mappers.map { |mapper| mapper.name }}")
  end
  @logger.info( "#{__method__} loaded #{mappers.size} mappers" )
end

#loadSnippet(snippetFacade, snippet) ⇒ Object

Load ‘snippet’ using object created for className

loader plugin

Parameters:



247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
 
# File 'lib/sbuilder/controller.rb', line 247

def loadSnippet( snippetFacade, snippet )

  @logger.info "#{__method__}, snippet=#{snippet}"
  
  Utils::Validate.validateProperties( snippet, Constants::VALIDATION[:snippet_loader_instantiate][:required], Constants::VALIDATION[:snippet_loader_instantiate][:allowed] )
  Utils::Validate.oneOf( snippet, Constants::VALIDATION[:snippet_loader_instantiate][:one_of] )
  # validateProperties( snippet, @@snippetLoaders_required, @@snippetLoaders_allowed )

  # create new snippet loader instance ('className', 'configuration') OR access existing 'objectName'
  loader = factory.getLoaderPlugin( snippet['className'], nil , snippet['objectName']  )      
  # configure facade
  loader.setSnippetFacade( snippetFacade )
  # configure new object (after facade set)
  if snippet['className'] && snippet['configuration']
    loader.configure( snippet['configuration'] )
  end

  # pass array of snippet definitions to plugin
  begin
    loader.registerSnippets( snippet['snippets']  )
  rescue SbuilderException => e
    msg = <<-EOS
    #{e}

    Error encountred, when loading snippet #{snippet.to_yaml}
    EOS
    @logger.error( "#{__method__}: #{msg}" )                    
    raise ControllerException.new,  msg, e.backtrace
  end

end

#loadSnippets(snippets) ⇒ Object

Iterate ‘snippets’ array to load snippets to sbuilder code repository.

Parameters:

  • snippets (Array) —

    array of snippet loader definitions



177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
 
# File 'lib/sbuilder/controller.rb', line 177

def loadSnippets( snippets )


  # access [Sbuilder::SnippetLoaderFacade]
  snippetFacade = factory.getSnippetFacade( self )
  snippetFacade.setMustache( factory.getSnippetFacadeMustache )

  # add implementation snippets
  loadInternalSnippets( snippetFacade )
  
  snippets && snippets.each do |snippet|
    loadSnippet( snippetFacade, snippet )
  end

  # once all snippets registered, facade manage singleton parser object
  @logger.info "#{__method__} create new ParserFacade object"
  parserFacade = factory.createParserFacade

  snippetFacade.acceptSnippets( parserFacade.getResolver(self) ) 
  
end

#mapperCreated(mapper) ⇒ Object

controllers gets informed that mapper is created



339
340
341
 
# File 'lib/sbuilder/controller.rb', line 339

def mapperCreated( mapper )
  @mappers << mapper
end

#metatypeSnippetRepository(snippetRepository, metatype) ⇒ String

Return path to directory for ‘metatype’ in snippetRepository (used by snippet loader), create the directory if it does not exists.

Parameters:

  • metatype (String) —

    in specification model

Returns:

  • (String) —

    path to an existing snippet direcotory



1535
1536
1537
1538
1539
 
# File 'lib/sbuilder/controller.rb', line 1535

def metatypeSnippetRepository( snippetRepository, metatype )
  path = File.join( snippetRepository, metatype )
  Dir.mkdir( path ) unless File.exists?( path )
  path
end

#output(level, msg, nl = true) ⇒ Object 



1572
1573
1574
1575
1576
1577
1578
1579
 
# File 'lib/sbuilder/controller.rb', line 1572

def output( level,  msg, nl=true )
  if nl
    puts msg if output_show( level )
  elsif output_show( level )
    print msg
    $stdout.flush
  end
end

#output_show(level) ⇒ Boolean

Returns true if output on level.

Returns:

  • (Boolean) —

    true if output on level



1582
1583
1584
 
# File 'lib/sbuilder/controller.rb', line 1582

def output_show( level )
  level <= @opts[:verbosity]
end

#prepareRender(setupName) ⇒ Sbuilder::Template

Create a reader for accessing templates file, configure the reader, and create template renderer using that reader.

Returns:



992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
 
# File 'lib/sbuilder/controller.rb', line 992

def prepareRender( setupName )
  
  # Known template readers:
  # - TemplateReader: simple reader, return first file matching
  # - TemplateContextReader: parsers template snippets, determine snippets reachable for
  #   setup steps, prune unreachable template snippets
  #
  reader = factory.getTemplateReader( self )
  # configure reader if it is ready to accept 'setupName'
  reader.setSetupName( setupName ) if reader.respond_to?( :setSetupName )
  # create pass reader to template generator
  mustache = factory.getTemplate( reader )

  return mustache
end

#prepareSetupDir(extensionDirectory) ⇒ String

Ensure that directory ‘extensionDirectory’ exists under ‘getGenerateDir’

Returns:

  • (String) —

    directoryPath where extension should be written



978
979
980
981
982
983
984
985
986
 
# File 'lib/sbuilder/controller.rb', line 978

def  prepareSetupDir( extensionDirectory )
  # Ensure that 'extensionDirectory' exists
  raise ControllerException.new "Directory #{getGenerateDir} does not exist"  unless File.exist?( getGenerateDir )
  # directory for setupName create automatically
  directoryPath = "#{getGenerateDir}/#{extensionDirectory}"
  Dir.mkdir( directoryPath ) unless File.exist?( directoryPath )
  return directoryPath  

end

#processSetup(setupName) {|setupName, setupConf, possibilities| ... } ⇒ Object

Yields:

  • (setupName, setupConf, possibilities) 


937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
 
# File 'lib/sbuilder/controller.rb', line 937

def processSetup( setupName, &blk )

  # init state
  start

  # load resolvers, interfaces, and invariants
  load

  # # create domain model i.e. resolve domains
  # resolve

  # access config && put to model
  setupConf = getSetup( setupName )
  defineSetup( setupConf )

  # add assumptions to model
  loadAssumptions( getSetupAssumptionList( setupConf ), setupName )

  # extensions
  loadExtensions( setupName )

  # DEPREACTED # initializeSymbolTable called after extension load
  # (but before generation) because 'interface-extension' sets
  # META_MODEL_SERVICE_IMPLEMENTATION
  # initializeSymbolTable

  # config model - before config rendering
  possibilities= getSetupPossibilitiesList( setupName )      
  setPossibilities( possibilities, setupName )

  # document or generate (possiblities)
  yield setupName, setupConf, possibilities if blk
  
end

#processSetups(chosenSetup = nil, &blk) ⇒ Object

Parameters:

  • chosenSetup (String) (defaults to: nil) —

    optional string for the setup to process



929
930
931
932
933
934
935
 
# File 'lib/sbuilder/controller.rb', line 929

def processSetups(chosenSetup=nil, &blk )
  setups = Marshal.load( Marshal.dump( getSetups ) || [] ).select { |s| chosenSetup.nil? || s['setupDirectory'] == chosenSetup }
  setups.each do |setup|
    setupName = setup['setupDirectory']
    processSetup( setupName, &blk )
  end
end

#registerMetatype(metatypeDef) ⇒ Object

Add metatype to symbol table

Parameters:

  • metatypeDef (Hash) —

    hash with metatype properties



560
561
562
563
 
# File 'lib/sbuilder/controller.rb', line 560

def registerMetatype( metatypeDef )
  symbolTable = getSymbolTable
  symbolTable.defineMetaType( metatypeDef )
end

#resolve ⇒ Object

Find domain for interface parameters, and for definitions (=types)



482
483
484
 
# File 'lib/sbuilder/controller.rb', line 482

def resolve
  resolveDomains
end

#resolveDomains ⇒ Object

Resolve domains (find domain name & domain object) for parameters sets in model. Only if resolve needed. Resolve also :response parameterSets (for interfaces).



863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
 
# File 'lib/sbuilder/controller.rb', line 863

def resolveDomains
  @logger.info( "#{__method__}: resolve started" )      
  # model.paramSets.each do |paramSet|
  model.paramSets.select{|ps| ps.resolveNeeded( self ) }.each do |paramSet|
    # @logger.info( "#{__method__} paramSet id=#{paramSet.getId}" )      
    resolver = findResolverForParameterSet( paramSet )
    if resolver.nil? then
      msg = "Could not locate resolver for paramSet #{paramSet.getId}"
      @logger.error( "#{__method__} #{msg}" )        
      raise msg
    end
    @logger.info( "#{__method__} resolved resolver.matcher #{resolver.matcher} for paramset id #{paramSet.getId}" )
    # delegate action
    begin
      resolver.resolveDomains( paramSet, model )
      
      # resolve also response
      resolver.resolveDomains( paramSet.response, model ) if  paramSet.respond_to?( :response )
      
     rescue ResolverException => e
      msg = "Error '#{e}' when mapping domains for parameter set '#{paramSet.getId}'"
      puts msg
      @logger.error( "#{__method__} #{msg}" )        
      raise
    end
  end
end

#resolveExtensionPartials ⇒ Object

Extract partial calls called in extension templates.



487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
 
# File 'lib/sbuilder/controller.rb', line 487

def resolveExtensionPartials
  @logger.info "#{__method__} start"
  
  # get Sbuilder::TemplateResolve used to access mustache
  # templates
  templateResolver = factory.getTemplateResolver( self )

  # iterate extension templates in generate definition used to
  # render 'tla/model.tla'
  
  getExtensionTemplates.each do |extensionTemplate|
    @logger.info( "#{__method__} extensionTemplate =#{extensionTemplate}" )
    resolved_partials = templateResolver.resolve_partials( extensionTemplate )
    # e.g. extend/extend_const.mustache --> 'const'
    extensionPoint = extensionTemplate2Name(extensionTemplate)
    # should use snippet-loader extension point
    deprecated=true
    addPartials( resolved_partials, extensionPoint, deprecated )        
    @logger.info( "#{__method__} extensionTemplate =#{extensionTemplate}--> resolved_partials=#{resolved_partials}" )
  end
  
  @logger.info "#{__method__} done"       
end

#setFactory(factory) ⇒ Object

Parameters:



146
147
148
149
150
 
# File 'lib/sbuilder/controller.rb', line 146

def setFactory( factory )
  @factory = factory
  # add loaders configured in 'sbuilder.yaml'
  factory.addLoaders( getConfiguredLoaders )
end

#setup(setupDirectory = nil) ⇒ Object

Process setup ‘setupDirectory’ or all setups (when ‘setupDirectory’ is nil)

Parameters:

  • setupDirectory (String) (defaults to: nil) —

    name of setup to process



729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
 
# File 'lib/sbuilder/controller.rb', line 729

def setup( setupDirectory=nil )

  @logger.info( "#{__method__} getSetups=#{getSetups.join( " ------------  " )}, #{getSetups.length}" )                    
  generated=false

  # deep down makes a new call to getSetups --> iteration fails
  setups = Marshal.load( Marshal.dump( getSetups ))
  setups.each_with_index do |setupDef,i|
    
    validateProperties( setupDef, @@validSetups_required, @@validSetups_allowed )
    @logger.info( "#{__method__} -->next" ) if setupDirectory && (setupDef['setupDirectory'] != setupDirectory)
    next if setupDirectory && setupDef['setupDirectory'] != setupDirectory
    validateProperties( setupDef['configuration'], @@validSetupConfiguration_required, @@validSetupConfiguration_allowed ) if setupDef['configuration']
      
    # process one setupDirectory
    @logger.info( "#{__method__} start to generate setupDirectory=#{setupDirectory} for #{setupDef}" )

    output( 1, "------------------------------------------------------------------" ) if isOptFilterSrc
    output( 1, "generate setup: #{setupDef['setupDirectory']}" )
    generateSetup( setupDef['setupDirectory'], setupDef['setupDirectory'] )
    @logger.info( "#{__method__} done to generate setupDirectory=#{setupDirectory} for #{setupDef}" )                      
    output( 2, "\n" ) 
    
    generated=true

  end
  
  @logger.info "#{__method__} done iterating setups"
  
  raise ControllerException.new <<-EOS if !generated && setupDirectory

  Setup #{setupDirectory} not found - Nothing generated

  Valid setups: #{getSetups.map {|setupDef| setupDef['setupDirectory']}.join(',')}

  EOS

end

#setupFilter(modelData, renderData) ⇒ Boolean

Decide whether ‘dataElement’ should be passed to template rendering.

Implementation: Default ‘true’, however when ‘options’ && ‘modelData’ == “interface” show only if included in ‘getSetupStepInterfaceOperations’

Parameters:

  • modelData (String) —

    type of data (see model#templateData)

  • renderData (Hash) —

    data element to filter, content depends on ‘modelData’

Returns:

  • (Boolean) —

    true when show the elmement



1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
 
# File 'lib/sbuilder/controller.rb', line 1215

def setupFilter( modelData, renderData )
case modelData
when "interfaces"
  return renderData unless isOptFilterSrc
  # show only interfaces_operations referenced in 'steps'
  interface_operations = getSetupStepInterfaceOperations
  renderData['interfaces'] = renderData['interfaces'].select{ |d| interface_operations.include?( d[:interface_operation] ) }
  @logger.info( "#{__method__}: filtered renderData['interfaces']=#{renderData['interfaces'].map{|i| i[:interface_operation]}}" )
  return renderData
else
  # default is to show all
  renderData
end
end

#snippetRepository ⇒ String

Return directory path for snippet directory, and ensure that the director exists

to store snippets

Returns:

  • (String) —

    repositoryPath to root direcnoty under, which



1520
1521
1522
1523
1524
1525
1526
 
# File 'lib/sbuilder/controller.rb', line 1520

def snippetRepository

  path = File.join( getOpt(:cache_dir), Sbuilder::Constants::SNIPPET_LOADER_DIR )
  Dir.mkdir( path ) unless File.exists?( path )
  path
  
end

#sortPartials ⇒ Object

topological sort on partials



512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
 
# File 'lib/sbuilder/controller.rb', line 512

def sortPartials

  # create object providing parser services
  @logger.info "#{__method__} create new ParserFacade object"
  parserFacade = factory.createParserFacade
  
  # init 
  parserResolver = parserFacade.getResolver( self ) do |stat,entry,e|
    # if error
    if ( !stat )
    end
  end

        
  partials.each do |partial_type, template_names|
    @logger.debug "#{__method__} sort template_names=#{template_names} for partial_type #{partial_type}, " if @logger.debug?
    partials[partial_type] = parserResolver.sortModules( template_names )
    @logger.info "#{__method__} sorted template_names=#{partials[partial_type]} for partial_type #{partial_type}, "        
  end

end

#start ⇒ Object

Reset @model, @mappers (=domain model resolvers)

Parameters:

  • possibilities (String:Array) —

    possibilities defined in setup



428
429
430
431
432
433
434
435
436
437
438
439
 
# File 'lib/sbuilder/controller.rb', line 428

def start
  # init state
  @mappers = []
  @model = factory.createModel()

  # no modifications for the setup
  @updatedSetups = {}

  # Clear caches
  @extensionTemplates = nil

end

#templateRenderDirectories ⇒ String:Array

Return search array of directories/gem names from, which to search templates to render.

render templates

Returns:

  • (String:Array) —

    direcotorie (or gem names) to search for



1546
1547
1548
1549
1550
1551
 
# File 'lib/sbuilder/controller.rb', line 1546

def templateRenderDirectories()
  options = @opts
  searchDirs = [ snippetRepository + "/" ] + options[:templates]  + (options[:default_templates] || [] )
  @logger.info "#{__method__}, searchDirs=#{searchDirs.join(', ')}"
  searchDirs
end

#updateSetup(setupName, setupData) ⇒ Object

Update ‘setupData’ on ‘setupName’ configuration (possible done in setup extension loaders).

Parameters:

  • setupName (String) —

    to update

  • setupData (Hash) —

    data to update on ‘setupName’



1432
1433
1434
1435
1436
1437
 
# File 'lib/sbuilder/controller.rb', line 1432

def updateSetup( setupName, setupData )
  @logger.info "#{__method__}: setupName=#{setupName} with data #{setupData}"
  @logger.debug "#{__method__}: data before update #{getSetup(setupName).to_yaml}" if @logger.debug?
  updatedSetups[setupName] = setupData
  @logger.debug "#{__method__}: data after update #{getSetup(setupName).to_yaml}" if @logger.debug?      
end