tla-sbuilder 0.2.2 → 0.3.4

data/lib/sbuilder/model.rb

@@ -1,3 +1,4 @@
+# coding: utf-8
 module Sbuilder
 
   class Model
@@ -12,14 +13,17 @@ module Sbuilder
     attr_reader   :possibilities              # [String:Array] possibilities in setup
     attr_reader   :invariants                 # [Hash:Array] properties 'name', 'desc'
     attr_reader   :setupDef                   # [Hash] properties 'setupDirectory', 'desc', 'extensions'
-    attr_reader   :assumptions                # [Hash:Array] properties 'name', 'desc'    
+    attr_reader   :assumptions                # [Hash:Array] properties 'name', 'desc'
+
+    # @əttr [domainDef:Array] applicationDomainValues to pass to 'dispatchExtendDomain'
+    attr_reader :applicationDomainValues
 
     # ------------------------------------------------------------------
     # mixer
-    PROGNAME = "Model"                        # progname for logger
+    PROGNAME = nil                            # progname for logger default class name
     include Sbuilder::Utils::MyLogger         # mix logger
 
-    @@validInterfaceExtensionProperties  = ["matcher", "implementation"]
+    # @@validInterfaceExtensionProperties  = ["matcher", "implementation"]
 
     # ------------------------------------------------------------------
     # constructore
@@ -42,7 +46,8 @@ module Sbuilder
       @invariants = []
       @assumptions = []      
       @interfaceExtensions = {}
-      
+      @symbolTable = nil
+      @applicationDomainValues = []
 
     end
     
@@ -91,6 +96,17 @@ module Sbuilder
                                                                                       
       return ret
     end
+
+
+    # ------------------------------------------------------------------
+    # synbol table stuff
+    
+
+    # @return [Sbuilder::SymbolTable] symbolTable for the model
+    def getSymbolTable
+      # init only once
+      @symbolTable = @symbolTable || factory.createSymbolTable
+    end
     
 
     # ------------------------------------------------------------------
@@ -108,6 +124,17 @@ module Sbuilder
       return createOrUpdateDomain( domainName, nil )
     end
 
+    ##
+    # Add application model domain value definition to an array.
+    # These are later (during setup phase) used to extend domains.
+    #
+    # 
+    # @param [Hash] domainDef to pass to dispatchExtendDomain
+    #
+    # @see dispatchExtendDomain
+    def addApplicationDomainValue( domainDef )
+      @applicationDomainValues << domainDef
+    end
 
     # called from a separte plase
     def extendDomain( domain )
@@ -115,7 +142,7 @@ module Sbuilder
       raise ModelException.new <<-EOS  unless domains[domain.name]
       Unknown domain.name=#{domain.name}
 
-      Trying to extend domain '#{domain.name}', which not among resolved domains.
+      Trying to extend domain '#{domain.name}', which is not known.
 
       Known domain names are: #{domains.keys.join(', ' )}
 
@@ -177,21 +204,24 @@ module Sbuilder
 
 
     # extend
+    # @param [Hash] interfaceExtensionDef
+    # @option [String] matcher
+    # @option [Sting] implementation
     def extendInterface( interfaceExtensionDef )
 
       # validate properties 'interfaceExtensionDef'
       begin
-        validateProperties( interfaceExtensionDef, @@validInterfaceExtensionProperties )
+        Utils::Validate.validateProperties( interfaceExtensionDef, Constants::VALIDATION[:interface_extension_def][:required], Constants::VALIDATION[:interface_extension_def][:allowed] )
+        # validateProperties( interfaceExtensionDef, @@validInterfaceExtensionProperties )
       rescue ModelException => me
         @logger.info( "#{__method__} model exception #{me}" )
         raise ExtensionException.new( me )
       end
-
       # locate interface being extended
       interfaceParamSet = getInterface( interfaceExtensionDef['matcher'] )
 
       # record extension in '@interfaceExtensions'
-      putImplementationExtension( interfaceParamSet, interfaceExtensionDef )
+      mergeImplementationExtension( interfaceParamSet, interfaceExtensionDef )
 
       # return the extended interface
       interfaceParamSet
@@ -220,16 +250,31 @@ module Sbuilder
       
     end
 
-    # record extension in '@interfaceExtensions'
-    def putImplementationExtension( interfaceParamSet, interfaceExtensionDef )
-      @interfaceExtensions[interfaceParamSet.getId] = interfaceExtensionDef
+    # record extension in '@interfaceExtensions' (merge with previos props)
+    # @param [Hash] interfaceExtensionDef
+    # @option interfaceExtensionDef [String] implementation
+    # @option interfaceExtensionDef [String] completion    
+    def mergeImplementationExtension( interfaceParamSet, interfaceExtensionDef )
+      @interfaceExtensions[interfaceParamSet.getId] = ( @interfaceExtensions[interfaceParamSet.getId] || {} ).merge interfaceExtensionDef
     end
 
-    # provide information on extension implementation during generation phase
+    # extension interface service implementation, accessed during generation phase
     def getImplementationExtension( interfaceParamSet )
-       interfaceExtensions[interfaceParamSet.getId] ? interfaceExtensions[interfaceParamSet.getId]['implementation'] : nil
+      doGetInterfaceExtension( interfaceParamSet, 'implementation' )
+    end
+
+    # extension to complete interface service  implementation, accessed during generation phase
+    def getCompletionExtension( interfaceParamSet )
+      doGetInterfaceExtension( interfaceParamSet, 'completion' )      
     end
 
+    ##
+    # @return 'key' property from from 'interfaceExtensions' for 'interfaceParamSet.getId', or false
+    private def doGetInterfaceExtension( interfaceParamSet, key )
+      interfaceExtensions[interfaceParamSet.getId] ? interfaceExtensions[interfaceParamSet.getId][key] : false
+    end
+    
+
     # array of known interface ids
     def interfaceIds
       interfaces.values.map { |interface| interface.getId }
@@ -273,27 +318,38 @@ module Sbuilder
     #
     # 
 
-    # return hash for mustache for 'templateName' in 'interfaces', 'domains', 'variables'
+    # @param [String] domainName in data model
+    #
+    # @return [Hash]  dataModelElement for mustache for 'templateName' in 'interfaces', 'domains', 'variables' etc
+    #
+    # @option dataModelElement [String] dump to output data array
+    #
+    # @option dataModelElement [String] symbols optional lambda
+    # function to map data array to symbol table definitions
+    #
+    # @option dataModelElement [String] 'domainName' data array for
+    # element in model for domainName
+    
     def templateData( domainName )
 
       case domainName
       when 'interfaces'
         # see domainName 'interfaces'        
         templateDataInterfaces( domainName, false )
-      when 'interface_types'
-        # see domainName 'interfaces', interface_types are not
-        # filtered i.e. generated model defines data types for all interfaces
-        templateDataInterfaces( 'interfaces', false )
+      # when 'interface_types'
+      #   # see domainName 'interfaces', interface_types are not
+      #   # filtered i.e. generated model defines data types for all interfaces
+      #   templateDataInterfaces( 'interfaces', false )
       when 'infrastructureServices'
         templateDataInterfaces( domainName, true )
       when 'possibility'        
         hash = {
-          "possibility"    => lambda { hash['possibility'].to_yaml },                    
+          "dump"           => lambda { hash['possibility'].to_yaml },                    
           "possibility"    => possibility, # possibility defined in setup, currently being generated
         }
       when 'possibilities'        
         hash = {
-          "possibilities"  => lambda { hash['possibilities'].to_yaml },                    
+          "dump"           => lambda { hash['possibilities'].to_yaml },                    
           "possibilities"  => possibilities,      # possibilities in setup, all in current setup
         }
       when 'variables'        
@@ -311,9 +367,10 @@ module Sbuilder
               :interface_operation => step.interfaceReference.getId,
               :interface_path => step.interfaceReference.path,
               # :interface_id => step.interfaceReference.getId,              
-              :_comma => (i< steps.length-1 ? "," : ""),                                         
+              '_comma' => (i< steps.length-1 ? "," : ""),                                         
               :bindRule => step.bindExact == false ? step.inputs : false,
-              :bindSets  => step.bindExact ?  step.inputs.map.with_index { |input,i| input[:_comma] = i<step.inputs.length-1 ? ',' : ''; input }  : false, 
+              # :bindSets  => step.bindExact ?  step.inputs.map.with_index { |input,i| input['_comma'] = i<step.inputs.length-1 ? ',' : ''; input }  : false,               
+              :bindSets  => step.bindExact ?  step.inputs : false, 
             }
           },
         }
@@ -330,30 +387,47 @@ module Sbuilder
           "dump"        => lambda { hash['assumptions'].to_yaml },          
           "assumptions" => assumptions,
         }
+        
       when 'definitions'
         hash = {
-          "dump"        => lambda { hash['definitions'].to_yaml },          
-          "definitions" => definitions.tsort.map.with_index { |parameterName,i|
+          "dump"        => lambda { hash['definitions'].to_yaml },
+          # "symbols" => ->( d ) { [
+          #                          Sbuilder::Constants::META_MODEL_DEFINITION,
+          #                          d[:definition_name],
+          #                          d[:definition_name]
+          #                        ] },
+          'definitions' => definitions.tsort.map.with_index { |parameterName,i|
             # tsort returns array of names, resolve paramSet
             p = getParamset( parameterName )
             {  :definition_name => p.getName,
                :isArray => p.isArray,
-               :_comma => (i< definitions.values.length-1 ? "," : ""),
+               :domainParameters => p.isFunction ? p.parameter_definitions( self, p.domainParameters ) : [],
+               :rangeParameters => p.isFunction ?  p.parameter_definitions( self, p.rangeParameters ) : [],                
+               :isFunction => p.isFunction,
+               '_comma' => (i< definitions.values.length-1 ? "," : ""),
                :parameter_definitions => p.parameter_definitions( self )
             }
           }
         }                                                                       # => TLA definitions
       when 'domains'
         hash = {
-          "dump"        => lambda { hash['domains'].to_yaml },          
+          "dump"        => lambda { hash['domains'].to_yaml },
           "domains"     => domains.values.map do |domain|
             {
               :domain_name => domain.domain_name,
-              :nil_value => setup_nil_values,
+              # Nil included: if global configuration does not prevent && domain uses nil
+              :nil_value => setup_nil_values && domain.includeNil,
+              :tlaBaseType =>  domain.tlaBaseType,                    
               :domain_values => domain.domain_values,
             }
           end,                                      # => TLA domain
         }
+      when 'metatypes'
+        hash = {
+          "dump"        => lambda { hash['metatypes'].to_yaml },
+          "metatypes"   => getSymbolTable.metatypes
+        }
+        
       else
         raise "Unknown template '#{domainName}'"
       end # case
@@ -363,37 +437,43 @@ module Sbuilder
 
     # Extract data model for interfaces 
     #
-    # @param infrastructureServices [Boolean] choose  'interfaces' or 'infrastructureServices'
-    # @return [Hash] for template rendering composed of interfaces, false if configs
+    # @param  [Boolean] choose false --> interterfaces with 'interfaceService', true => 'infrastructureService'
+    #
+    # @return [Hash] for template rendering composed of interfaces, 'false' if configs
     #
-    private def templateDataInterfaces( domainName, infrastructureServices )
+    private def templateDataInterfaces( domainName, choose )
       hash = {
-          "dump" => lambda { hash[domainName].to_yaml },
-          domainName => interfaces.values.select { |iface|
+        "dump" => lambda { hash[domainName].to_yaml },
+        
+        domainName => interfaces.values.select { |iface|
             
-            iface.infrastructureService == infrastructureServices
+          !choose && iface.interfaceService ||
+          choose && iface.infrastructureService
             
-          }.map { |iface |
-            {
-              :interface_name => iface.getName,          # e.g._pet_post_
-              :interface_operation => iface.getId,       # e.g /pet(post)
-              :implementation => getImplementationExtension( iface ),
-              :_comma => ',',
-              :parameter_definitions => iface.parameter_definitions( self ),
-              :response_definitions => iface.response && iface.response.parameters.any? ? iface.response.parameter_definitions( self ) : false,
-            }
-          }       # => TLA process & stubs
+        }.map { |iface |
+          {
+            :interface_name => iface.getName,          # e.g._pet_post_
+            :interface_operation => iface.getId,       # e.g /pet(post)
+            :implementation => getImplementationExtension( iface ),
+            :completion => getCompletionExtension( iface ),            
+            '_comma' => ',',
+            :parameter_definitions => iface.parameter_definitions( self ),
+            :response_definitions => iface.response && iface.response.parameters.any? ? iface.response.parameter_definitions( self ) : false,
+          }
+        }       # => TLA process & stubs
       }
 
       # return 'false' instead of an array if empty
       hash[domainName] = false unless hash[domainName].any?
-      # fix _comma for the last entry in array
+      # fix _comma = "" for the last entry in array
       fixLastComma( hash[domainName] )
       return hash
     end
 
+    # @return [Hash:Array] with _comma property set to '' for the
+    # last element in the array
     private def fixLastComma( arrOfHashes )
-      arrOfHashes.last[:_comma] = "" if arrOfHashes && arrOfHashes.any?
+      arrOfHashes.last['_comma'] = "" if arrOfHashes && arrOfHashes.any?
     end
       
 

data/lib/sbuilder/mustache/template.rb

@@ -1,11 +1,10 @@
-require 'mustache'                   # extendending implementation of
-
 module Sbuilder
 
-  class Template < Mustache
+  
+  class Template < TemplateRoot
 
     include Sbuilder::Utils::MyLogger   # mix logger
-    PROGNAME = "template"               # progname for logger
+    PROGNAME = nil
 
     
     # ------------------------------------------------------------------
@@ -13,16 +12,11 @@ module Sbuilder
 
     # instance
     attr_writer :partials            # f: partial-name --> template string
-    attr_reader :reader              # Sbuilder::TemplateReader implementing
-                                     # 'get_template', 'get_template_filepath'
-    
-    extend Forwardable               # for easy delegation
-    def_delegators :reader,:get_template, :get_template_filepath, :configSetup, :template_read
-    
     # ------------------------------------------------------------------
     # Constructor
     
     def initialize( reader, options={} )
+      super( reader, options )
       @logger = getLogger( PROGNAME, options )
       @logger.info( "#{__method__} created" )
       @logger.debug( "#{__method__}, options='#{options}" )
@@ -30,59 +24,130 @@ module Sbuilder
       # init partial cache
       @partials = {}
 
-      # inject reader
-      #@reader = Sbuilder::TemplateReader.new( options )
-      @reader = reader
+      # inidirection data init to empty hash
+      setData( {} )
+      
 
     end
 
     # ------------------------------------------------------------------
     # Services
     
+    # Return extension point for 'template_name' mustache template as
+    # string.
+    #
+    # Implemtation return a string including mustache partial calls
+    # '{{>partial}}' for entries in array read from controller
+    # using method 'getExtensionPointPartials'. 
+    #
+    # @param template_name [String] template for extension point
+    # 
+    private def extension_template( template_name )
+      extensionTemplates = controller.getExtensionPointPartials( template_name )
+      @logger.info "#{__method__} Create extension_template for #{template_name} with #{extensionTemplates.join(',')}"
+      str=<<-EOS
+      {{! Generated in #{__FILE__} in #{__method__}  }}
+
+      \\* Extension point template #{template_name}:
+
+      #{ 
+         extensionTemplates.map{ |p| '{{>' + p + '}}' }.join( "\n")
+       }
+      EOS
+      @logger.debug "#{__method__} template  #{template_name} is #{str}" if @logger.debug?
+      str
+    end
+    
+    
     def to_str( template_name, data )
       @logger.info( "#{__method__}: template_name=#{template_name}" )
       @logger.debug( "#{__method__}: template_name=#{template_name}" ) if @logger.debug?
       # @logger.debug( "#{__method__}: nodes=#{data.nodes}" )
       
-      # data = add_dynamic_load( data )
-      
-      @data = data
+      # parent class keeps tract of data, and get_template may need it
+      # for indirection
+      setData( data )
+
+      if is_extension_point( template_name ) then
+        #
+        # Use a dynamically created string to output extension points
+        #
+        template = extension_template( template_name )
+        @logger.debug "#{__method__} template: is extension  #{template_name} -> #{template}"  if @logger.debug?
+        
+      else
+
+        # reader in parent class returns template to resolve as a
+        # string.
+        #
+        # Normally reads template from file to which 'template_name'
+        # resolves.  It may be also an empty string (if reader has
+        # decided that 'template_name' should not be shown.
+        template = get_template( template_name )
+        @logger.debug "#{__method__} template: is not extension  #{template_name} -> #{template}" if @logger.debug?
+        # render( template, @data )
+      end
       
-      template = get_template( template_name )
       # render( template, @data )
-      
-      render( template, @data )
+      render_str( template, data )
     end
 
+    
+    # @param template [String] mustache template used to render
+    # @param data [Hash] data to render
     def render_str( template, data )
       render( template, data )
     end
 
-    # ------------------------------------------------------------------
-    # Integrate with mustache
+    # Method called from concrete sub-class before rendering start.
+
+    # @param data [Hash] data being rendered
+    def setData( data={} )
+      @data = data
+    end
+
+    # @attr [Hash] data stored in concrete class, enable indirection
+    # using lambda function
+    def data 
+      return @data
+    end
+    
+    
+
 
-    # method used by mustache framework - delegate to 'get_partial'
-    def partial(name)
+    # ------------------------------------------------------------------
+    # @!group Called from  'partial' -method 
+
+    # Intercept chain to read template file, and cache @partials.
+    #
+    # Delegates actual read operation to 'get_template' in parent
+    # class reader.
+    #
+    # @param name [String] name of partial template to include
+    def get_partial( name ) 
       @logger.debug( "#{__method__} name=#{name}" )
+      # return indirection for 'name[2..-1]) ' if name[0..1]  == '!!'
+      name = resolve_partial_name(name)      
+      return @partials[name] if @partials[name]
+      @logger.info( "#{__method__} read partial_file=#{name}" )
+      
+      @partials[name] = get_template( name )
+      return @partials[name]
 
-      # return resolve_partial_direct(name[2..-1])  if name[0..1]  == '!!'
-      get_partial( resolve_partial_name(name) )
     end
 
-    # #
-    # # @param path_template [String] mustache template string to intepret for path
-    # #
-    # # @return [String] content of file pointed by rendering 'path_template'
-    # def resolve_partial_direct( path_template )
-    #   # change mustache delimerters to allow rendering
-    #   # templ = "{{=%% %%=}}#{path_template}<%={{ }}=%>"
-    #   puts path_template
-    #   templ = path_template
-    #   path = render( templ, @data )
-    #   template_read( path )
-    # end
-
-    # lookup
+    # @!endgroup
+
+    # ------------------------------------------------------------------
+    # @!group private
+
+    # Return name of partial, which normally is simply 'name'
+    # parameer, but which can be found form '@data' using indirect
+    # address following starting exclamation mark.
+    #
+    # @return [String] 'name' or value from '@data' pointed by name
+    # minus prefixed exclamation
+    
     def resolve_partial_name( name )
       return name unless name[0..0]  == '!'
       # remove !, split, and use injected traves to access data
@@ -98,25 +163,9 @@ module Sbuilder
       @logger.info( "#{__method__} name=#{name} --> #{ret}" )
       ret
     end
-
-    # ------------------------------------------------------------------
-    # Cache partials once resoved
-
-    # cache @partials - for easier extension
-    def get_partial( name ) 
-      @logger.debug( "#{__method__} name=#{name}" )
-      return @partials[name] if @partials[name]
-      @logger.info( "#{__method__} read partial_file=#{name}" )
-      
-      @partials[name] = get_template( name )
-      return @partials[name]
-
-      # partial_file = get_template_filepath( name )
-      # @logger.info( "#{__method__} read partial_file=#{partial_file}" )
-      # @partials[name] = File.read( partial_file )
-      # @partials[name]
-    end
-
+    
+    
+    
 
   end # class