tla-sbuilder 0.2.2 → 0.3.4

data/lib/sbuilder/mustache/template_resolve.rb

@@ -0,0 +1,103 @@
+module Sbuilder
+
+
+  # Find names of templates included from mustache extension point
+  # template file.
+  #
+  # @since 0.3.1
+  #
+  class TemplateResolve < TemplateRoot
+
+    include Sbuilder::Utils::MyLogger   # mix logger
+    PROGNAME = nil
+
+
+    extend Forwardable               # for easy delegation
+    def_delegators :reader,:get_template
+    
+    # ------------------------------------------------------------------
+    # @!group Construtor + configure
+    
+    def initialize(  reader, options={} )
+      super( reader, options )
+      
+      @logger = getLogger( PROGNAME, options )
+      @logger.info( "#{__method__} created" )
+    
+    end
+
+    # @!endgroup
+
+    # ------------------------------------------------------------------
+    # @!group Public services
+
+    # Resolve file names used in 'extesion_point'
+    #
+    # Implementation assumes that this method is called only for
+    # extension points.
+    #
+    # @param extension_point [String] template for extension point
+    # 
+    # @return [String:Array] array filenames for partials called for the 'extension_point'
+    def resolve_partials( extension_point )
+      @logger.info( "#{__method__} extension_point=#{extension_point}" )
+      template = get_template( extension_point )
+      @logger.debug( "#{__method__} #{extension_point} -> template #{template}" )      
+
+      # data passed to rendering, in this use empty data, because we
+      # are interested only in names included templates
+      data = {}
+
+      # render collects partials used for 'template'
+      partialsInit
+
+      str = render( template, {} )
+
+      return partialsCalled
+
+    end
+
+    # @!endgroup
+
+    # ------------------------------------------------------------------
+    # @!group Called from  'partial' -method
+
+    # Intercept chain to read template file.
+    #
+    # Delegates actual read operation to 'get_template' in parent
+    # class reader.
+    #
+    # @param name [:symbol] name of partial template to include
+    def get_partial( name ) 
+      @logger.info( "#{__method__} read partial_file=#{name}:#{name.class}" )
+
+      # this partial called
+      partialsAdd( name.to_s )
+      
+      partial = get_template( name )
+      return partial
+
+    end
+    
+    # @!endgroup
+
+    # ------------------------------------------------------------------
+    # @!group Collect partials called
+
+    def partialsInit()
+      @partials=[]
+    end
+    
+    def partialsAdd( name )
+      @partials << name
+    end
+    
+    def partialsCalled
+      @partials
+    end
+    
+    # @!endgroup    
+    
+  end
+  
+end

data/lib/sbuilder/mustache/template_root.rb

@@ -0,0 +1,71 @@
+# coding: utf-8
+require 'mustache'                   # extendending implementation of
+
+module Sbuilder
+
+  # Abstract base class, implmenting common template methods. 
+  # 
+  # @abstract
+  class TemplateRoot < Mustache
+
+    include Sbuilder::Utils::MyLogger   # mix logger
+    PROGNAME = nil
+
+    extend Forwardable               # for easy delegation
+    def_delegators :reader,
+                   :get_template,
+                   :controller
+
+    attr_reader :reader
+    # ------------------------------------------------------------------
+    # @!group Constructor && config
+    # 
+    
+    def initialize(  reader, options={} )
+
+      # inject reader
+      #@reader = Sbuilder::TemplateReader.new( options )
+      @reader = reader
+      
+      @logger = getLogger( PROGNAME, options )
+      @logger.info( "#{__method__} created" )
+    
+    end
+
+    # @!endgroup
+    
+    # ------------------------------------------------------------------
+    # @!group Mustache extenstion points
+
+    # method used by mustache framework - delegate to 'get_partial',
+    # which must be implemented by concrete child class
+    
+    def partial(name)
+      @logger.debug( "#{__method__} name=#{name}" )
+
+      # return resolve_partial_direct(name[2..-1])  if name[0..1]  == '!!'
+      # get_partial( resolve_partial_name(name) )
+      get_partial( name )      
+    end
+
+    # @!endgroup    
+
+    # ------------------------------------------------------------------
+    # @!group Services offered to concrete sub-classes
+
+
+    # Is template extension point?
+    #
+    # @param template_name [String] name of template to check
+    #
+    def is_extension_point( template_name )
+      controller.is_extension_point( template_name )
+    end
+    
+
+    # @!endgroup        
+
+
+  end # class
+  
+end

data/lib/sbuilder/param_set.rb

@@ -1,41 +1,55 @@
 
 module Sbuilder
 
-  class ParamSet
+  class ParamSet < ParamSetRoot
 
-    attr_reader :parameters                   # array of parameters:Parameter
+    # attr_reader :parameters                   # array of parameters:Parameter
 
     # ------------------------------------------------------------------
     # mixer
-    PROGNAME = "ParamSet"                     # progname for logger
+    PROGNAME = nil                            # progname for logger default class name
     include Sbuilder::Utils::MyLogger         # mix logger
 
 
     # ------------------------------------------------------------------
     # constrcutore
     def initialize( options = {} )
+      super( options )
       @logger = getLogger( PROGNAME, options )
       @logger.debug( "#{__method__} initialized" )
-      @parameters = []
+      # @parameters = []
     end
 
     def to_s
       "#{getId}"
     end
 
-    # normally resolve 'parameter' sub-classes may override
+    # normally resolve 'parameter' sub-classes may override ie. to
+    # include also response parameters to the list of parameters to
+    # resolve.
     def parametersToResolve
       parameters
     end
 
-    # ------------------------------------------------------------------
-    # builder
-    def addParameter( param )
-      parameters << param
-      self
+    # @return [Boolean] true is some of of 'parametersToResolve'
+    # unsersolved. Uses 'resolveReference' to resolve a parameter, if
+    # parameter implements this method.
+    def resolveNeeded( controller )
+      # TODO - check parametersToResolve
+      # return true
+      unresolved = parametersToResolve.select { |p| !( p.isResolved || p.respond_to?(:resolveReference) && p.resolveReference(controller.model))  }
+      needed = unresolved.any?
+      @logger.debug "#{__method__}: #{getId} resolve needed=#{needed},  unresolved=#{unresolved.map {|u| u.name}.join(',')}, parametersToResolve=#{parametersToResolve.map{|p| p.name }.join(',')}" if @logger.debug?
+      needed
     end
 
     # ------------------------------------------------------------------
+    # builder
+    # def addParameter( param )
+    #   parameters << param
+    #   self
+    # end
+
     # identifier for finding domain matche
     
     def matchesWithParamSet( matcher )
@@ -49,8 +63,9 @@ module Sbuilder
 
     def doGetId
       msg = "Sub class should implement doGetId -method"
-      @logger.error( "#{__method__} #{msg}" )        
-      raise NoMethodError.new( msg  )
+      @logger.error( "#{__method__} #{msg}" )
+      return msg
+      # raise NoMethodError.new( msg  )
     end
 
     # ------------------------------------------------------------------
@@ -58,14 +73,14 @@ module Sbuilder
 
     
     # return hash for generation phase, false if no paramteers
-    def parameter_definitions( model )
-      arra = parameters.map.with_index do |p,i|
+    def parameter_definitions( model, paramArray=parameters )
+      arra = paramArray.map.with_index do |p,i|
         # puts "p=#{p}"
         parameter_def = p.parameter_definition( model )
         # puts "parameter_def=#{parameter_def}"
         parameter_def[:parameter_name] = ParamSet.cleanUpName( parameter_def[:parameter_name] )
         
-        parameter_def[:_comma] = (i < parameters.length-1 ? "," : "" )   # empty string for last element
+        parameter_def['_comma'] = (i < paramArray.length-1 ? "," : "" )   # empty string for last element
         parameter_def
         # {
         #   :name           => p.name,

data/lib/sbuilder/param_set_db.rb

@@ -5,7 +5,7 @@ module Sbuilder
 
     # ------------------------------------------------------------------
     # mixer
-    PROGNAME = "ParamSet_Db"                   # progname for logger
+    PROGNAME = nil                            # progname for logger default class name
     include Sbuilder::Utils::MyLogger         # mix logger
 
     # ------------------------------------------------------------------

data/lib/sbuilder/param_set_def.rb

@@ -10,7 +10,7 @@ module Sbuilder
 
     # ------------------------------------------------------------------
     # mixer
-    PROGNAME = "ParamSet_Def"                  # progname for logger
+    PROGNAME = nil                            # progname for logger default class name
     include Sbuilder::Utils::MyLogger         # mix logger
 
     # ------------------------------------------------------------------
@@ -49,6 +49,11 @@ module Sbuilder
       @isArray = isArray
       self
     end
+
+    # @return [Boolean ] false should not be intepreted as a function
+    def isFunction
+      false
+    end
     
     
 

data/lib/sbuilder/param_set_def_func.rb

@@ -0,0 +1,39 @@
+module Sbuilder
+
+
+  class ParamSetDefFunc < ParamSetDef
+    
+    PROGNAME = nil                            # progname for logger default class name
+    include Sbuilder::Utils::MyLogger         # mix logger
+
+    # ------------------------------------------------------------------
+    # @!group construct && configure
+
+    def initialize( options={} )
+      super( options )
+      @logger = getLogger( PROGNAME, options )
+      @logger.debug( "#{__method__} initialized" )
+      
+    end
+    # @!endgroup
+
+    # @return [Boolean ] true should not be intepreted as a function
+    # (Overrides paranent method)
+    def isFunction
+      true
+    end
+
+    # @return [Parameter:Array] all but last element parameters[0..-2]
+    def domainParameters
+      parameters[0..-2]
+    end
+
+    # @return [Parameter:Array] last element as an array [parameters[-1]]
+    def rangeParameters
+      [parameters[-1]]
+    end
+    
+    
+  end
+
+end

data/lib/sbuilder/param_set_if.rb

@@ -1,17 +1,33 @@
 
 module Sbuilder
 
-  # interface paramter set (identified by path+operations)
+  ##
+  # Interface paramter set model interfaces. An interface is
+  # identified by path+operations (e.g. /customer(get) ).
+  #
+  # Method #parameters return input to the interface, and #response
+  # -method output from the interface service.
+  #
+  #
   class ParamSet_If < ParamSet
 
     attr_reader :path                         # REST path
     attr_reader :operation                    # REST path
-    attr_reader :response                     # returned from interface
+
+    # @attr [ParamSet] response parameter set
+    attr_reader :response
+
+    # @attr [Boolean] infrastructureService true when generate support
+    # to return response from interface service.
     attr_reader :infrastructureService        # default 'false'
 
+    # @attr [Boolean] interfaceService true when generates interface
+    # process
+    attr_reader :interfaceService
+
     # ------------------------------------------------------------------
     # mixer
-    PROGNAME = "ParamSet_If"                  # progname for logger
+    PROGNAME = nil                            # progname for logger default class name
     include Sbuilder::Utils::MyLogger         # mix logger
 
     # ------------------------------------------------------------------
@@ -21,15 +37,12 @@ module Sbuilder
       @logger = getLogger( PROGNAME, options )
       @logger.debug( "#{__method__} initialized" )
       @response = nil
-      @infrastructureService = false
+      
+      # default: generate interface processes, no support for response return
+      setInterfaceService( true )
+      setInfrastructureService( false )
     end
 
-    # # normally resolve 'parameter', however in my case resolve also responses
-    # def parametersToResolve
-    #   return parameters + ( @response ? @response.parameters : [])
-    # end
-    
-
     # ------------------------------------------------------------------
     # configure
 
@@ -43,11 +56,29 @@ module Sbuilder
       self
     end
 
+    ##
+    # Rendering generates interface procesess when true
+    #
+    def setInterfaceService( interfaceService )
+      @interfaceService = interfaceService
+      self
+    end
+
+    ##
+    # Rendering generates support to return values from infrastructure
+    # service.
     def setInfrastructureService( infrastructureService )
       @infrastructureService = infrastructureService
       self
     end
 
+    # @return [Parameter:Array] parameters including
+    # response.parameters, if any
+    def parametersToResolve
+      parameters + (response.nil? ? [] : response.parameters)
+    end
+    
+
     # ------------------------------------------------------------------
     # setIdentity
 
@@ -63,6 +94,10 @@ module Sbuilder
       "#{path}(#{operation})"
     end
 
+    def isArray
+      return false
+    end
+
   end
   
 end

data/lib/sbuilder/param_set_loader_swagger.rb

@@ -13,18 +13,32 @@ module Sbuilder
 
 
     # ------------------------------------------------------------------
-    # constrcutore
+    # @!group Construct && configure
+    
     def initialize( options = {} )
+      super( options )
     end
 
 
-    # ------------------------------------------------------------------
+    ##
     # class method configure
-
+    #
     # @param configuration [Hash] properties to configure
     def self.configure( configuration )
     end
 
+    ##
+    # Instance configuration
+    #
+    # @param [Hash] configuration for object instance, defined in
+    # sbuilder.yaml
+    #
+    def doConfigure( configuration )
+    end
+
+    # @!endgroup
+    
+
     # ------------------------------------------------------------------
     # Loader methods
 
@@ -138,20 +152,23 @@ module Sbuilder
         
         # create set && configure param set for a defintion
         paramSet = facade.newDefinition( defineKey, definedDoc['type']  == 'array' )
+        logger.info "#{__method__} create new definition paramSet=#{paramSet}, isArray=#{paramSet.isArray}" 
         
         # collect
         definitions << paramSet 
 
-        # defines reference
+        # defines reference $ref of items.$ref
         if hasRef( definedDoc ) then
           # case paramter set is a wrapper - most likely an array
-          reference_parameter( paramSet, defineKey, getRefDocumentName( definedDoc ), definedDoc['type'] )
+          # reference_parameter( paramSet, defineKey, getRefDocumentName( definedDoc ), definedDoc['type'] )
+          swagger_parameter = facade.newParameterReference( defineKey, getRefDocumentName( definedDoc ), definedDoc['type'] == 'array' )
+          facade.addParameter( paramSet, swagger_parameter )
           
         else
 
           # defines onw attributes
           expandedDocs = expand_definedDocs( definedDoc, swagger_hash )
-          # puts "    defineKey=#{defineKey} --> expandedDocs=#{expandedDocs}"
+          logger.debug "#{__method__}    defineKey=#{defineKey} --> expandedDocs=#{expandedDocs}"
 
           # iterate array of [ { <name> = { "type"=>.., <format> =>..}, <name> => ..}, ... ]
           expandedDocs.each do |expandedDoc|
@@ -159,9 +176,14 @@ module Sbuilder
             expandedDoc.each do  |parameterName,parameterProps|
               logger.debug( "#{__method__} {op}-parameterName->#{parameterName}, parameterProps=>#{parameterProps}" )
               if hasRef( parameterProps ) then
-                reference_parameter( paramSet, parameterName, getRefDocumentName( parameterProps ), parameterProps['type'] )                
+                # reference_parameter( paramSet, parameterName, getRefDocumentName( parameterProps ), parameterProps['type'] )
+                swagger_parameter = facade.newParameterReference( parameterName, getRefDocumentName( parameterProps ), parameterProps['type'] == 'array' )
+                facade.addParameter( paramSet, swagger_parameter )
+                
               else
-                simple_parameter( paramSet, parameterName, parameterProps['type'] )
+                # simple_parameter( paramSet, parameterName, parameterProps['type'] )
+                swagger_parameter = facade.newParameter( parameterName, parameterProps['type'] == 'array' )
+                facade.addParameter( paramSet, swagger_parameter )
               end
             end
           end
@@ -190,7 +212,7 @@ module Sbuilder
           
           # New interface operation '/path(op) & access response  operation
           interfaceParamSet = facade.newInterface( path, op )
-          paramSetResponse  = interfaceParamSet.response
+          # paramSetResponse  = interfaceParamSet.response
           
           logger.info( "#{__method__} created interfaceParamSet=#{interfaceParamSet.getId}" )
           logger.debug( "#{__method__} created interfaceParamSet.getId=#{interfaceParamSet.getId}, opdef=#{opdef}" )
@@ -206,9 +228,16 @@ module Sbuilder
             if parameter['schema'] then
               # in='body' => schema defined
               defintionReferenceName =  getReferencedDefinitionName( parameter['schema'], swagger_hash )
-              reference_parameter( interfaceParamSet, parameter['name'], defintionReferenceName )
+              parameterType = parameter['schema']['type']
+              
+              # reference_parameter( interfaceParamSet, parameter['name'], defintionReferenceName, parameterType )
+              swagger_parameter = facade.newParameterReference( parameter['name'], defintionReferenceName, parameterType == 'array' )
+              facade.addParameter( interfaceParamSet, swagger_parameter )
+              
             elsif parameter['name']
-              simple_parameter( interfaceParamSet, parameter['name'], parameter['type'] ) if parameter['name']
+              # simple_parameter( interfaceParamSet, parameter['name'], parameter['type'] ) if parameter['name']
+              swagger_parameter = facade.newParameter( parameter['name'], parameter['type'] == 'array' )
+              facade.addParameter( interfaceParamSet, swagger_parameter )
             else
               msg = "Empty parameter definition on #{path}/#{op} "
               logger.error( "#{__method__} #{msg}" )
@@ -226,8 +255,9 @@ module Sbuilder
             if response['schema'] then
               defintionReferenceName =  getReferencedDefinitionName( response['schema'], swagger_hash )
               logger.debug( "#{__method__} defintionReferenceName=#{defintionReferenceName}, op=#{op}, status_code=#{status_code}, response=#{response}" )
-              reference_parameter( paramSetResponse, "status_#{status_code}", defintionReferenceName, response['schema']['type']  )
-
+              # reference_parameter( paramSetResponse, "status_#{status_code}", defintionReferenceName, response['schema']['type']  )
+              swagger_parameter = facade.newParameterReference( "status_#{status_code}", defintionReferenceName, response['schema']['type'] == 'array' )
+              facade.addResponseParameter( interfaceParamSet, swagger_parameter )
             else
               logger.debug( "#{path}-#{op}-#{status_code}: no response data for response #{response}" )
               # response object
@@ -243,25 +273,25 @@ module Sbuilder
     # ------------------------------------------------------------------
     # Create parameters && add to param set
 
-    # process simple (i.e. non body ) parameter
-    def simple_parameter( paramSet, name, parameterType )
+    # # process simple (i.e. non body ) parameter
+    # def simple_parameter( paramSet, name, parameterType )
       
-      swagger_parameter = facade.newParameter( name, parameterType == 'array' )
-      # add to parameter set
-      paramSet.addParameter( swagger_parameter )
-    end
+    #   swagger_parameter = facade.newParameter( name, parameterType == 'array' )
+    #   # add to parameter set
+    #   paramSet.addParameter( swagger_parameter )
+    # end
 
-    # process simple (i.e. non body ) parameter
-    def reference_parameter( paramSet, name, defintionReferenceName, parameterType="string" )
+    # # process simple (i.e. non body ) parameter
+    # def reference_parameter( paramSet, name, defintionReferenceName, parameterType="string" )
       
-      swagger_parameter = facade.newParameterReference( name, defintionReferenceName, parameterType == 'array' )
+    #   swagger_parameter = facade.newParameterReference( name, defintionReferenceName, parameterType == 'array' )
       
-      logger.info( "#{__method__} param set =#{paramSet.getId}, parameter=#{swagger_parameter.getName}, parameter=#{swagger_parameter.reference}" )
+    #   logger.info( "#{__method__} param set =#{paramSet.getId}, parameter=#{swagger_parameter.getName}, parameter=#{swagger_parameter.reference}, parameterType=#{parameterType}" )
 
-      # add to parameter set
-      paramSet.addParameter( swagger_parameter )
+    #   # add to parameter set
+    #   paramSet.addParameter( swagger_parameter )
 
-    end
+    # end
 
     
     # ------------------------------------------------------------------