tla-sbuilder 0.2.2 → 0.3.4

data/lib/sbuilder/facade/{api_loader.rb → api_loader_facade.rb}

@@ -10,13 +10,17 @@ module Sbuilder
   #   model objects, and build sbuilder model
   #
   
-  class ApiLoader
+  class ApiLoaderFacade
 
     extend Forwardable                        # for easy delegation
 
-    # facade configuration
 
-    attr_reader :infrastructureServices       # default 'false'
+    # @attr [Boolean] infrastructureServices generate response, default 'false'
+    attr_reader :infrastructureServices
+
+    # @attr [Boolean] interfaceService genarate interface process, default 'true'
+    attr_reader :interfaceServices
+    
 
     # string to prefix to all definitions (default 'nil' ie. no
     # prefix). Allow homonymous API definition names ie. same
@@ -42,15 +46,13 @@ module Sbuilder
 
     # ------------------------------------------------------------------
     
-    
     # progname for logger
-    PROGNAME = "ApiLoader"
-    
-    include Sbuilder::Utils::MyLogger    # mix logger
+    PROGNAME = nil                            # progname for logger default class name
+    include Sbuilder::Utils::MyLogger         # mix logger
 
 
     # ------------------------------------------------------------------
-    # @!group Constructore
+    # @!group Construtor
     
     def initialize( factory, options = {} )
       @logger = getLogger( PROGNAME, options )
@@ -61,7 +63,9 @@ module Sbuilder
       @controller = nil
       
       # configuration init
-      @infrastructureServices = false
+      configureInfrastructureService( false )
+      configureInterfaceService( true )
+      
       @namespace = nil
       
       @cacheFile = nil
@@ -72,7 +76,7 @@ module Sbuilder
     # @!endgroup
     
     # ------------------------------------------------------------------
-    # @!group Interface used by controller to configure the facade
+    # @!group Prepare Facade
 
     # Allow facade to access controller services
     # @param controller [Sbuilder::Controller] controller sets self
@@ -85,18 +89,26 @@ module Sbuilder
     def setFactory( factory )
       @factory = factory
     end
-    
+
+    ##
     # Tag all interfaces created using this facadate with property 'infrastructureServices'
     #
-    # @param infrastructureServices [Boolean] true/false set on all interfaces
+    # @param [Boolean] infrastructureServices true/false set on all interfaces
     #
     def configureInfrastructureService( infrastructureServices )
       @infrastructureServices = infrastructureServices
     end
 
+    ##
+    # Tag all interfaces created using this facadate with property 'interfaceService'
+    def configureInterfaceService( interfaceServices )
+      @interfaceServices = interfaceServices
+    end
+    
+
     # Prefix all definititions with "#{namespace}." string
     #
-    # @param namespace [String] string to prefix to all definitions
+    # @param  [String] namespace to prefix to all definitions
     #
     def configureNamespace( namespace )
       @namespace = namespace
@@ -104,7 +116,7 @@ module Sbuilder
 
     # Cache string read into 'cacheFile'
     #
-    # @param cacheFile [String] name of file to cache content in this facade
+    # @param [String] cacheFile name of file to cache content in this facade
     #
     def setInterfaceCacheFilePath( cacheFile )
       @cacheFile = cacheFile
@@ -113,16 +125,16 @@ module Sbuilder
     # @!endgroup    
 
     # ------------------------------------------------------------------
-    # @!group Read and cache api content
+    # @!group Cache API Metadata
     
     # Reader service: read String of interface definitions from
     # 'location'. The string is cached in '@cacheFile', which
     # controller has configured.
     #
-    # @param location [String] uri/file/block parameter from which to
+    # @param [String] location uri/file/block parameter from which to
     # read the string
     #
-    # @param blk [yield] yield block to read if no block given use
+    # @param  [yield] blk yield block to read if no block given use
     # 'Sbuilder::Utils::NetIo.read_lines'. Block should return a
     # string.
     #
@@ -144,14 +156,14 @@ module Sbuilder
     # @param what [String] sub-content in cache
     # @return [String] cached content (nil if no cached content
     def get_cached( what=nil )
-      Sbuilder::Utils::CacheLines.cache_read( get_cachefile(what)  ) if doCache?
+      Sbuilder::Utils::FileIo.cache_read( get_cachefile(what)  ) if doCache?
     end
 
     # Service for loader to save 'line' into cache
     # @param line [String] content to store
     # @param what [String] sub-content in cache
     def cache_line( line, what=nil )
-      Sbuilder::Utils::CacheLines.cache_write( get_cachefile(what), line ) if doCache? && line
+      Sbuilder::Utils::FileIo.cache_write( get_cachefile(what), line ) if doCache? && line
     end
 
     # @return [Boolean] true if cache i.e. when cacheFile defined
@@ -159,20 +171,27 @@ module Sbuilder
       !cacheFile.nil?
     end
 
+    # Return cache directory location from opitions
+    #
+    # @return [String] path to cache -directory
+    def getCacheDir
+      controller.getCacheDir
+    end
+    
+
     # @!endgroup
-    # ------------------------------------------------------------------
 
     # ------------------------------------------------------------------
-    # @!group Build model
+    # @!group Add to Sbuilder
 
     # Add 'newDefinition' to model
-    # @param newDefinition [Sbuilder::ParamSetDef] definition to add
+    # @param  [Sbuilder::ParamSetDef] newDefinition definition to add
     def modelDefinition( newDefinition )
       controller.modelDefinition( newDefinition ) 
     end
 
     # Add 'newInterface' to model
-    # @param newInterface [Sbuilder::ParamSet_If] interface to add
+    # @param  [Sbuilder::ParamSet_If] newInterface interface to add
     def modelInterface( newInterface )
       controller.modelInterface( newInterface ) 
     end
@@ -180,15 +199,32 @@ module Sbuilder
     # @!endgroup    
 
     # ------------------------------------------------------------------
-    # @!group Construct model objects
+    # @!group Construct Model Objects
     
     # 
-    # @param definitionName [String] name of defintition to create
-    # @param isArray [Boolean] if array defined
+    # @param  [String] definitionName name of defintition to create
+    # @param  [Boolean] isArray true if array defined
     #
     # @return [Sbuilder::ParamSetDef] New definition object created
     def newDefinition( definitionName, isArray=false )
-      paramSet =  createParamSet( Sbuilder::Constants::SWAGGER_DEFINITION )
+      paramSet =  createParamSet( Sbuilder::Constants::DEFINITION )
+      # optionally prefix within namespace
+      definitionName = namespacedReferenceName( definitionName )
+      paramSet.setDefinition( definitionName )
+      paramSet.setIsArray(  isArray )
+      return paramSet
+    end
+
+    # Create a function definition (parameter set)
+    #
+    # @param [String] definitionName name of defintition to create
+    # @param [Boolean] isArray true if array defined
+    #
+    # @return [Sbuilder::ParamSetDefFunc] New definition object created
+
+    def newFunctionDefinition( definitionName, isArray=false )
+
+      paramSet =  createParamSet( Sbuilder::Constants::DEFINITION_FUNCTION )
       # optionally prefix within namespace
       definitionName = namespacedReferenceName( definitionName )
       paramSet.setDefinition( definitionName )
@@ -196,11 +232,12 @@ module Sbuilder
       return paramSet
     end
 
-    # Create new interface paramtereter sert (and response parameter set)
+    # Create new interface paramtereter set (and a response parameter
+    # set)
     #
-    # @param path [String] path of restfull interface operation
+    # @param [String] path of restfull interface operation
     #
-    # @param op [String] rest operation (get, put, post,...), defaults
+    # @param  [String] op rest operation (get, put, post,...), defaults
     # to 'response' (ie. definiting return from a operation)
     #
     # @return [Sbuilder::ParamSet_If] New interface param set createds
@@ -213,8 +250,8 @@ module Sbuilder
     end
 
     # Cretate new pojo for a simple paramter
-    # @param name [String] name of the simple paramter to create
-    # @param isArray [Boolean] true if array
+    # @param  [String] name of the simple paramter to create
+    # @param  [Boolean] isArray true if array
     # @return [Sbuilder::Parameter_Dom] new parmater created
     def newParameter( name, isArray=false )
       swagger_parameter = createParameter( Sbuilder::Constants::PARAMETER  )
@@ -224,34 +261,124 @@ module Sbuilder
       return swagger_parameter
     end
 
+    ##
+    # Add +paramter+ to +parameterSet+
+    #
+    # @param [ParamSet|ParamSetDef|ParamSet_If]  paramSet where to add to
+    #
+    # @param [Parameter] parameter to add
+    #
+    # @param [String] name of domain to assign to +parameter+
+
+    def addParameter( paramSet, parameter, domain_name=nil )
+      paramSet.addParameter( parameter )
+      configParameterDomain( parameter, domain_name ) if domain_name      
+    end
+
+    ##
+    # Add +paramter+ to +parameterSet+ response
+    #
+    # @param [ParamSet_If] paramSet of the response where to add to
+    #
+    # @param [Parameter] parameter to add
+    #
+    # @param [String] name of domain to assign to +parameter+
+
+    def addResponseParameter( paramSet, parameter, domain_name=nil )
+      responseParamSet = paramSet.response      
+      responseParamSet.addParameter( parameter )
+      configParameterDomain( parameter, domain_name ) if domain_name
+    end
+
+    ##
+    # Set +domain_name+ to +parameter+
+    #
+    # @param [Parameter] parameter to add
+    #
+    # @param [String] name of domain to assign to +parameter+ private
+    def configParameterDomain( parameter, domain_name )
+
+      if !parameter.is_a?(Parameter_Dom) then
+        msg = <<-EOS
+          Only domain parameters can assgined domain
+
+          In this case domain '#{domain_name}' was assigned to #{parameter.class}
+          EOS
+        @logger.error "#{__method__}, msg"
+        raise PluginException, msg
+      end
+      # call static busines rule to set 'domain' on 'parameter' in model context
+      ResolverRuleMatch.setDomain( parameter, domain_name, controller.model )
+      
+    end
+    
+
     # Create new pojo for a reference to a definition
     #
-    # @param name [String] name of the simple paramter to create
-    # @param referenceName [String] definition name referenced
-    # @param isArray [Boolean] true if array
+    # @param [String] name of the simple paramter to create
+    # @param [String] referenceName definition name referenced
+    # @param [Boolean] isArray true if array
     # @return [Sbuilder::Parameter_Ref] new parmater created
     
     def newParameterReference( name, referenceName, isArray )
-      swagger_parameter = createParameter( Sbuilder::Constants::PARAMETER_REF  )
-      swagger_parameter.setName( name )
+      refParameter = createParameter( Sbuilder::Constants::PARAMETER_REF  )
+      refParameter.setName( name )
       # namespace.name
       referenceName = namespacedReferenceName( referenceName )      
-      swagger_parameter.setReference( referenceName )
-      swagger_parameter.setIsArray( isArray )
-      return swagger_parameter
+      refParameter.setReference( referenceName )
+      refParameter.setIsArray( isArray )
+      return refParameter
     end
 
     # @!endgroup
+
     # ------------------------------------------------------------------
+    # @!group domain
+
+    ##
+    # Add +domainName+ to sbuilder. Pass +domainValues+ to controller
+    # using +setApplicationDomainValues+ api if defined. 
+    #
+    # @param [String] domainName to define
+    #
+    # @param [String:Array] domainValues e.g. literals in application
+    #
+    def defineDomain( domainName, domainValues = nil )
+      controller.domainEncountered( domainName )
+      controller.setApplicationDomainValues( domainName, domainValues ) if domainValues && domainValues.is_a?( Array ) && domainValues.any?
+    end
+    
+
+    # @!endgroup
 
     # ------------------------------------------------------------------
-    # @!group misc
+    # @!group Access framework context
 
-    # @return [String] semver number
+
+    ##
+    # Return array of base metatypes in sbuilder context
+    #
+    # @return [Hash] baseMetatypes
+    # @option baseMetatype [Symbol] :name of metatype
+    # @option baseMetatype [Symbol] :desc metatype description
+    def baseMetatypes
+      controller.baseMetatypes
+    end
+    
+
+    # @!endgroup
+    
+    # ------------------------------------------------------------------
+    # @!group Miscellaneous Operations
+
+    
+
+    # # @return [String] semver number
     def version
-      "1.0.2"
+      Sbuilder::version
     end
 
+
     # @param logname [String] progname to set on logger
     # @return [Logger] new logger object
     def createLogger( logname )
@@ -269,7 +396,11 @@ module Sbuilder
     def newParamset( path, op ='response' )
       interfaceParamSet =  createParamSet( Sbuilder::Constants::INTERFACE_OPERATION )
       interfaceParamSet.setIdentity( path, op )
+      # infrastructureService (capability to return response), and
+      # infrastructureService (interface process) use values set using
+      # configure* -methods
       interfaceParamSet.setInfrastructureService( infrastructureServices )
+      interfaceParamSet.setInterfaceService( interfaceServices )      
       return interfaceParamSet
     end
 
@@ -278,7 +409,7 @@ module Sbuilder
       "#{cacheFile}#{ what ? '.' + what : '' }"
     end
 
-    # @return [String] 'definitionName' optionallayy prefixed with namespace
+    # @return [String] 'definitionName' possible prefixed with 'namespace'
     def namespacedReferenceName( definitionName )
       if namespace 
         definitionName = "#{namespace}.#{definitionName}"
@@ -287,7 +418,7 @@ module Sbuilder
     end
     
 
-  end # class ApiLoader
+  end # class ApiLoaderFacade
 
 
 end # module

data/lib/sbuilder/facade/api_loader_plugin.rb

@@ -9,47 +9,21 @@ module Sbuilder
   # - configure plugin  
   #
   
-  class ApiLoaderPlugin
+  class ApiLoaderPlugin < LoaderPluginRoot
 
-    
-    include Sbuilder::Utils::MyLogger    # mix logger
+    # mix api loader plugin services
+    include ApiLoaderPluginMixer
 
     # ------------------------------------------------------------------
     # @!group Constructor and Object Initialize
 
-    def initialize( factory, options = {} )
-    end
-
-    # Sbuilder controller calls 'setFacade' when new API loader object
-    # is contstructed. Sets instance variable '@facade' and '@logger'.
-    #
-    # @param [Sbuilder::ApiLoader] facace to Sbuilder  services
-    
-    def setFacade( facade )
-      @facade = facade
-      @logger = facade.createLogger( self.class.name.split('::').last )
+    def initialize( options = {} )
+      super
     end
 
-
-    # @!endgroup
-
-    # ------------------------------------------------------------------
-    # @!group Framework Services
-
-    # @return [Sbuilder::ApiLoader] facade to access Sbuilder servivices ( set in 'setFacade')
-    def facade
-      @facade
-    end
-    
-    # @return [Logger] logger logging to Sbuiler log
-    def logger
-      # return STDERR logger - if logger not yet ready
-      Logger.new( STDERR ) unless @logger
-      @logger
-    end
     
     # ------------------------------------------------------------------
-    # @!group Configure services - MUST be implement by  plugin class
+    # @!group Configure Plugin
 
     # Configure API loader - MUST be implemented by plugin class
     # @param configuration [Hash] properties to configure

data/lib/sbuilder/facade/api_loader_plugin_mixer.rb

@@ -0,0 +1,35 @@
+module Sbuilder
+
+  # mixer module to include to API loader plugins
+  #
+  # Implement:
+  # - getter & setter for API loader facade
+  
+  module ApiLoaderPluginMixer
+
+    # Sbuilder controller calls 'setFacade' when new API loader object
+    # is contstructed. 
+    #
+    # @param [Sbuilder::ApiLoaderFacade] facace to Sbuilder  services
+    
+    def setFacade( facade )
+      @facade = facade
+      # @logger = facade.createLogger( self.class.name.split('::').last )
+    end
+
+
+    # @!endgroup
+
+    # ------------------------------------------------------------------
+    # @!group Framework Services
+
+    # @return [Sbuilder::ApiLoaderFacade] facade to access Sbuilder servivices ( set in 'setFacade')
+    def facade
+      @facade
+    end
+    
+    
+  end
+
+
+end