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

Class Method Details

.baseMetatypes ⇒ Hash:Array

Returns baseMetatype definitions.

Parameters:

  • baseMetatype (Hash) —

    a customizable set of options

Returns:

  • (Hash:Array) —

    baseMetatype definitions



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

def self.baseMetatypes
  Sbuilder::Constants::META_MODEL
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



796
797
798
799
800
801
802
803
804
805
806
807
 
# File 'lib/sbuilder/controller.rb', line 796

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:



720
721
722
723
724
725
 
# File 'lib/sbuilder/controller.rb', line 720

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:



697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
 
# File 'lib/sbuilder/controller.rb', line 697

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 ⇒ Object

See Also:

  • Sbuilder::Controller.{{.baseMetatypes}


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

def baseMetatypes
  self.class.baseMetatypes
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



1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
 
# File 'lib/sbuilder/controller.rb', line 1462

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



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

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



856
857
858
859
860
861
862
863
 
# File 'lib/sbuilder/controller.rb', line 856

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



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
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
 
# File 'lib/sbuilder/controller.rb', line 1037

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



904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
 
# File 'lib/sbuilder/controller.rb', line 904

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



1110
1111
1112
1113
1114
1115
1116
1117
 
# File 'lib/sbuilder/controller.rb', line 1110

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

  str = generateTemplateString( setupName, outputPath, generateDef, mustache )
  
  # output to file
  fileHandle.puts str
  
end

#generateTemplateString(setupName, outputPath, generateDef, mustache) ⇒ Object

Create string to output in #generateTemplate.

Parameters:



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
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
 
# File 'lib/sbuilder/controller.rb', line 1129

def generateTemplateString( setupName, outputPath, 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 )

  # Support template paramaters
  templateParameters = generateDef['templateParameters'].nil? ? {} : generateDef['templateParameters']
  
  # optional parameters added in generate -section
  renderData['PARAMETERS'] = templateParameters
  
  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
      return key if ( keys.length == 1 ) # just a name
      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

  # snippetEntry['PARAM_SET_FIELD_DOMAIN_INIT'] = lambda do |accesKey|
  #   raise "herer #{accessKey}"
  # 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

  # Log (a little bit too early :(
  @logger.info( "#{__method__} templateName=#{template}" )
  output( 3, "    ---> #{generateDef['desc']} (#{template})" )
  
  # return rendersed string
  str

end

#getCacheDir ⇒ String

Return cache directory location from opitions

Returns:

  • (String) —

    path to cache -directory



1669
1670
1671
 
# File 'lib/sbuilder/controller.rb', line 1669

def getCacheDir
  getOpt(:cache_dir)
end

#getCodeRepository ⇒ String

Currently uses first element in template as code repostirory

Returns:

  • (String) —

    path to code repository



1662
1663
1664
 
# File 'lib/sbuilder/controller.rb', line 1662

def getCodeRepository
  getOpt( :templates ).first
end

#getCommonPreferences ⇒ Object

Get preferences for default+common



1642
1643
1644
 
# File 'lib/sbuilder/controller.rb', line 1642

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



1631
1632
1633
 
# File 'lib/sbuilder/controller.rb', line 1631

def getCommonPreferencesData
  getPreferencesDataHash( getCommonPreferences() )
end

#getConfig ⇒ Object

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



1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
 
# File 'lib/sbuilder/controller.rb', line 1513

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 )
  @controller_config = getConfigSbuilder()
  # 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 )
  begin
    internal_config = YAML.load( yaml_lines )
  rescue Exception => e
    msg = <<-EOS
    #{e}
    Error encountred, when parsing yaml #{yaml_lines}
    EOS
    @logger.error( "#{__method__}: #{msg}" )                    
    raise ControllerException.new,  msg, e.backtrace
  end
  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

#getConfigSbuilder ⇒ Hash

Returns configuration parsed getConfigFilePath.

Returns:

  • (Hash) —

    configuration parsed getConfigFilePath



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

def getConfigSbuilder
  @logger.info( "#{__method__} loading config from #{getConfigFilePath}" )
  yaml_lines = Sbuilder::Utils::NetIo.read_lines( getConfigFilePath )
  return YAML.load( yaml_lines )
end

#getEntryPoints ⇒ String:Array

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

Return also

Returns:



1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
 
# File 'lib/sbuilder/controller.rb', line 1406

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



838
839
840
841
842
843
844
845
846
847
848
849
850
 
# File 'lib/sbuilder/controller.rb', line 838

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 



1718
1719
1720
 
# File 'lib/sbuilder/controller.rb', line 1718

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

#getModelInvariants ⇒ String:Array

Return model invariant defined in sbuilder

Returns:

  • (String:Array) —

    of invariant names



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

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



1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
 
# File 'lib/sbuilder/controller.rb', line 1386

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)



1650
1651
1652
 
# File 'lib/sbuilder/controller.rb', line 1650

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



1566
1567
1568
 
# File 'lib/sbuilder/controller.rb', line 1566

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

#getSetupAssumes ⇒ String:Array

‘setups.supet.assumptions’ property

Returns:

  • (String:Array) —

    names of setup assumes from



1449
1450
1451
 
# File 'lib/sbuilder/controller.rb', line 1449

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



1610
1611
1612
 
# File 'lib/sbuilder/controller.rb', line 1610

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



1597
1598
1599
1600
 
# File 'lib/sbuilder/controller.rb', line 1597

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



1428
1429
1430
1431
1432
 
# File 'lib/sbuilder/controller.rb', line 1428

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



1603
1604
1605
1606
 
# File 'lib/sbuilder/controller.rb', line 1603

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:



1656
1657
1658
 
# File 'lib/sbuilder/controller.rb', line 1656

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

#getSetups ⇒ Object 



1554
1555
1556
 
# File 'lib/sbuilder/controller.rb', line 1554

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



1374
1375
1376
1377
1378
1379
1380
 
# File 'lib/sbuilder/controller.rb', line 1374

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



1576
1577
1578
1579
1580
 
# File 'lib/sbuilder/controller.rb', line 1576

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`



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
623
624
625
626
627
628
629
 
# File 'lib/sbuilder/controller.rb', line 574

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, symbol table not yet built
    symbol_lookup=false
    modelData = templateData( input['modelData'], symbol_lookup )
    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



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

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



823
824
825
 
# File 'lib/sbuilder/controller.rb', line 823

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
480
 
# File 'lib/sbuilder/controller.rb', line 450

def load
  @logger.info( "#{__method__} load started" )

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

  loadResolvers( getResolversConfig )
  loadInterfaces( getInterfaceConfig   )
  loadInvariants( getInvariantConfig )

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

  # 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

  # moved to processSetup
  # # 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



662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
 
# File 'lib/sbuilder/controller.rb', line 662

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



1692
1693
1694
1695
1696
 
# File 'lib/sbuilder/controller.rb', line 1692

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

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



1729
1730
1731
1732
1733
1734
1735
1736
 
# File 'lib/sbuilder/controller.rb', line 1729

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



1739
1740
1741
 
# File 'lib/sbuilder/controller.rb', line 1739

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:



1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
 
# File 'lib/sbuilder/controller.rb', line 1006

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



992
993
994
995
996
997
998
999
1000
 
# File 'lib/sbuilder/controller.rb', line 992

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) 


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
971
972
973
974
975
976
977
978
979
980
981
982
983
984
 
# File 'lib/sbuilder/controller.rb', line 944

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 )

  # snippet load extension point
  loadSnippets( getSnippetConfig )

  # topological sort 
  sortPartials


  # 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



936
937
938
939
940
941
942
 
# File 'lib/sbuilder/controller.rb', line 936

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



566
567
568
569
 
# File 'lib/sbuilder/controller.rb', line 566

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

#resolve ⇒ Object

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



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

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).



870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
 
# File 'lib/sbuilder/controller.rb', line 870

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.



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

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



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
767
768
769
770
771
772
773
 
# File 'lib/sbuilder/controller.rb', line 736

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



1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
 
# File 'lib/sbuilder/controller.rb', line 1355

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



1677
1678
1679
1680
1681
1682
1683
 
# File 'lib/sbuilder/controller.rb', line 1677

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



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

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



1703
1704
1705
1706
1707
1708
 
# File 'lib/sbuilder/controller.rb', line 1703

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’



1589
1590
1591
1592
1593
1594
 
# File 'lib/sbuilder/controller.rb', line 1589

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