tla-sbuilder 0.2.2 → 0.3.4

data/lib/sbuilder/controller.rb

@@ -1,3 +1,4 @@
+# coding: utf-8
 require 'forwardable'
 
 module Sbuilder
@@ -5,18 +6,46 @@ module Sbuilder
   class Controller
 
 
-
     extend Forwardable                      # for easy delegation
 
-    attr_reader   :factory                    # factory pattern
-    attr_reader   :mappers                    # array of loader 'Resolver' objects
+    # @attr [Factory] factory
+    attr_reader   :factory
+
+    # @əttr [Resolver] mappers array of loader 'Resolver' objects
+    attr_reader   :mappers
 
-    # model parts
-    attr_reader   :model                      # which contain values loaded
-    def_delegators :model, :extendDomain, :extendInterface, :modelInterface, :modelDefinition,
-                   :domainEncountered, :templateData, :getInterface, :extendStep, :defineSetup
+    # @attr partials [Hash] map extension-point to array of partial templates
+    # @option partials [String] :key name of extension point
+    # @option partials [String] :value array of partials to include
+    attr_reader   :partials
+
+    # @attr [Hash] updatedSetups
+    #
+    # @option updatedSetups [String] <key> setupName being extended
+    #
+    # @option updatedSetups [Hash] <value> to merge to setup
+    # configuration
+    attr_reader :updatedSetups
+    
+    # @attr [Model] model
+    attr_reader   :model                      
     
-    def_delegators :factory, :createParameter, :createParamSet
+    def_delegators :model,
+                   :extendDomain,
+                   :extendInterface,
+                   :modelInterface,
+                   :modelDefinition,
+                   :domainEncountered,
+                   :addApplicationDomainValue,
+                   :templateData,
+                   :getInterface,
+                   :getSymbolTable,
+                   :extendStep
+    
+    def_delegators :factory,
+                   :createParameter,
+                   :createParamSet,
+                   :getResolverLoader
 
     
 
@@ -42,6 +71,9 @@ module Sbuilder
     }
     @@extensionLoaderDef_allowed = @@extensionLoaderDef_required + @@extensionLoaderDef_oneof + ['type']
 
+    @@snippetLoader_required = [  'metatype', 'appName', 'file' ]
+    @@snippetLoader_allowed = @@snippetLoader_required  + []    
+    
 
     @@resolverLoader_required = [ ]
     @@resolverLoader_oneof = ["url", "file",]
@@ -50,26 +82,38 @@ module Sbuilder
     }
     @@resolverLoader_allowed = @@resolverLoader_required + @@resolverLoader_oneof + ['type']    
     
-    @@interfaceLoaderDef_required = [ ]
-    @@interfaceLoaderDef_oneof = [  'url', "file", ]
-    @@interfaceLoaderDef_oneof2 = [  'type', "className", ]    
-    @@interfaceLoaderDef_allowed = @@interfaceLoaderDef_required + ["cache", "infrastructureServices", "namespace" ]  + @@interfaceLoaderDef_oneof  + @@interfaceLoaderDef_oneof2
-
-    @@validExtendLoader = %w( gem className configuration )
 
     @@validConfig = %w( generate )
-    @@allowConfig = @@validConfig + %w( extend extensions setups preferences resolvers interfaces invariants ) 
+    @@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" ]
+    @@validGenerateDef_allowed     =  @@validGenerateDef_required + [ "templateParameters", 'type', 'symbols' ]
+
+    # moved to Constants::VALIDATION
+    # @@requireExtendLoader = %w( className configuration )
+    # @@allowExtendLoader = %w( gem objects  )    + @@requireExtendLoader
+
+    # @@snippetLoaders_required = ['className', 'snippets' ]
+    # @@snippetLoaders_allowed = @@snippetLoaders_required  + []    
+
+    # @@interfaceLoaderDef_required = [ ]
+    # @@interfaceLoaderDef_oneof = [  'url', "file", ]
+    # @@interfaceLoaderDef_oneof2 = [  'type', "className", ]    
+    # @@interfaceLoaderDef_allowed = @@interfaceLoaderDef_required + ["cache", "infrastructureServices", "namespace" ]  + @@interfaceLoaderDef_oneof  + @@interfaceLoaderDef_oneof2
+    
+
+    
     # ------------------------------------------------------------------
     # mixer
-    PROGNAME = "Controller"             # progname for logger
-    include Sbuilder::Utils::MyLogger         # mix logger
-
+    PROGNAME = nil                        # progname for logger default class name
+    include Sbuilder::Utils::MyLogger     # mix logger
 
+    include Sbuilder::ControllerUtils
     # ------------------------------------------------------------------
     # constructore
     
@@ -86,9 +130,15 @@ module Sbuilder
                 :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],
+                :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
 
@@ -98,27 +148,132 @@ module Sbuilder
       # add loaders configured in 'sbuilder.yaml'
       factory.addLoaders( getConfiguredLoaders )
     end
-    
-    # @param possibilities [String:Array] possibilities defined in setup
-    def start
-      # init state
-      @mappers = []
-      @model = factory.createModel()
 
+    # @return [Hash] hash with keys for known extension-points, values []
+    private def initPartials
+      @logger.info "#{__method__}, starts"
+      return {
+        Sbuilder::Constants::EXTENSION_POINT_ASSUMPTIONS => [],
+        Sbuilder::Constants::EXTENSION_POINT_IMPLEMENTATION => [],
+        Sbuilder::Constants::EXTENSION_POINT_INVARIANT => [],
+        Sbuilder::Constants::EXTENSION_POINT_CONST => [],
+        Sbuilder::Constants::EXTENSION_POINT_MACRO => [],
+        Sbuilder::Constants::EXTENSION_POINT_OPERATIONS => [],
+        Sbuilder::Constants::EXTENSION_POINT_STATE => [],
+      }
     end
-
+    
     # Iterate 'assumptions' and add to model assumption descritptions.
     # Issue a warning if assumptions not defined
     # 
     # @param assumption [String:Array] name of assumption to activate
 
+
+    # Iterate 'snippets' array to load snippets to sbuilder code
+    # repository.
+    #
+    # @param [Array] snippets array of snippet loader definitions
+    #
+    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
+
+    # Add fixed platform snippets using 'loadSnippet' interface
+    #
+    # @param [Sbuilder::SnippetLoaderFacade] snippetFacade for snippet loader plugin
+    #
+    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
     
-    def loadAssumptions( assumptions )
+    
+    # Load 'snippet' using object created for className
+    #
+    # @param [Sbuilder::SnippetLoaderFacade] snippetFacade for snippet
+    # loader plugin
+    #
+    #
+    # @param [Hash] snippet to load
+    # @option snippetLoader [String] metatype in specification code domain for the snippetBody
+    # @option snippetLoader [String] appName name of the snippet in application domain
+    # @option snippetLoader [String] file containing snippetBody to load
+    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
 
-      @logger.info "#{__method__}: assumptions=#{assumptions}"
-      assumptions.each do |assumption|
-        model.addAssumption( { :name => assumption, :desc => "Assume #{assumption}" } ) 
-      end # else - not nil
     end
 
     # Iterate 'invariants' and add to model invariant descritptions.
@@ -157,7 +312,9 @@ module Sbuilder
     
     def loadResolvers( arrOfmappersTypePath )
       !arrOfmappersTypePath.nil? && arrOfmappersTypePath.each do |mapperDef|
-        # add defaults to 'mapperDef'
+
+        # validate configuration
+        
         mapperDef = defaultProps( mapperDef, @@resolverLoader_defaults )
         validateProperties( mapperDef, @@resolverLoader_required, @@resolverLoader_allowed )
         validateOne( mapperDef, @@resolverLoader_oneof )
@@ -166,9 +323,10 @@ module Sbuilder
         @logger.debug( "#{__method__} mapperDef=#{mapperDef} " )      
         
         # find correct loader based on type
-        loader  = factory.getResolverLoader( getResolverDefType( mapperDef ) )
+        # loader  = factory.getResolverLoader( getResolverDefType( mapperDef ) )
+        loader  = getResolverLoader( getResolverDefType( mapperDef ) )
         
-        # load an put array
+        # 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}" )              
@@ -182,43 +340,12 @@ module Sbuilder
       @mappers << mapper
     end
 
+    # @param name [String] resolver to find
+    # @return (first) resolver with 'name'
     def findResolver( name )
       @mappers.select{  |mapper| mapper.name == name }.first
     end
 
-    # ------------------------------------------------------------------
-    # load extensions
-
-    # Load exntesion for setup
-    #
-    # @param setupName [String] name of setup, currently = extensionDirectory
-    # def loadExtensions( arrayOfExtensionDefs )
-    def loadExtensions( setupName )
-
-      # access sbuilder.yaml configuration
-      arrayOfExtensionDefs = getSetupExtensions( setupName )
-
-      # iteratio
-      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'] )
-        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
-
     # ------------------------------------------------------------------
     # load interfaces
 
@@ -227,10 +354,14 @@ module Sbuilder
     def loadInterfaces( arrOfparamsetTypePath )
       !arrOfparamsetTypePath.nil? && arrOfparamsetTypePath.each do |interfaceParamsetDef|
 
-        begin 
-          validateProperties( interfaceParamsetDef, @@interfaceLoaderDef_required, @@interfaceLoaderDef_allowed )
-          validateOne( interfaceParamsetDef, @@interfaceLoaderDef_oneof )
-          validateOne( interfaceParamsetDef, @@interfaceLoaderDef_oneof2 )
+        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:
@@ -266,17 +397,19 @@ module Sbuilder
            className: Sbuilder::ParamSetLoaderSwagger
 
         EOS
-        
-        # find correct loader based on type & configure it
-        loader = factory.getParamSetLoader( getParamsetType( interfaceParamsetDef ))
 
-        # configure facade && pass it to loader
-        facade = factory.getFacade(self)
-        # facada loading instrcture services
+        # 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
@@ -284,52 +417,321 @@ module Sbuilder
         # @paramSets = paramSets.concat( loaded ) if loaded && loaded.any?
       end
     end
+    # @!endgroup    
 
-    # # accept parameters set to model
-    # def modelInterface( paramSet )
-    #   model.modelInterface( paramSet )
-    # end
-
-    # def paramSets
-    #   model.paramSets
-    # end
 
     # ------------------------------------------------------------------
-    # manages domains
+    # @!group processing steps
 
-    # # called when loading mappers for each domain encountered, return domain
-    # def domainEncountered( domainName )
-    #   model.domainEncountered( domainName )
-    # end
+    # Reset @model, @mappers (=domain model resolvers)
+    # @param possibilities [String:Array] possibilities defined in setup
+    def start
+      # init state
+      @mappers = []
+      @model = factory.createModel()
 
-    # # delegate to domains
-    # def  domains
-    #   model.domains
-    # end
+      # no modifications for the setup
+      @updatedSetups = {}
+
+      # Clear caches
+      @extensionTemplates = nil
+
+    end
 
+    # load resolvers, interfaces, and invariants for application model
+    # (before setups are loaded).
 
-    # load paremSets and mappers
+    # This means that symbol table cannot be initalized here (because
+    # it load implementation names, which are defines in setup
+    # extesion).
+    #
+    # @todo move implementation extension to model construct phase and
+    # initalize symbol table herre
     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
+
+    # Find domain for interface parameters, and for definitions (=types)
+    def resolve
+      resolveDomains
+    end
+
+    # Extract partial calls called in extension templates.
+    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
+
+    # topological sort on partials
+    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
+
+    # Create metamodel definitions in symbol table 
+    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
+
+    # @return [Hash:Array] baseMetatype definitions
+    # @option baseMetatype [Symbol] :name
+    # @option baseMetatype [Symbol] :desc    
+    def baseMetatypes
+      Sbuilder::Constants::META_MODEL
+    end
+
+    # Add metatype to symbol table
+    #
+    # @param [Hash] metatypeDef hash with metatype properties
+    def registerMetatype( metatypeDef )
+      symbolTable = getSymbolTable
+      symbolTable.defineMetaType( metatypeDef )
     end
+
     
+    # Add initial symbols to symbol table from generate definition
+    # producing module `tla/model.tla`
+    def initializeSymbolTable
+      @logger.info "#{__method__} start"
 
-    # def extend
-    #   loadExtensions( getExtensionConfigs  )
-    # end
+      # 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
+
+    # Notify model for the setup being processed
+    #
+    # @param setupConf [Hash] setupConf
+    # @option setupConf [String] :setupDirectory name of the setup
+    # @option setupConf [String] :desc description
+    private def defineSetup( setupConf )
+      model.defineSetup( setupConf )
+    end
+
+    # Notify model for setup possibilities 
+    private def setPossibilities( possibilities, setupName )
+      model.setPossibilities( possibilities )
+    end
+
+    # Load _setup_ assumptions to model
+    #
+    # @param assumptions [String:Array] name assumptions for a setup
+    # currently being processed
+    private def loadAssumptions( assumptions, setupName  )
+
+      @logger.info "#{__method__}: assumptions=#{assumptions}"
+      assumptions.each do |assumption|
+        model.addAssumption( { :name => assumption, :desc => "Assume #{assumption}" } ) 
+      end # else - not nil
+    end
+
+    # Load setup specific extensions (e.g. possibilities, extend
+    # domains, extend implementation)
+    #
+    # @param setupName [String] name of setup, currently = extensionDirectory
+    # def loadExtensions( arrayOfExtensionDefs )
+    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
+
+    ##
+    # extend sbuilder domains, and application domains (literal
+    # values) before setup extensions are loader
+    #
+    #
+    # @see baseExtensionDefine for definition
+    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
+
+    ## 
+    # define base/common domains for model
+    #
+    # @see baseExtensionSetup for extending domains
+    def  baseExtensionDefine
+      Constants::BASE_EXTENSIONS_DOMAIN.each do |domainDef|
+        model.domainEncountered( domainDef['domain'] )
+      end
+      
+    end
+
+    # @!endgroup    
 
     # ------------------------------------------------------------------
-    # iterate setups
     
+    # @!group Public services
+    
+    # Process setup 'setupDirectory' or all setups (when 'setupDirectory' is nil)
+    #
+    # @param setupDirectory [String] name of setup to process
     def setup( setupDirectory=nil )
 
       @logger.info( "#{__method__} getSetups=#{getSetups.join( " ------------  " )}, #{getSetups.length}" )                    
       generated=false
 
-      # deep down makes a new call to getSetups --> interation fails
+      # deep down makes a new call to getSetups --> iteration fails
       setups = Marshal.load( Marshal.dump( getSetups ))
       setups.each_with_index do |setupDef,i|
         
@@ -343,7 +745,7 @@ module Sbuilder
 
         output( 1, "------------------------------------------------------------------" ) if isOptFilterSrc
         output( 1, "generate setup: #{setupDef['setupDirectory']}" )
-        generate( setupDef['setupDirectory'], setupDef['setupDirectory'] )
+        generateSetup( setupDef['setupDirectory'], setupDef['setupDirectory'] )
         @logger.info( "#{__method__} done to generate setupDirectory=#{setupDirectory} for #{setupDef}" )                      
         output( 2, "\n" ) 
         
@@ -351,6 +753,8 @@ module Sbuilder
 
       end
       
+      @logger.info "#{__method__} done iterating setups"
+      
       raise ControllerException.new <<-EOS if !generated && setupDirectory
 
       Setup #{setupDirectory} not found - Nothing generated
@@ -359,9 +763,86 @@ module Sbuilder
 
       EOS
 
-      
+    end
+
+    # @!endgroup    
+
+    # ------------------------------------------------------------------
+    # @!group Used by resolveExtensionPartials
+
+    # Add 'resolved_partials' found in extensionTemplate to
+    # `extension_point( extensionTemplate )`
+    #
+    # @param extensionPoint [String] name of extension point
+    # (e.g. const, see src/extend/extend_*.tla)
+    #
+    # @return [Array] partials collected
+    #
+    # @option partials [String] key is extensionpoint corresponding
+    # 'extensionTemplate'
+    #
+    # @option partials [Array] value is array partials resolved in
+    # 'extensionTemplate' file
+    #
+    # @param [Boolean] depracted true when adding partials included using {{>partial}} syntax
+    #
+    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
+
+    # Extract extension point name from 'extensionTemplate'
+    # 
+    # @param extensionTemplate [String] e.g. extend/extend_const.mustache
+    #
+    # @return [String] extension point name extracted from extesion
+    # template name e.g. const
+    def extensionTemplate2Name( extensionTemplate )
+      name = extensionTemplate[/.*\/extend_([^.]+)/,1]
+      # @logger.debug "#{__method__}, name=#{name}:#{name.class}, extensionTemplate=#{extensionTemplate}:#{extensionTemplate.class}"
+      return name
+    end
+
+
+    # @return [Boolean] true if 
+    def is_extension_point( template_name )
+      return template_name.match( /extend\/.*\.mustache/ )
     end
     
+    
+
+    # Retrun list of template partials in extension points for
+    # +template_name+.
+    #
+    # @param  [String] template_name to map extension point key
+    #
+    # @param [Boolean] depracted true when accessing partials included
+    # using {{>partial}} syntax, in this case return all depracted partials
+    #
+    # @return [String] partials for extension point
+    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
+
+    # @!endgroup
 
     # ------------------------------------------------------------------
     # resolve
@@ -374,9 +855,15 @@ module Sbuilder
       return nil
     end
 
+    ##
+    # Resolve domains (find domain name & domain object) for
+    # parameters sets in model. Only if resolve needed. Resolve also
+    # :response parameterSets (for interfaces).
+    #
     def resolveDomains
-      @logger.info( "#{__method__} resolve started" )      
-      model.paramSets.each do |paramSet|
+      @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
@@ -399,25 +886,20 @@ module Sbuilder
           raise
         end
       end
-      
     end
 
-    def resolve
-      resolveDomains
-    end
 
-    # ------------------------------------------------------------------
-    # start, load, resolve, extend && output
+    # start, load, resolve, extend && render
     #
     # @param setupName [String] name of setup, currently = extensionDirectory
     # @param extensionDirectory [String]  directory where setup generated
     
-    def generate( setupName="default", extensionDirectory="default" )
+    def generateSetup( setupName="default", extensionDirectory="default" )
       @logger.info( "#{__method__} setupName=#{setupName}, extensionDirectory=#{extensionDirectory}" )
 
       processSetup( setupName )  do |name, setupConf, possibilities|
       
-        # config && get renderes
+        # config && get renderer
         mustache = prepareRender( setupName )
 
         # path to directory where setup output is done
@@ -457,27 +939,33 @@ module Sbuilder
       # init state
       start
 
-      # load configs
+      # load resolvers, interfaces, and invariants
       load
 
-      # resolve domain
-      resolve
+      # # 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 ) )
+      loadAssumptions( getSetupAssumptionList( setupConf ), setupName )
 
       # extensions
-      loadExtensions( setupName )      
+      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 )      
-      model.setPossibilities( possibilities )
+      setPossibilities( possibilities, setupName )
 
-      yield setupName, setupConf, possibilities
+      # document or generate (possiblities)
+      yield setupName, setupConf, possibilities if blk
       
     end
       
@@ -497,14 +985,21 @@ module Sbuilder
 
     end
 
+    # Create a reader for accessing templates file, configure the
+    # reader, and create template renderer using that reader.
+    #
     # @return  [Sbuilder::Template] mustache template generator
     def prepareRender( setupName )
       
-      # access template generator from factory
+      # 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 )
-      # pass reader to template generator
+      # create pass reader to template generator
       mustache = factory.getTemplate( reader )
 
       return mustache
@@ -519,7 +1014,7 @@ module Sbuilder
     #
     # @param generateCategory [Nil|String] choose templates in
     # 'generateCategory', Nil = no category defined. Intended
-    # usage for to generate possibitilies
+    # usage for to generate possibitilies.
     #
     # @param mustache [Sbuilder::Template] generator to render
     #
@@ -608,10 +1103,13 @@ module Sbuilder
       # 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'] ]
+      # # 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 paramters to template
+      # Support template paramaters
       templateParameters = generateDef['templateParameters'].nil? ? {} : generateDef['templateParameters']
       
       # optional parameters added in generate -section
@@ -640,14 +1138,55 @@ module Sbuilder
           :cat => lambda do |path_template|
             path = mustache.render_str( path_template, renderData )
             File.readlines( path.strip ).join('')
-          end
+          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!( getPreferencesData(setupName ))
+        renderData.merge!( getSetupPREFERENCES(setupName) )
 
         # finally render i.e. create string to output
-        str = mustache.to_str( template, renderData )
+        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}" )
@@ -700,9 +1239,10 @@ module Sbuilder
       return ret
     end
 
-    # Return names defined in mode (definitions)
+    # Return names (e.g. definitions, domains) defined in the
+    # specification model.
     #
-    # @return [String:Array] of names in define in model
+    # @return [String:Array] of names in defined in model
     def getModelNames
       ret = []
       
@@ -712,13 +1252,14 @@ module Sbuilder
       # domain --> 'd_:domain_name'
       ret += templateData( "domains" )['domains'].map { |d| "d_#{d[:domain_name]}"}      
       
-      @logger.debug( "#{__method__} ret=#{ret.join(',')}" )
+      @logger.debug( "#{__method__}: ret=#{ret.join(',')}" )
       ret
     end
 
-    # Return entry_points such that
-    # interfaces[steps.interface_operation ==
-    # intertafaces.interface_operation].implementation
+    # Return 'implementation' and 'complation' for interfaces,
+    # which are referenced on steps.
+    #
+    # Return also 
     #
     # @return [String:Array] names of interface[:implementation]
     #
@@ -732,7 +1273,10 @@ module Sbuilder
       @logger.debug( "#{__method__}:  setup_operations= #{setup_operations}" )
       entry_points = interfaces.
                       select {|i| setup_operations[i[:interface_operation]] }.
-                      map { |i|  i[:implementation] }
+                      map { |i|  [ i[:implementation], i[:completion]] }.
+                      flatten.
+                      select {|e| e }
+                            
       @logger.info( "#{__method__}:  entry_points= #{entry_points}" )      
       entry_points
       
@@ -766,8 +1310,63 @@ module Sbuilder
       model.assumptions.map{|a| a[:name] }
     end
 
-    # ------------------------------------------------------------------
-    # configuration
+    # Add functions used in mustache rendering sections to 'renderData'
+    #
+    # @param [Hash] renderData to decorate
+    #
+    # @param [Mustache] mustache template tool to reander section text
+    #
+    # @return [Hash] renderData decorated with functions uses in
+    # mustache rendering.
+    
+    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
+
+
+
+    # @!group Access sbuilder.yaml configuration
+
 
 
     # cache '@controller_config' read 'getConfigFilePath' and 'getInternalConfigFilePath', merge 'generate'
@@ -799,13 +1398,43 @@ module Sbuilder
       getConfig()['setups']
     end
 
+
+    ##
+    # For 'setupName' return configuration, which may be overridden
+    # from setup extension loaders. (@see updateSetup)
+    # 
     # @param setupName [String] name of setup to get
+    #
     # @return [Hash] hash of set in sbuilder configuration
     def getSetup( setupName )
+      (initialGetSetup( setupName ) || {} ).merge( updatedSetups[setupName] || {} )
+    end
+    
+
+    ##
+    # Return data for setup as configured in main-configuration file
+    #
+    # @param setupName [String] name of setup to get
+    # @return [Hash] hash of set in sbuilder configuration
+    def initialGetSetup( setupName )
       setup = getSetups.select { |setup| setup['setupDirectory'] == setupName }.first
       @logger.debug( "#{__method__} setupName=#{setupName}, setup=#{setup} " )      
       setup
     end
+    
+    ##
+    # Update 'setupData' on 'setupName' configuration (possible done
+    # in setup extension loaders).
+    #
+    # @param [String] setupName to update
+    # 
+    # @param [Hash] setupData data to update on 'setupName'
+    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
 
     # @return [Hash:Array] of 'type', 'url'|'file' properties
     def getSetupExtensions( setupName )
@@ -827,18 +1456,36 @@ module Sbuilder
     
     
 
-    def getPreferencesData( setupName )
+    # @return [Hash] renderData with PREFERENCES property
+    private def getSetupPREFERENCES( setupName )
+      getPreferencesDataHash( getMergedSetupPreferences( setupName ) )
+    end
+
+    # Put 'prefs' into a hash in 'PREFERENCES' property
+    private def getPreferencesDataHash( prefs )
       renderData = {}
-      renderData['PREFERENCES'] = getPreferencesWithDefaults( setupName )
+      renderData['PREFERENCES'] = prefs
       return renderData
     end
+    
 
-    # Get prefecnces with default setttings
-    # @return preferences [Hash]  with values for all known preferences
-    def getPreferencesWithDefaults( setupName )
-      DEFAULT_PREFERENCES.merge( getPreferences ).merge( getSetupPrefences( setupName ))
+    # @return [Hash] render data with 'PREFERENCES' -property with
+    # default preferences, and common preference from sbuilder.yaml
+    def getCommonPreferencesData
+      getPreferencesDataHash( getCommonPreferences() )
     end
     
+
+    # Get preferences for default+common+setup
+    private def getMergedSetupPreferences( setupName )
+      getCommonPreferences.merge( getSetupPrefences( setupName ))
+    end
+
+    # Get preferences for default+common
+    def getCommonPreferences
+      DEFAULT_PREFERENCES.merge( getPreferences )
+    end
+      
     # Access preferences in main configuration file 'sbuilder.yaml'
     #
     # @return preferences [Hash] possible empty (but definitely
@@ -859,6 +1506,86 @@ module Sbuilder
       getOpt( :templates ).first
     end
 
+    # Return cache directory location from opitions
+    #
+    # @return [String] path to cache -directory
+    def getCacheDir
+      getOpt(:cache_dir)
+    end
+
+    # Return directory path for snippet directory, and ensure that the director exists
+    #
+    # @return [String] repositoryPath to root direcnoty under, which
+    # to store snippets
+    def snippetRepository
+
+      path = File.join( getOpt(:cache_dir), Sbuilder::Constants::SNIPPET_LOADER_DIR )
+      Dir.mkdir( path ) unless File.exists?( path )
+      path
+      
+    end
+
+    # Return path to directory for 'metatype' in snippetRepository
+    # (used by snippet loader), create the directory if it does not exists.
+    #
+    # @param [String] metatype in specification model
+    #
+    # @return [String] path to an existing snippet direcotory
+
+    def metatypeSnippetRepository( snippetRepository, metatype )
+      path = File.join( snippetRepository, metatype )
+      Dir.mkdir( path ) unless File.exists?( path )
+      path
+    end
+
+    # Return search array of directories/gem names from, which to
+    # search templates to render. 
+    #
+    # @return [String:Array] direcotorie (or gem names) to search for
+    # render templates
+    def templateRenderDirectories()
+      options = @opts
+      searchDirs = [ snippetRepository + "/" ] + options[:templates]  + (options[:default_templates] || [] )
+      @logger.info "#{__method__}, searchDirs=#{searchDirs.join(', ')}"
+      searchDirs
+    end
+
+    
+    
+
+    # @!endgroup        
+
+    # ------------------------------------------------------------------
+    # @!group Access symbol table
+
+    def getMetaTypeDefinition( metatype )
+      getSymbolTable.getMetaTypeDefinition( metatype )
+    end
+
+    # 
+    # @!endgroup    
+
+    # ------------------------------------------------------------------
+    # @!group output
+
+    
+    def output( level,  msg, nl=true )
+      if nl
+        puts msg if output_show( level )
+      elsif output_show( level )
+        print msg
+        $stdout.flush
+      end
+    end
+
+    # @return [Boolean] true if output on level
+    def output_show( level )
+      level <= @opts[:verbosity]
+    end
+
+    # @!endgroup
+    
+
     private
 
     # path to configuration file 
@@ -876,12 +1603,17 @@ module Sbuilder
     end
     
     def getExtensionConfigs    
-      getConfig()['extensions']
+      ret = getConfig()['extensions']
+      ret
     end
 
     # @return [Hash] of extension properties
     def getExtensions
-      getConfig()['extend'] || {}
+      ret = getConfig()['extend'] || {}
+      @logger.debug "#{__method__}: extensions-to-return=#{ret}"
+
+      validateProperties( ret, @@extend_required, @@extend_allowed )
+      ret 
     end
 
     # Api loaders configured in sbuilder.yaml['extend']['loaders']
@@ -889,8 +1621,10 @@ module Sbuilder
     # @return [Hash:Array] with :name,:className,:configuration properties
     def getConfiguredLoaders
       loaders = getExtensions()['loaders'] || []
+      @logger.debug "#{__method__}: loaders=#{loaders}"
       loaders.each do |loader|
-        validateProperties( loader, @@validExtendLoader )
+        Utils::Validate.validateProperties( loader, Constants::VALIDATION[:extend_loader][:required], Constants::VALIDATION[:extend_loader][:allowed] )        
+        # validateProperties( loader, @@requireExtendLoader, @@allowExtendLoader )
       end
       loaders      
     end
@@ -905,12 +1639,22 @@ module Sbuilder
       invariants = [invariants] if invariants.is_a?( Hash )
       return invariants || []
     end
-    
+
+    # @return [Hash] snippetConfig from sbuilder.yaml['snippets']
+    def getSnippetConfig
+      getConfig()['snippets'] || {}
+    end
+
 
     # @param generateCategory [Nil|String] choose templates in
-    # 'generateCategory', @return [Hash:Array] of {'output', 'inputs'}
-    # defining a file to render using templates in 'inputs'
-    def getGenerateConfig( generateCategory )
+    # 'generateCategory', nil for all templates
+    #
+    # @param output [Nil|String] or choose template where 'output' property mathces
+    #
+    #
+    # @return [Hash:Array] of {'output', 'inputs'} defining a file to
+    # render using templates in 'inputs'
+    def getGenerateConfig( generateCategory, output=nil )
       ret = getConfig()['generate']
       if ret.nil? then
         warn <<-EOS
@@ -923,9 +1667,47 @@ module Sbuilder
       end
       
       #  Screen category
-      ret.select { |c| c['category'] == generateCategory }
+      ret.select { |c| (c['category'] == generateCategory  && output.nil?) || (c['output'] == output && generateCategory.nil? )  }
+    end
+
+    # @return [Hash] generateConfig defining model.tla module
+    # @option generateConfig [String] inputs array of input mustache templates
+    def getModelTemplate
+      modeltemplate = getGenerateConfig( nil, Sbuilder::Constants::MODEL_TEMPLATE_OUTPUT ).first
+    end
+
+
+    # Extract extension templates from generate configuration, cache
+    # templates in @extensionTemplates
+    #
+    # 
+    # @return [String:Array] extension template  names ie. names with matching  'extend/*.mustache'
+    def getExtensionTemplates
+      return @extensionTemplates if @extensionTemplates
+
+      # access generate configuration defining 'model.tla'
+      # modeltemplate = getGenerateConfig( nil, Sbuilder::Constants::MODEL_TEMPLATE_OUTPUT ).first
+      modeltemplate = getModelTemplate
+      
+      @extensionTemplates = modeltemplate && modeltemplate ['inputs' ] && modeltemplate['inputs'].
+        select { |i| is_extension_point( i['template'] ) }.
+        map {|i| i['template']} || []
+
+      @logger.info "#{__method__} extensionTemplates=#{@extensionTemplates}" 
+      return @extensionTemplates
+    end
+    
+    # Return name of template to use in generation
+    #
+    # @param generateDef [Hash] generate definition
+    # @option generateDef [String] 'template' name of template to generate
+    
+    private def getGenerateTemplate( generateDef )
+      # default uses template name
+      return generateDef['template'] 
     end
 
+
     # return uri whero load from
     def getFileUrlOrPath( paramSetDef )
       @logger.info( "#{__method__} paramSetDef=#{paramSetDef}" )
@@ -941,8 +1723,8 @@ module Sbuilder
 
     # @return [String] path to cacheFilePath, if no 'cache' -property
     def getParamsetCacheFilePath( paramSetDef )
-      return "#{getOpt(:cache_dir)}/#{paramSetDef['cache']}" if paramSetDef['cache'] && getOpt(:cache_dir)
-      return paramSetDef['cache']  if paramSetDef['cache']
+      return "#{getCacheDir}/#{paramSetDef['cache']}" if paramSetDef['cache'] #  && getOpt(:cache_dir)
+      # return paramSetDef['cache']  if paramSetDef['cache']
       return nil
     end
 
@@ -980,22 +1762,13 @@ module Sbuilder
       getOpt( :filter_src )
     end
 
-    # ------------------------------------------------------------------
-    # output
+    # @!endgroup    
+    # Configuration
     
-    def output( level,  msg, nl=true )
-      if nl
-        puts msg if output_show( level )
-      elsif output_show( level )
-        print msg
-        $stdout.flush
-      end
-    end
+    # Configuration
 
-    # @return [Boolean] true if output on level
-    def output_show( level )
-      level <= @opts[:verbosity]
-    end
+    # @!group helpers
+    
 
     # validate 'defintionHash' all 'required'/only 'allowed' props set
     private def validateProperties( defintionHash, required, allowed=nil )
@@ -1021,7 +1794,8 @@ module Sbuilder
       end
     end
     
-    
+
+    # @!endgroup        
     
   end # class