tla-sbuilder 0.2.2 → 0.3.4

data/lib/sbuilder/facade/snippet_loader_plugin.rb

@@ -0,0 +1,76 @@
+module Sbuilder
+
+  # Abstract Parent class for Sbuilder for Snippet loaders.
+  #
+  # Class implements following service groups
+  #
+  # - Constructor and Object Initialize
+  # - Framework Services for API loader
+  # - configure plugin  
+  #
+
+  
+  class SnippetLoaderPlugin < LoaderPluginRoot
+
+    
+    # services to hook up framework
+    include SnippetLoaderPluginMixer
+
+    # def_delegator Sbuilder::SnippetLoaderPlugin, :validateProperties
+
+    # ------------------------------------------------------------------
+    # @!group Constructor and Object Initialize
+
+    def initialize( options = {} )
+      super( options )
+    end
+
+    # @!endgroup
+
+    # ------------------------------------------------------------------
+    # @!group Configure Plugin
+
+    # Configure API loader - MUST be implemented by plugin class
+    # @param configuration [Hash] properties to configure
+    
+    def self.configure( configuration )
+      raise PluginException.new <<-EOS unless configuration.nil?
+      Plugin classes should implement class method #{__method__}
+
+
+      This error is raised when using 'configuration' -property in 'extend.loaders' array entry.
+      For example:
+
+      extend:
+          loaders:
+            - className: Sbuilder::XXXX::Plugin
+              gem: sbuilder-xxxx
+              configuration: any value
+
+      and the plugin class (e.g. Sbuilder::XXXX::Plugin) does not implement class 
+      method '.#{__method__}'
+
+      EOS
+    end
+
+    
+    # @!endgroup
+
+    # ------------------------------------------------------------------
+    # @!group Register snippets to sbuilder
+
+    # Abstract method, which must be implemented by concrete snippet loader plugin
+    #
+    # This method should use 'handOver' method, which passes snippet,
+    # along with metadata, via snippet loader snippetFacade to sbuilder.
+    #
+    def doRegisterSnippets( snippetsDefs )
+      raise PluginException.new "Missing implementation for  'doRegisterSnippets'"
+    end
+    
+    # @!endgroup
+
+    
+  end # class  SnippetLoaderPlugin
+end
+

data/lib/sbuilder/facade/snippet_loader_plugin_mixer.rb

@@ -0,0 +1,56 @@
+module Sbuilder
+
+  ##
+  # Mixer module to include to API loader plugins
+  #
+  # Implement:
+  # - getter & setter for Snippet loader facade
+  
+  module SnippetLoaderPluginMixer
+
+    ##
+    # Sbuilder controller calls 'setFacade' when new API loader object
+    # is contstructed. Sets instance variable '@facade'.
+    #
+    # @param [Sbuilder::ApiLoaderFacade] facace to Sbuilder  services
+    
+    def setSnippetFacade( facade )
+      @snippetFacade = facade
+    end
+
+    # @return [Sbuilder::ApiLoaderFacade] snippetFacade to access Sbuilder servivices ( set in 'setFacade')
+    def snippetFacade
+      @snippetFacade
+    end
+
+    ##
+    # A method available for plugin sub class, allowing sub class to
+    # register metatype prio 
+    def registerMetatype( metatype, desc )
+      snippetFacade.registerMetatype( metatype, desc )
+    end
+
+    ##
+    # @param [Hash] snippetsDefs defining snippets to
+    # load. +snippetsDefs+ are passed un modified to plugin
+    # implementation
+    def registerSnippets( snippetsDefs )
+      # call implementation in concrete class
+      logger.info "#{__method__}, snippetsDefs=#{snippetsDefs}"
+      doRegisterSnippets( snippetsDefs  )
+    end
+    
+
+    # def validateProperties( hash, required_props, allowed_props )
+    #   SnippetLoaderPlugin.validateProperties( hash, required_props, allowed_props )      
+    # end
+
+    def self.validateProperties( hash, required_props, allowed_props )
+      Sbuilder::Utils::Validate.validateProperties( hash, required_props, allowed_props )      
+    end
+
+    
+
+  end
+  
+end

data/lib/sbuilder/factory.rb

@@ -7,7 +7,7 @@ module Sbuilder
     @@singleton=nil                   # initiallly no factory object
     attr_reader :options              # remembers options
 
-    attr_reader :paramSetLoaders      # hash[Name->Class:ParamSetLoader]
+    attr_reader :loaderPlugins        # hash[Name->Class] with configure method
     attr_reader :mapperRules          # hash[Name->Class:ResolverRule]
     attr_reader :mapperLoaders        # hash[Name->Class:ResolverLoader]    
     attr_reader :parameters           # hash[Name->Class:Parameter]     
@@ -15,9 +15,17 @@ module Sbuilder
     attr_reader :domains              # hash[Name->Class:Domain]    
     attr_reader :extension_loaders    # hash[Name->Class:ExtensionLoader]
 
+    # @attr [Sbuilder::SetupLoader:Array] array of setuploader
+    attr_reader :setup_loaders
+
+    # @attr [Hash] namedPluginObjects
+    # @option namedPluginObjects [String] name of ApiLoaderPlugin, SnippetLoaderPlugin
+    # @option namedPluginObjects [Object] object of ApiLoaderPlugin, SnippetLoaderPlugin    
+    attr_accessor :namedPluginObjects
+
     # ------------------------------------------------------------------
     # mixer
-    PROGNAME = "Factory"        # progname for logger
+    PROGNAME = nil                    # progname for logger default class name
     include Sbuilder::Utils::MyLogger # mix logger
 
    
@@ -29,34 +37,47 @@ module Sbuilder
       @logger = getLogger( PROGNAME, options )
       @logger.info( "#{__method__} initialized options=#{options}" )
       @options = options
+
+      self.namedPluginObjects={}
       initializeFactories
     end
 
+
     def initializeFactories
       @extension_loaders={
         Sbuilder::Constants::EXTENSION_LOADER_YAML => ExtensionLoader,
       }
+      @setup_loaders = {
+        Sbuilder::Constants::SETUP_LOADER_ENVIRONMENT => SetupLoaderEnv,
+        Sbuilder::Constants::SETUP_LOADER_STEP => SetupLoaderEnv,
+        Sbuilder::Constants::SETUP_PREFERENCES_EXTENSION => SetupLoaderPref,
+      }
       @parameters={
         Sbuilder::Constants::PARAMETER => Parameter_Dom,
         Sbuilder::Constants::PARAMETER_REF => Parameter_Ref,
       }
       @paramSets = {
         Sbuilder::Constants::INTERFACE_OPERATION => ParamSet_If,
-        Sbuilder::Constants::SWAGGER_DEFINITION => ParamSetDef,
+        Sbuilder::Constants::DEFINITION => ParamSetDef,
+        Sbuilder::Constants::DEFINITION_FUNCTION => ParamSetDefFunc,        
         Sbuilder::Constants::PARAM_SET_STEPS => ParamSetStep,
       }
       
-      @paramSetLoaders = {
+      @loaderPlugins = {
         # Sbuilder::Constants::LOADER_SWAGGER => ParamSetLoaderSwagger
       }
       
-      # swagger loader loaded as an extension
+      # add default loaders to sbuilder
       addLoaders( [
-                    { 'gem' => 'sbuilder/param_set_loader_swagger',
+                    { 'gem' => './param_set_loader_swagger',
                       'className' => 'Sbuilder::ParamSetLoaderSwagger',
                       'configuration' => nil,
-                    }
-                  ], [ Sbuilder::Constants::LOADER_SWAGGER] )
+                    },
+                    { 'gem' => './snippet_loader_simple',
+                      'className' => 'Sbuilder::SnippetLoaderSimple',
+                      'configuration' => { 'src_dir' => options[:src_dir] },
+                    },
+                  ], [ Sbuilder::Constants::LOADER_SWAGGER, nil] )
       @mapperLoaders = {
         Sbuilder::Constants::MAPPER_YAML => ResolverLoader_YAML
       }
@@ -67,23 +88,42 @@ module Sbuilder
 
       @domains = {
         Sbuilder::Constants::TYPE_DOMAIN => Domain,
-        Sbuilder::Constants::TYPE_VALUE_DOMAIN => DomainValue ,
+        Sbuilder::Constants::TYPE_DOMAIN_TYPE => DomainType,
+        Sbuilder::Constants::TYPE_RANGE_DOMAIN => DomainRange,
+        Sbuilder::Constants::TYPE_VALUE_DOMAIN => DomainValue,
         Sbuilder::Constants::TYPE_CARDINALITY_DOMAIN => DomainCardinality ,               
       }
       
     end
 
-    # Configure additional loaders
+
+    # ------------------------------------------------------------------
+    # @!group Plugin extensions
+
+    # Configure additional plugin extensions
+    #
+    # @param arrOfLoaders [Hash:Array] with properties
+    # :name,:className
+    #
+    # @param name [String:Array] alias name to use (in addition to
+    # className)
     #
-    # @param arrOfLoaders [Hash:Array] with properties :name,:className
-    # @param name [String:Array] alias name to use (in addition to className)
     def addLoaders( arrOfLoaders, names=nil )
+      
       arrOfLoaders.each_with_index do |loader,index|
 
-        validateProperties( loader, ['className', 'gem'], ['configuration'] )
+        # validateProperties( loader, ['className', ], ['configuration', 'gem', 'objects'] )
+        Utils::Validate.validateProperties( loader, Constants::VALIDATION[:extend_loader][:required], Constants::VALIDATION[:extend_loader][:allowed] )        
         
-        # load class module to context - if className
-        require loader['gem'] unless Class.const_defined?( loader['className'] )
+        # load class module to context - unless Class already defined
+        if ! Class.const_defined?( loader['className'] )
+          Utils::Validate.validateProperties( loader, Constants::VALIDATION[:extend_loader][:required_after_classname], Constants::VALIDATION[:extend_loader][:allowed] )
+          if loader['gem'][0] == '.'
+            require_relative loader['gem']
+          else
+            require loader['gem']
+          end
+        end
 
         begin
           @logger.info "#{__method__} loader['className']=#{loader['className']}"
@@ -97,16 +137,98 @@ module Sbuilder
           @logger.error( "#{__method__} #{msg}" )          
           raise NameError, msg, e.backtrace
         end
-        klass.configure( loader['configuration'] )
         # using className
         name = loader['className']
-        paramSetLoaders[name] = klass
-        # using optional name
-        paramSetLoaders[names[index]] = klass  if names
         
+        loaderPlugins[name] = klass
+        # @logger.info  "#{__method__}, name=#{name}, configuration: #{loader['configuration']} "
+        klass.configure( loader['configuration']  )
+        # optional alias name
+        loaderPlugins[names[index]] = klass  if names && names[index]
+
+        # if 'objects property defined'
+        loader['objects'] && loader['objects'].each do |objectConfiguration|
+
+          @logger.info  "#{__method__}, objectConfiguration=#{objectConfiguration}"
+
+          Utils::Validate.validateProperties( objectConfiguration, Constants::VALIDATION[:extend_loader_object][:required], Constants::VALIDATION[:extend_loader_object][:allowed] )        
+
+          # # create & configure object for 'className'
+          # o = klass.new( options ).configure( objectConfiguration['configuration']  )
+          o = getLoaderPlugin( loader['className'], objectConfiguration['configuration']  )
+
+          # add it to dictionary
+          @logger.info  "#{__method__}, add=#{objectConfiguration['objectName']}, #{o}"          
+          namedPluginObjects[ objectConfiguration['objectName'] ] = o
+          
+        end # each object
+        
+      end # each 
+    end
+
+    # return 'objectName' plugin instance, or create new plugin object
+    # with 'className.new'.configure( configuration )
+    #
+    # @param [String] className name of the plugin, if nil objectName
+    # must be nil
+    #
+    # @param [Object] configuration to pass to className.new 
+    #
+    # @param [String] objectName name of the plugin object, if nil
+    # className must be non nil.
+    #
+    # 
+    # @return [ApiLoaderPlugin] plugin object instance
+    #
+    def getLoaderPlugin( className, configuration=nil, objectName=nil )
+
+      @logger.info "#{__method__}, className=#{className}, configuration=#{configuration}, objectName=#{objectName}"
+
+      raise FactoryException, "Must give either 'className' or 'objectName'" if
+        className.nil? && objectName.nil? || !className.nil? && !objectName.nil? 
+
+      if objectName then
+        
+        # get usign objectName
+        o = namedPluginObjects[objectName]
+
+        if o.nil? then
+          msg = <<-EOS
+          Unknown loader plugin object #{objectName}
+
+          Check array 'extend.loaders.objects' for 'objectName' 
+
+          Known loader plugin object names: #{namedPluginObjects.keys.join(',')}
+          EOS
+          @logger.error( "#{__method__} #{msg}" )
+          raise NameError.new( msg  ) 
+          
+        end
+        @logger.info "#{__method__}, found #{objectName} --> #{o.class}"
+        return o
+      else
+
+        # create new 'unnamed object'
+        
+        if loaderPlugins[className].nil? then
+          msg = <<-EOS
+        Unknown parameter className #{className}"
+
+        Validate classNames #{loaderPlugins.keys}
+        EOS
+          
+          @logger.error( "#{__method__} #{msg}" )
+          raise NameError.new( msg  ) 
+        end
+        newObject = loaderPlugins[className].new( options )
+        newObject.configure( configuration ) if configuration
+        return newObject
       end
     end
     
+    # @!endgroup    
+
+    
     # ------------------------------------------------------------------
     # singleton 
     class << self
@@ -140,29 +262,22 @@ module Sbuilder
       return mapperLoaders[type].new( Factory.getFactory(options), options )      
     end
 
-    # @return [Sbuilder::ApiLoader] facade to Sbuilder
-    def getFacade( controller )
-      facade = Sbuilder::ApiLoader.new( Factory.getFactory(options), options )
+    # @return [Sbuilder::ApiLoaderFacade] api loader facade to Sbuilder
+    def getApiFacade( controller )
+      facade = Sbuilder::ApiLoaderFacade.new( Factory.getFactory(options), options )
+      facade.setController( controller )
+      return facade
+    end
+
+    # @return [Sbuilder::SnippetLoaderFacade] api loader facade to Sbuilder
+    def getSnippetFacade( controller )
+      facade = Sbuilder::SnippetLoaderFacade.new( Factory.getFactory(options), options )
       facade.setController( controller )
       return facade
     end
 
 
-    # return object to load parameter sets
-    def getParamSetLoader( type )
-      if paramSetLoaders[type].nil? then
-        msg = <<-EOS
-        Unknown parameter type #{type}"
 
-        Validate types #{paramSetLoaders.keys}
-        EOS
-        
-        @logger.error( "#{__method__} #{msg}" )
-        raise NameError.new( msg  ) 
-      end
-      return paramSetLoaders[type].new( options )
-    end
-    
     # ------------------------------------------------------------------
     # template reader
 
@@ -176,15 +291,21 @@ module Sbuilder
       if options[:filter_src]
         Sbuilder::TemplateContextReader.new( controller, @options )
       else
-        Sbuilder::TemplateReader.new( controller, @options )
+        getDefaultTemplateReader( controller )
+        # Sbuilder::TemplateReader.new( controller, @options )
       end
       # return @template_reader if @template_reader
       # @template_reader = Sbuilder::TemplateReader.new( @options )
       # @template_reader
     end
 
+    # @return [TemplateReader] default reader
+    private def getDefaultTemplateReader( controller )
+      Sbuilder::TemplateReader.new( controller, @options )
+    end
+
     # ------------------------------------------------------------------
-    # generate
+    # template
     #
     # @return [Template] mustache template generator
     def getTemplate( reader )
@@ -193,31 +314,81 @@ module Sbuilder
       # @template = Template.new( getTemplateReader, @options )
       # @template
     end
+
+    # @return [mustache] template to accept 
+    def getSnippetFacadeMustache
+      return Mustache.new
+    end
+
+    
+    # @return [Sbuilder::TemplateResolve] mustache template generator to resolver partials
+    def getTemplateResolver( controller )
+      reader = getDefaultTemplateReader( controller )
+      Sbuilder::TemplateResolve.new( reader, @options )      
+    end
     
     # ------------------------------------------------------------------
-    # model
+
+
+    # @return [Sbuilder::Model] model created
     def createModel
       Sbuilder::Model.new( self, options )
     end
+
+    # @return [Sbuilder::SymbolTable] symbol table created
+    def createSymbolTable
+      Sbuilder::SymbolTable.new( options )
+    end
+      
     
     # ------------------------------------------------------------------
-    # domainLoader
-    
-    def getExtensionLoader( type )
+    # extesion loaders
+
+    # @param [String] setupName
+    def getExtensionLoader( type, setupName )
       if extension_loaders[type].nil? then
         
         msg = <<-EOS
-        Unknown extension loader type #{type}"
+        Unknown extension type #{type}"
 
-        Valid extension loader types #{extension_loaders.keys}
+        Valid extension types #{extension_loaders.keys}
         EOS
         @logger.error( "#{__method__} #{msg}" )
         raise NameError.new( msg  )
       end
-      extension_loaders[type].new( options )
+      ldr = extension_loaders[type].new( options )
+      ldr.setupName = setupName
+      ldr
       # Sbuilder::ExtensionLoader.new( options )
     end
 
+    # @param [String] type of controller to create
+    #
+    # @param [Sbuilder::Controller] controllre to associate with setup loader
+    #
+    # @param [String] setupName name of setup to extended
+    def getSetupLoader( type, controller, setupName )
+      if setup_loaders[type].nil? then
+        
+        msg = <<-EOS
+        Unknown setup extension type #{type}"
+
+        Valid setup extesion types: #{setup_loaders.keys}
+        EOS
+        @logger.error( "#{__method__} #{msg}" )
+        raise NameError.new( msg  )
+      end
+      ldr = setup_loaders[type].new( options,  )
+      ldr.controller = controller
+      ldr.setupName = setupName
+      # Sbuilder::ExtensionLoader.new( options )
+      ldr
+    end
+
+    def getStepGenerator
+      Sbuilder::StepGenerator.new( options )
+    end
+
     # ------------------------------------------------------------------
     # mapper
 
@@ -277,6 +448,14 @@ module Sbuilder
       parameters[type].new( options )
     end
 
+    # ------------------------------------------------------------------
+    # parser
+
+    # @return [Sbuilder::ParserFacade] facade to parser
+    def createParserFacade
+      Sbuilder::ParserFacade.new( options )
+    end
+
     # ------------------------------------------------------------------
     # validate 'defintionHash' all 'required'/only 'allowed' props set
     private def validateProperties( defintionHash, required, allowed=[] )