tla-sbuilder 0.1.0 → 0.2.1

data/lib/sbuilder/factory.rb

@@ -41,14 +41,22 @@ module Sbuilder
         Sbuilder::Constants::PARAMETER_REF => Parameter_Ref,
       }
       @paramSets = {
-        Sbuilder::Constants::SWAGGER => ParamSet_If,
+        Sbuilder::Constants::INTERFACE_OPERATION => ParamSet_If,
         Sbuilder::Constants::SWAGGER_DEFINITION => ParamSetDef,
         Sbuilder::Constants::PARAM_SET_STEPS => ParamSetStep,
       }
       
       @paramSetLoaders = {
-        Sbuilder::Constants::SWAGGER => ParamSetLoaderSwagger
+        # Sbuilder::Constants::LOADER_SWAGGER => ParamSetLoaderSwagger
       }
+      
+      # swagger loader loaded as an extension
+      addLoaders( [
+                    { 'gem' => 'sbuilder/param_set_loader_swagger',
+                      'className' => 'Sbuilder::ParamSetLoaderSwagger',
+                      'configuration' => nil,
+                    }
+                  ], [ Sbuilder::Constants::LOADER_SWAGGER] )
       @mapperLoaders = {
         Sbuilder::Constants::MAPPER_YAML => ResolverLoader_YAML
       }
@@ -64,6 +72,40 @@ module Sbuilder
       }
       
     end
+
+    # Configure additional loaders
+    #
+    # @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'] )
+        
+        # load class module to context - if className
+        require loader['gem'] unless Class.const_defined?( loader['className'] )
+
+        begin
+          @logger.info "#{__method__} loader['className']=#{loader['className']}"
+          klass = Object.const_get( loader['className'] )
+        rescue Exception => e
+          msg = <<-EOS
+          Unknown class: #{loader['className']}, #{e.message}
+
+          On loader extension #{loader}
+          EOS
+          @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
+        
+      end
+    end
     
     # ------------------------------------------------------------------
     # singleton 
@@ -98,6 +140,13 @@ 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 )
+      facade.setController( controller )
+      return facade
+    end
+
 
     # return object to load parameter sets
     def getParamSetLoader( type )
@@ -111,7 +160,7 @@ module Sbuilder
         @logger.error( "#{__method__} #{msg}" )
         raise NameError.new( msg  ) 
       end
-      return paramSetLoaders[type].new( Factory.getFactory(options), options )
+      return paramSetLoaders[type].new( options )
     end
     
     # ------------------------------------------------------------------
@@ -227,6 +276,20 @@ module Sbuilder
       end
       parameters[type].new( options )
     end
+
+    # ------------------------------------------------------------------
+    # validate 'defintionHash' all 'required'/only 'allowed' props set
+    private def validateProperties( defintionHash, required, allowed=[] )
+
+      allowed = allowed + required
+      
+      missingProps = required - defintionHash.keys
+      raise FactoryException,  "Missing properties #{missingProps} in #{defintionHash} - required #{required}" if missingProps.any?
+
+      invalidProps = defintionHash.keys - allowed 
+      raise FactoryException,  "Unknown properties #{invalidProps} in #{defintionHash} - allowed #{allowed}" if invalidProps.any?
+
+    end
     
 
   end # class Factory

data/lib/sbuilder/model.rb

@@ -10,6 +10,9 @@ module Sbuilder
     attr_reader   :steps                      # array of paramSetSteps
     attr_reader   :possibility                # [String] of setup possibility - may be nil
     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'    
 
     # ------------------------------------------------------------------
     # mixer
@@ -34,12 +37,25 @@ module Sbuilder
       @interfaces = {}
       @steps = []
       @possibility = nil
+      @setupDef = nil
       @possibilities = []
-      
+      @invariants = []
+      @assumptions = []      
       @interfaceExtensions = {}
       
 
     end
+    
+    # ------------------------------------------------------------------
+    # invariants + assumptions
+    
+    def addInvariant( invariant )
+      @invariants.push( invariant )
+    end
+
+    def addAssumption( assumption )
+      @assumptions.push( assumption )
+    end
 
     # ------------------------------------------------------------------
     # possibility stuff
@@ -53,6 +69,30 @@ module Sbuilder
       @logger.info( "#{__method__} @possibilities=#{@possibilities}" )
     end
 
+    # ------------------------------------------------------------------
+    # setup
+
+    # setter for setup configuration, called for each setup
+    def defineSetup( setupDef )
+      @logger.info "#{__method__} setupDef=#{setupDef}"
+      @setupDef = setupDef
+    end
+
+    # In order to prevent error 'Attempted to construct a set with too
+    # many elements' we allow setup to define cardinalities without
+    # nil. When default cardinality is one and this results to fixed
+    # domain ranges.
+    #
+    # @return [Boolean] true/false depeding whether setup should output nil_values
+    def setup_nil_values
+      ret = setupDef && setupDef.key?('configuration') && setupDef['configuration'].key?('allow_domain_nil_values')  ?
+              setupDef['configuration']['allow_domain_nil_values'] :
+              true 
+                                                                                      
+      return ret
+    end
+    
+
     # ------------------------------------------------------------------
     # domain stuff
     
@@ -128,7 +168,7 @@ module Sbuilder
     # interface stuff
 
     # accept parameters set to model
-    def interfaceEncountered( paramSet )
+    def modelInterface( paramSet )
       @interfaces[paramSet.getId] = paramSet
       
       # # collect all paramsets
@@ -198,7 +238,7 @@ module Sbuilder
     # ------------------------------------------------------------------
     # definition stuff
             
-    def definitionEncountered( paramSet )
+    def modelDefinition( paramSet )
       @logger.info( "#{__method__} paramSet=#{paramSet}, paramSet.class=#{paramSet.class}" )
 
       # collect definitions
@@ -238,7 +278,12 @@ module Sbuilder
 
       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 'infrastructureServices'
         templateDataInterfaces( domainName, true )
       when 'possibility'        
@@ -275,6 +320,16 @@ module Sbuilder
       when 'none'
         {
         }
+      when 'invariants'
+        hash = {
+          "dump"        => lambda { hash['invariants'].to_yaml },          
+          "invariants" => invariants,
+        }
+      when 'assumptions'
+        hash = {
+          "dump"        => lambda { hash['assumptions'].to_yaml },          
+          "assumptions" => assumptions,
+        }
       when 'definitions'
         hash = {
           "dump"        => lambda { hash['definitions'].to_yaml },          
@@ -294,6 +349,7 @@ module Sbuilder
           "domains"     => domains.values.map do |domain|
             {
               :domain_name => domain.domain_name,
+              :nil_value => setup_nil_values,
               :domain_values => domain.domain_values,
             }
           end,                                      # => TLA domain

data/lib/sbuilder/mustache/template.rb

@@ -65,22 +65,22 @@ module Sbuilder
     def partial(name)
       @logger.debug( "#{__method__} name=#{name}" )
 
-      return resolve_partial_direct(name[2..-1])  if name[0..1]  == '!!'
+      # 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
+    # #
+    # # @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
     def resolve_partial_name( name )

data/lib/sbuilder/mustache/template_reader_context.rb

@@ -34,7 +34,9 @@ module Sbuilder
                                         # [String:Array] names of
                                         # possiblity operators defined
                                         # for current setup
-    
+
+                   :getModelInvariants, # [String:Array] of invariant names for the model
+                   :getSetupAssumes,    # [String:Array] of assume names for the setup
                    :isOptFilterSrc,     # [Boolean] true when
                                         # filtering
                    :output,             # (level,msg) to output
@@ -53,7 +55,7 @@ module Sbuilder
 
     # Sbuilder constant symbols
     SBUILDER = %w( Nil InfrastructureServiceReturn InfrastructureServiceGetStatus 
-    InfrastructureServiceGetResponse)
+    InfrastructureServiceGetResponse InTransaction)
 
     # these directories not unmustached
     DOC_DIRS= [ "docs", "doc" ]
@@ -334,7 +336,7 @@ module Sbuilder
     def whitelist_resolved
       rslv = resolver
       output( 1, "Resolving symbols - start" )
-      entrypoints = getEntryPoints + getSetupPossibilities
+      entrypoints = getEntryPoints + getSetupPossibilities + getModelInvariants + getSetupAssumes
       @logger.debug("#{__method__}: entrypoints=#{entrypoints}")
       ret =  rslv.resolveModules( entrypoints  ) do |type,arr|
         case type

data/lib/sbuilder/param_set.rb

@@ -15,7 +15,7 @@ module Sbuilder
     # constrcutore
     def initialize( options = {} )
       @logger = getLogger( PROGNAME, options )
-      @logger.info( "#{__method__} initialized" )
+      @logger.debug( "#{__method__} initialized" )
       @parameters = []
     end
 
@@ -93,6 +93,7 @@ module Sbuilder
               gsub( /\(/, "_" ).   # ( --> _
               gsub( /\{/, "_" ).   # { --> _
               gsub( /\}/, "_" ).   # } --> _
+              gsub( /\./, "_" ).   # . --> _              
               gsub( /\)/, "_" )    # ) --> _
       
     end

data/lib/sbuilder/param_set_db.rb

@@ -12,7 +12,7 @@ module Sbuilder
     # constrcutore
     def initialize( options = {} )
       @logger = getLogger( PROGNAME, options )
-      @logger.info( "#{__method__} initialized" )
+      @logger.debug( "#{__method__} initialized" )
     end
 
   end

data/lib/sbuilder/param_set_def.rb

@@ -18,7 +18,7 @@ module Sbuilder
     def initialize( options = {} )
       super( options )
       @logger = getLogger( PROGNAME, options )
-      @logger.info( "#{__method__} initialized" )
+      @logger.debug( "#{__method__} initialized" )
       
       # default is not an arrays
       @isArray = false

data/lib/sbuilder/param_set_if.rb

@@ -19,7 +19,7 @@ module Sbuilder
     def initialize( options = {} )
       super( options )
       @logger = getLogger( PROGNAME, options )
-      @logger.info( "#{__method__} initialized" )
+      @logger.debug( "#{__method__} initialized" )
       @response = nil
       @infrastructureService = false
     end

data/lib/sbuilder/param_set_loader_swagger.rb

@@ -9,9 +9,10 @@ module Sbuilder
 
   
 
-  class ParamSetLoaderSwagger < ParamSetLoader
+  class ParamSetLoaderSwagger
 
-    attr_reader :infrastructureServices  # default 'false'
+    attr_reader :facade                  # [Sbuilder::ParamSetLoader]
+                                         # facade to Sbuilder
 
     # ------------------------------------------------------------------
     # mixer
@@ -20,39 +21,74 @@ module Sbuilder
 
     # ------------------------------------------------------------------
     # constrcutore
-    def initialize( factory, options = {} )
-      super( factory, options )
-      @logger = getLogger( PROGNAME, options )
-      @logger.info( "#{__method__} initialized" )
+    def initialize( options = {} )
+      # @logger = getLogger( PROGNAME, options )
+      # @logger.info( "#{__method__} initialized" )
 
-      # properties
-      @infrastructureServices = false
+      @facade = nil
       
     end
 
-    # extract 'intfractureServices' property from 'paramsetLoaderDef'
+    # Facade gets injected, and used immediately to create logger
+    # object.
     #
-    # @param paramsetLoaderDef [Hash] configuration in 'sbuilder.yaml'
+    # @param [Sbuilder::ApiLoader] facace to Sbuilder  services
     #
-    def doConfigure( paramsetLoaderDef )
-      @infrastructureServices = true if paramsetLoaderDef['infrastructureServices']
+    def setFacade( facade )
+      @facade = facade
+      # 
+      @logger = facade.createLogger( PROGNAME )
+    end
+
+    # ------------------------------------------------------------------
+    # class method configure
+
+    # @param configuration [Hash] properties to configure
+    def self.configure( configuration )
     end
     
 
+    # # extract 'intfractureServices' property from 'paramsetLoaderDef'
+    # #
+    # # @param paramsetLoaderDef [Hash] configuration in 'sbuilder.yaml'
+    # #
+    # def doConfigure( paramsetLoaderDef )
+    #   @infrastructureServices = true if paramsetLoaderDef['infrastructureServices']
+    # end
+
+    # @param yamlFileUri [String] path or url to YAML file to process
+    def readLines( yamlFileUri )
+      yaml_lines = facade.read_cached( yamlFileUri )
+      return yaml_lines
+    end
+
     # implements abstract super class method validates, loads
     # interfaces and definitions in YAML parsed from 'yamlFileUri'
     
     # @param yamlFileUri [String] path or url to YAML file to process
     
-    def doLoad( yamlFileUri, cacheFile=nil )
+    def load( yamlFileUri )
       @logger.info( "#{__method__} yamlFileUri=#{yamlFileUri}" )
-      # swagger_hash = YAML.load_file( yamlFileUri )
-      yaml_lines = Sbuilder::Utils::NetIo.read_lines_cached( yamlFileUri, cacheFile )
-      # puts yaml_lines
-      # puts "yamlFileUri=#{yamlFileUri}"
-      swagger_hash = YAML.load( yaml_lines )
+
+      begin
+
+        # use facade services to read lines in 
+        yaml_lines = readLines( yamlFileUri )
+        
+        # YAML parse & schema validation
+        
+        swagger_hash = YAML.load( yaml_lines )
+      rescue Exception => e
+        msg = <<-EOS.gsub( /^\s*/, '' )
+        Error #{e.message}  when loading '#{yamlFileUri}'
+        EOS
+        raise Sbuilder::LoaderException.new, msg, e.backtrace
+        
+      end
 
       validate( swagger_hash )
+
+      # and extract interfaces && definitions
       doLoadInterfaces( swagger_hash )
       doLoadDefinitions( swagger_hash )
 
@@ -61,35 +97,33 @@ module Sbuilder
     # ==================================================================
     # entry points
 
-    # calls '@controller.definitionEncountered' for each parameter set
+    # calls '@controller.modelDefinition' for each parameter set
     # found in swagger configuration
     # @param swagger_hash [swagger 2.0]
     
     def doLoadDefinitions( swagger_hash )
-      paramsSets = swaggerDefinitionParamsets( swagger_hash )
+      paramsSets = parseDefinitions( swagger_hash )
       paramsSets.each do |paramSet|
-        controller.definitionEncountered( paramSet )
+        facade.modelDefinition( paramSet )
       end
       
     end
 
-    # calls '@controller.interfaceEncountered' for each parameter set
+    # calls '@facade.modelInterface' for each parameter set
     # found in swagger configuration
     #
     # @param swagger_hash [swagger 2.0] 
     
     def doLoadInterfaces( swagger_hash )
 
-      interface_paramsSets = swaggerPathInterfaces( swagger_hash )
+      interface_paramsSets = parseInterfaces( swagger_hash )
       @logger.info( "#{__method__} loaded=#{interface_paramsSets.length} interface_paramsSets" )      
-      
+
       interface_paramsSets.each do |interface|
-        controller.interfaceEncountered( interface )
+        facade.modelInterface( interface )
       end
-
     end
 
-    # entry poinsts
     # ==================================================================    
 
     # Validates this object against the Swagger specification and
@@ -120,23 +154,30 @@ module Sbuilder
     private
 
     # ------------------------------------------------------------------
-    # iterate defitions
-    def swaggerDefinitionParamsets( swagger_hash )
-      paramSets = []
+    # parse defitions from swagger_hash['definitions']
+    #
+    # @param swagger_hash [Hash] definitions in property 'definitions'
+    #
+    # @return [Sbuilder::ParamSetDef:Array] of parsed definitions
+    
+    def parseDefinitions( swagger_hash )
+      definitions = []
       swagger_hash['definitions'] && swagger_hash['definitions'].each do |defineKey,definedDoc|
-        # puts "defineKey=#{defineKey} -> #{definedDoc}"
-
+        
         # create set && configure param set for a defintion
-        paramSet =  createParamSet( Sbuilder::Constants::SWAGGER_DEFINITION )
-        paramSet.setDefinition( defineKey )
-        paramSet.setIsArray if definedDoc['type']  == 'array'
-        paramSets << paramSet 
+        paramSet = facade.newDefinition( defineKey, definedDoc['type']  == 'array' )
+        
+        # collect
+        definitions << paramSet 
 
+        # defines reference
         if hasRef( definedDoc ) then
           # case paramter set is a wrapper - most likely an array
           reference_parameter( paramSet, defineKey, getRefDocumentName( definedDoc ), definedDoc['type'] )
+          
         else
 
+          # defines onw attributes
           expandedDocs = expand_definedDocs( definedDoc, swagger_hash )
           # puts "    defineKey=#{defineKey} --> expandedDocs=#{expandedDocs}"
 
@@ -156,52 +197,46 @@ module Sbuilder
         
       end # each definitions
 
-      return paramSets
+      return definitions
     end
 
     # ------------------------------------------------------------------
-    # iterate interface  ['path'][<operation>]['paramters'] 
-
-    def swaggerPathInterfaces( swagger_hash )
+    # parse interface from  ['path'][<operation>]['paramters'] 
+    # @return [Sbuilder::ParamSet_If:Array] of parsed interfaces
+    #
+    def parseInterfaces( swagger_hash )
       
       @logger.info( "#{__method__} starting" )
 
       # collect all interface paramsets together
-      paramSets = []
+      interfaces = []
 
       # interfaces are hashes under 'paths'/<path>/<op>
       swagger_hash['paths'].each do |path,ops|
+        
         ops.each do |op,opdef|
           
-          # Create new paramSet, configugre its identity
-          interfaceParamSet =  createParamSet( Sbuilder::Constants::SWAGGER )
-          interfaceParamSet.setIdentity( path, op )
-          interfaceParamSet.setInfrastructureService( infrastructureServices )
+          # New interface operation '/path(op) & access response  operation
+          interfaceParamSet = facade.newInterface( path, op )
+          paramSetResponse  = interfaceParamSet.response
+          
           @logger.info( "#{__method__} created interfaceParamSet=#{interfaceParamSet.getId}" )
           @logger.debug( "#{__method__} created interfaceParamSet.getId=#{interfaceParamSet.getId}, opdef=#{opdef}" )
 
-          # add to array we are going to return
-          paramSets << interfaceParamSet
+          # collect
+          interfaces << interfaceParamSet
 
           # ---------------------------------
           # input paramters: 'paths'/<path>/<op>/'parameters'
 
-          # collect paramters to an array
-          # parameters = []
           opdef['parameters'] && opdef['parameters'].map do |parameter|
             @logger.debug( "#{__method__} path/op #{path}/#{op} - parameter #{parameter}" )            
             if parameter['schema'] then
               # in='body' => schema defined
               defintionReferenceName =  getReferencedDefinitionName( parameter['schema'], swagger_hash )
               reference_parameter( interfaceParamSet, parameter['name'], defintionReferenceName )
-              # parameters = parameters + 
-              #   #            expand_reference_object( parameter['schema'], swagger_hash ).map do |schema|
-                # [ parameter['name'], schema ] 
-            #end
             elsif parameter['name']
               simple_parameter( interfaceParamSet, parameter['name'], parameter['type'] ) if parameter['name']
-              # parameter object normal i.e. not in='body' object
-              # parameters << parameter2ParamObject( parameter )
             else
               msg = "Empty parameter definition on #{path}/#{op} "
               @logger.error( "#{__method__} #{msg}" )
@@ -212,13 +247,6 @@ module Sbuilder
 
           # ------------------------------
           # responses: 'paths'/<path>/<op>/'responses'
-          
-          paramSetResponse =  createParamSet( Sbuilder::Constants::SWAGGER )
-          paramSetResponse.setIdentity( path, 'response' )
-
-          # response response to an interface
-          interfaceParamSet.setResponse( paramSetResponse )
-          
 
           opdef['responses'] && opdef['responses'].each_pair do |status_code,response|
             # puts "op=#{op}, status_code=#{status_code}, response=#{response}"
@@ -230,20 +258,45 @@ module Sbuilder
 
             else
               @logger.debug( "#{path}-#{op}-#{status_code}: no response data for response #{response}" )
-          #     # response object
+              # response object
             end
-          end # opdef['responses'].each
-
+          end # responses
           
         end # each 'paths'
+        
       end
+      return interfaces
+    end
+
+    # ------------------------------------------------------------------
+    # Create parameters && add to param set
+
+    # process simple (i.e. non body ) parameter
+    def simple_parameter( paramSet, name, parameterType )
       
-      return paramSets
+      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" )
+      
+      swagger_parameter = facade.newParameterReference( name, defintionReferenceName, parameterType == 'array' )
+      
+      @logger.info( "#{__method__} param set =#{paramSet.getId}, parameter=#{swagger_parameter.getName}, parameter=#{swagger_parameter.reference}" )
+
+      # add to parameter set
+      paramSet.addParameter( swagger_parameter )
+
     end
-    
 
+    
+    # ------------------------------------------------------------------
+    # Extract data from swagger properties
 
-    # return the name of definition referenced in 'paramOrRespSchema'
+    
+    # @return [String] name of definition referenced in 'paramOrRespSchema'
     def getReferencedDefinitionName( paramOrRespSchema, swagger_hash )
 
       # e.g. '#/definitions/doc
@@ -319,7 +372,6 @@ module Sbuilder
 
     def getRefDocumentName( paramOrRespSchema )
 
-
       # --> /definitions/doc  
       ref = getRef( paramOrRespSchema )
 
@@ -343,7 +395,6 @@ module Sbuilder
     def getDefinitionDoc( ref, swagger_hash )
       @logger.info( "#{__method__} ref=#{ref}" )
 
-      
       # currently supports only local references
       raise "Not valid local ref #{ref} in #{schemaObject}" unless valid_local_ref( ref )
 
@@ -363,62 +414,12 @@ module Sbuilder
     end
 
 
-
-    # # process one pameter in swagger inferface
-    # def set_paramter_swagger( swagger_hash, paramSet, paramDef )
-    #   @logger.debug( "#{__method__} paramSet=#{paramSet}, paramDef=#{paramDef}" )
-
-    #   name = getProp( 'name', paramDef )
-    #   inType = getProp( 'in', paramDef )
-
-    #   if inType == 'body' then
-    #     schema_parameter( paramSet, paramDef, swagger_hash )
-    #   else
-    #     simple_parameter( paramSet, name )
-    #   end
-      
-    # end
-
-    # process simple (i.e. non body ) parameter
-    def simple_parameter( paramSet, name, parameterType )
-      
-      # create parameter object && configure it
-      swagger_parameter = createParameter( Sbuilder::Constants::PARAMETER  )
-      swagger_parameter.setName( name )
-
-      # default for parameter 'not array' - set exlicitely array
-      swagger_parameter.setIsArray if parameterType == 'array'
-      
-      @logger.info( "#{__method__} param set =#{paramSet.getId}, parameter name=#{swagger_parameter.getName}" )
-
-      # add to parameter set
-      paramSet.addParameter( swagger_parameter )
-
-    end
-
-    # process simple (i.e. non body ) parameter
-    def reference_parameter( paramSet, name, defintionReferenceName, parameterType="string" )
-      
-      # create parameter object && configure it
-      swagger_parameter = createParameter( Sbuilder::Constants::PARAMETER_REF  )
-      swagger_parameter.setName( name )      
-      swagger_parameter.setReference( defintionReferenceName )
-      swagger_parameter.setIsArray if parameterType == 'array'
-      
-      @logger.info( "#{__method__} param set =#{paramSet.getId}, parameter=#{swagger_parameter.getName}, parameter=#{swagger_parameter.reference}" )
-
-      # add to parameter set
-      paramSet.addParameter( swagger_parameter )
-
-    end
-    
-
+    # @return [Boolean] true if starts with hash '#' -character
     def valid_local_ref(ref)
       ref.match(%r{\A#\/})
     end
 
     
-    
   end # class ResolverLoaderSwagger << ResolverLoader
 
 end # module Sbuilder