tla-sbuilder 0.1.0

data/lib/sbuilder/param_set.rb

@@ -0,0 +1,132 @@
+
+module Sbuilder
+
+  class ParamSet
+
+    attr_reader :parameters                   # array of parameters:Parameter
+
+    # ------------------------------------------------------------------
+    # mixer
+    PROGNAME = "ParamSet"                     # progname for logger
+    include Sbuilder::Utils::MyLogger         # mix logger
+
+
+    # ------------------------------------------------------------------
+    # constrcutore
+    def initialize( options = {} )
+      @logger = getLogger( PROGNAME, options )
+      @logger.info( "#{__method__} initialized" )
+      @parameters = []
+    end
+
+    def to_s
+      "#{getId}"
+    end
+
+    # normally resolve 'parameter' sub-classes may override
+    def parametersToResolve
+      parameters
+    end
+
+    # ------------------------------------------------------------------
+    # builder
+    def addParameter( param )
+      parameters << param
+      self
+    end
+
+    # ------------------------------------------------------------------
+    # identifier for finding domain matche
+    
+    def matchesWithParamSet( matcher )
+      matcher.is_a?( String ) ? getId == matcher  : (getId =~ matcher) != nil
+    end
+
+    def getId
+      doGetId
+    end
+    
+
+    def doGetId
+      msg = "Sub class should implement doGetId -method"
+      @logger.error( "#{__method__} #{msg}" )        
+      raise NoMethodError.new( msg  )
+    end
+
+    # ------------------------------------------------------------------
+    # generata phase
+
+    
+    # return hash for generation phase, false if no paramteers
+    def parameter_definitions( model )
+      arra = parameters.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
+        # {
+        #   :name           => p.name,
+        #   :parameter_name => ParamSet.cleanUpName( p.name ),
+        #   :type           => p.getType,
+        #   :
+        # }
+      end
+      # return false if no parameter
+      return false if arra.length == 0
+      return arra
+    end
+
+    # make it valid identifier 
+    def self.cleanUpName( name )
+      return name ?
+               name.gsub( /\./, "_" ) :    # . --> _
+               name
+    end
+
+    # getId with invalid-caharacters as underscpce
+    def getName
+      return getId.
+              gsub( /\//, "_" ).   # / --> _
+              gsub( /\(/, "_" ).   # ( --> _
+              gsub( /\{/, "_" ).   # { --> _
+              gsub( /\}/, "_" ).   # } --> _
+              gsub( /\)/, "_" )    # ) --> _
+      
+    end
+
+    # ------------------------------------------------------------------
+    # locateParameter
+
+    # Locate parameter 'key', raise on an error if not found
+    def locateParameter( key )
+      key = key.first if key.is_a?( Array )
+      @logger.debug( "#{__method__} key=#{key}" )
+
+
+      # locate key in this paramter set
+      # puts "parameters=#{parameters}"
+      found = parameters.select do |parameter|
+        # puts "parameter.name #{parameter.name} == key = #{key}"
+        parameter.name == key
+      end.first
+      @logger.debug( "#{__method__} key=#{key} --> found='#{found}' found.class=#{found.class}" )
+      raise <<-EOS if found.nil?
+
+      Could not locate parameter '#{key}' in parameter set '#{getId}'
+
+      Valid names in parameter set '#{getId}':  #{parameters.map {|parameter| parameter.name}.join(',')}
+
+      EOS
+      
+      return found
+
+    end
+
+   
+    
+  end # class
+  
+end

data/lib/sbuilder/param_set_db.rb

@@ -0,0 +1,20 @@
+
+module Sbuilder
+
+  class ParamSet_Db < ParamSet
+
+    # ------------------------------------------------------------------
+    # mixer
+    PROGNAME = "ParamSet_Db"                   # progname for logger
+    include Sbuilder::Utils::MyLogger         # mix logger
+
+    # ------------------------------------------------------------------
+    # constrcutore
+    def initialize( options = {} )
+      @logger = getLogger( PROGNAME, options )
+      @logger.info( "#{__method__} initialized" )
+    end
+
+  end
+  
+end

data/lib/sbuilder/param_set_def.rb

@@ -0,0 +1,57 @@
+
+module Sbuilder
+
+  # interface paramter set (identified by path+operations)
+  class ParamSetDef < ParamSet
+
+    attr_reader  :isArray                     # defaults 'false'
+    attr_reader :definition                     # REST path
+    
+
+    # ------------------------------------------------------------------
+    # mixer
+    PROGNAME = "ParamSet_Def"                  # progname for logger
+    include Sbuilder::Utils::MyLogger         # mix logger
+
+    # ------------------------------------------------------------------
+    # constrcutore
+    def initialize( options = {} )
+      super( options )
+      @logger = getLogger( PROGNAME, options )
+      @logger.info( "#{__method__} initialized" )
+      
+      # default is not an arrays
+      @isArray = false
+    end
+    
+
+    # ------------------------------------------------------------------
+    # setIdentity
+
+    # set configure
+    def setDefinition( definition )
+      @definition = definition
+      self
+    end
+
+    # ------------------------------------------------------------------
+    # implentation
+
+    # return identity
+    def doGetId
+      "#{definition}"
+    end
+
+
+    # ------------------------------------------------------------------
+    # 
+    def setIsArray( isArray = true )
+      @isArray = isArray
+      self
+    end
+    
+    
+
+  end
+  
+end

data/lib/sbuilder/param_set_if.rb

@@ -0,0 +1,68 @@
+
+module Sbuilder
+
+  # interface paramter set (identified by path+operations)
+  class ParamSet_If < ParamSet
+
+    attr_reader :path                         # REST path
+    attr_reader :operation                    # REST path
+    attr_reader :response                     # returned from interface
+    attr_reader :infrastructureService        # default 'false'
+
+    # ------------------------------------------------------------------
+    # mixer
+    PROGNAME = "ParamSet_If"                  # progname for logger
+    include Sbuilder::Utils::MyLogger         # mix logger
+
+    # ------------------------------------------------------------------
+    # constrcutore
+    def initialize( options = {} )
+      super( options )
+      @logger = getLogger( PROGNAME, options )
+      @logger.info( "#{__method__} initialized" )
+      @response = nil
+      @infrastructureService = false
+    end
+
+    # # normally resolve 'parameter', however in my case resolve also responses
+    # def parametersToResolve
+    #   return parameters + ( @response ? @response.parameters : [])
+    # end
+    
+
+    # ------------------------------------------------------------------
+    # configure
+
+    # def addResponse( response )
+    #   @responses << response
+    #   self
+    # end
+
+    def setResponse( response )
+      @response =  response
+      self
+    end
+
+    def setInfrastructureService( infrastructureService )
+      @infrastructureService = infrastructureService
+      self
+    end
+
+    # ------------------------------------------------------------------
+    # setIdentity
+
+    # set identity
+    def setIdentity( path, operation )
+      @path = path
+      @operation = operation
+      self
+    end
+
+    # return identity
+    def doGetId
+      "#{path}(#{operation})"
+    end
+
+  end
+  
+end

data/lib/sbuilder/param_set_loader.rb

@@ -0,0 +1,77 @@
+
+module Sbuilder
+
+  class ParamSetLoader
+
+    attr_reader :factory                      # to create stuff
+    attr_accessor :controller                 # get sets when load starts
+
+    # ------------------------------------------------------------------
+    # mixer
+    PROGNAME = "ParamSetLoader"               # progname for logger
+    include Sbuilder::Utils::MyLogger         # mix logger
+
+
+    # ------------------------------------------------------------------
+    # constructore
+    
+    def initialize( factory, options = {} )
+      @logger = getLogger( PROGNAME, options )
+      @logger.info( "#{__method__} initialized" )
+      @factory = factory
+    end
+
+    # @param loaderDef [Hash] adding configuration for loader (override)
+    def configure( loaderDef )
+      doConfigure( loaderDef )
+    end
+    
+    def doConfigure( loaderDef )
+      msg = "Sub class should implement doConfigure -method"
+      @logger.error( "#{__method__} #{msg}" )        
+      raise NoMethodError.new( msg  )
+    end
+    
+    # ------------------------------------------------------------------
+    # load paramset from 'fileUri' 
+    def load( controller, fileUri, cacheFile=nil )
+      # controller which control loading
+      @controller = controller
+      
+      begin
+        loaded = doLoad( fileUri, cacheFile )
+      rescue Exception => e
+        msg = "Exception '#{e}' when loading fileUri '#{fileUri}'"
+        @logger.error( "#{__method__} #{msg}" )
+        puts msg
+        raise e
+      end
+
+      # # iterate && report to controller
+      # loaded.each do |paramSet|
+      #   controller.interfaceEncountered( paramSet )
+      # end
+    end
+
+    def createParamSet( type )
+      factory.createParamSet( type )
+    end
+
+    def createParameter( type )
+      factory.createParameter( type )
+    end
+    
+
+    # ------------------------------------------------------------------
+    # sub-class should implement the doload method
+    def doLoad( fileUri, cacheFile=nil )
+      msg = "Sub class should implement doLoad -method"
+      @logger.error( "#{__method__} #{msg}" )        
+      raise NoMethodError.new( msg  )
+    end
+    
+
+  end # class ParamSetLoader
+
+
+end # module

data/lib/sbuilder/param_set_loader_swagger.rb

@@ -0,0 +1,424 @@
+# coding: utf-8
+require 'yaml'
+require 'json'
+require 'hashie'
+
+require 'json-schema'
+
+module Sbuilder
+
+  
+
+  class ParamSetLoaderSwagger < ParamSetLoader
+
+    attr_reader :infrastructureServices  # default 'false'
+
+    # ------------------------------------------------------------------
+    # mixer
+    PROGNAME = "LoadSwagger"                  # progname for logger
+    include Sbuilder::Utils::MyLogger         # mix logger
+
+    # ------------------------------------------------------------------
+    # constrcutore
+    def initialize( factory, options = {} )
+      super( factory, options )
+      @logger = getLogger( PROGNAME, options )
+      @logger.info( "#{__method__} initialized" )
+
+      # properties
+      @infrastructureServices = false
+      
+    end
+
+    # extract 'intfractureServices' property from 'paramsetLoaderDef'
+    #
+    # @param paramsetLoaderDef [Hash] configuration in 'sbuilder.yaml'
+    #
+    def doConfigure( paramsetLoaderDef )
+      @infrastructureServices = true if paramsetLoaderDef['infrastructureServices']
+    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 )
+      @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 )
+
+      validate( swagger_hash )
+      doLoadInterfaces( swagger_hash )
+      doLoadDefinitions( swagger_hash )
+
+    end
+
+    # ==================================================================
+    # entry points
+
+    # calls '@controller.definitionEncountered' for each parameter set
+    # found in swagger configuration
+    # @param swagger_hash [swagger 2.0]
+    
+    def doLoadDefinitions( swagger_hash )
+      paramsSets = swaggerDefinitionParamsets( swagger_hash )
+      paramsSets.each do |paramSet|
+        controller.definitionEncountered( paramSet )
+      end
+      
+    end
+
+    # calls '@controller.interfaceEncountered' for each parameter set
+    # found in swagger configuration
+    #
+    # @param swagger_hash [swagger 2.0] 
+    
+    def doLoadInterfaces( swagger_hash )
+
+      interface_paramsSets = swaggerPathInterfaces( swagger_hash )
+      @logger.info( "#{__method__} loaded=#{interface_paramsSets.length} interface_paramsSets" )      
+      
+      interface_paramsSets.each do |interface|
+        controller.interfaceEncountered( interface )
+      end
+
+    end
+
+    # entry poinsts
+    # ==================================================================    
+
+    # Validates this object against the Swagger specification and
+    # returns the first detected error.  Faster than
+    # {#fully_validate}.
+    #
+    # @return [true] if the object fully complies with the Swagger specification.
+    # @raise [Swagger::InvalidDefinition] if an error is found.
+    def validate( json )
+      JSON::Validator.validate!(swagger_schema, json ) # 
+      # JSON::Validator.fully_validate(swagger_schema, json ) # 
+    rescue JSON::Schema::ValidationError => e
+      raise Sbuilder::LoaderException.new, e.message
+    end
+
+    
+    private def swagger_schema
+        @swagger_schema ||= JSON.parse(File.read(Sbuilder::Constants::SWAGGER_SCHEMA))
+        # FIXME: Swagger should be able to parse offline. Blocked by json-schema.
+        # Offline workaround
+        # @swagger_schema = JSON.parse(File.read(SWAGGER_SCHEMA)
+        #   .gsub('http://json-schema.org/draft-04/schema', "file://#{SWAGGER_SCHEMA}"))
+        # @swagger_schema['$schema'] = 'http://json-schema.org/draft-04/schema#'
+        # @swagger_schema
+    end
+
+
+    private
+
+    # ------------------------------------------------------------------
+    # iterate defitions
+    def swaggerDefinitionParamsets( swagger_hash )
+      paramSets = []
+      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 
+
+        if hasRef( definedDoc ) then
+          # case paramter set is a wrapper - most likely an array
+          reference_parameter( paramSet, defineKey, getRefDocumentName( definedDoc ), definedDoc['type'] )
+        else
+
+          expandedDocs = expand_definedDocs( definedDoc, swagger_hash )
+          # puts "    defineKey=#{defineKey} --> expandedDocs=#{expandedDocs}"
+
+          # iterate array of [ { <name> = { "type"=>.., <format> =>..}, <name> => ..}, ... ]
+          expandedDocs.each do |expandedDoc|
+            # puts "#----->{op}-expandedDoc->#{expandedDoc}"
+            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'] )                
+              else
+                simple_parameter( paramSet, parameterName, parameterProps['type'] )
+              end
+            end
+          end
+        end
+        
+      end # each definitions
+
+      return paramSets
+    end
+
+    # ------------------------------------------------------------------
+    # iterate interface  ['path'][<operation>]['paramters'] 
+
+    def swaggerPathInterfaces( swagger_hash )
+      
+      @logger.info( "#{__method__} starting" )
+
+      # collect all interface paramsets together
+      paramSets = []
+
+      # 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 )
+          @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
+
+          # ---------------------------------
+          # 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}" )
+              warn msg
+            end
+            
+          end # parameters
+
+          # ------------------------------
+          # 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}"
+            
+            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']  )
+
+            else
+              @logger.debug( "#{path}-#{op}-#{status_code}: no response data for response #{response}" )
+          #     # response object
+            end
+          end # opdef['responses'].each
+
+          
+        end # each 'paths'
+      end
+      
+      return paramSets
+    end
+    
+
+
+    # return the name of definition referenced in 'paramOrRespSchema'
+    def getReferencedDefinitionName( paramOrRespSchema, swagger_hash )
+
+      # e.g. '#/definitions/doc
+      ref = getRef( paramOrRespSchema )
+
+      # e.g ['defintions', 'doc']
+      pathElements = getPathElementFromReference( ref )
+
+      # e.g. doc
+      definitionDocumentName = pathElements.last
+
+      # return the name
+      definitionDocumentName
+
+    end
+
+    # concat 'collectedReferences' with expanded '$ref' properties in 'definedDoc' with values in 'swagger_hash' 
+    def expand_definedDocs( definedDoc, swagger_hash )
+      
+      if  definedDoc['properties']
+        return [ definedDoc['properties'] ]
+      # collect documents in 'allOf'
+      elsif definedDoc['allOf'] then
+        allDocs = []
+        definedDoc['allOf'].each do |elemenDoc|
+          allDocs = allDocs + definedDocArr2ParamObject(expand_definedDocs( elemenDoc, swagger_hash ))
+        end
+        # puts "---> expand_definedDocs-1 = #{allDocs} for #{definedDoc}"
+        return allDocs
+      else
+        # check for references
+        definedDoc.extend Hashie::Extensions::DeepFind
+        refs = definedDoc.deep_find_all( "$ref" )
+
+        if refs.nil?
+          puts "---> expand_definedDocs-2 = #{[definedDoc]} for #{definedDoc}"
+          return definedDocArr2ParamObject([definedDoc])
+        end
+        # expand all referncnes
+        expandedDocs = []
+        refs.each do |ref|
+          referredDoc = getDefinitionDoc( ref, swagger_hash )
+          expandedDocs  = expandedDocs + definedDocArr2ParamObject(expand_definedDocs( referredDoc, swagger_hash ))
+        end
+
+        # puts "---> expand_definedDocs-3 = #{expandedDocs} for #{definedDoc}"        
+        return expandedDocs
+      end # else not allOf
+
+    end
+
+    # 'properties' holds paramObject { <name>=>{}, <name>=>{}, ...}
+    def definedDocArr2ParamObject( definedDocArr )
+      definedDocArr.map { |e| e['properties'] ? e['properties'] : e }
+    end
+
+    # parameter hash {name: <name>, type:...} paramObject { <name>=>{}, <name>=>{}, ...}
+    def parameter2ParamObject( parameter )
+      return { parameter['name'] =>
+               {
+                 "type" =>  parameter['type'],
+                 "format" =>  parameter['format'],
+               } }
+    end
+
+
+    # get $ref from '$ref' or 'item.$ref'
+    def getRef( paramOrRespSchema )
+      return paramOrRespSchema['$ref'] if paramOrRespSchema['$ref']
+      return paramOrRespSchema['items']['$ref'] if paramOrRespSchema['items'] && paramOrRespSchema['items']['$ref']
+      raise "No ref found in #{paramOrRespSchema}"
+    end
+
+    def getRefDocumentName( paramOrRespSchema )
+
+
+      # --> /definitions/doc  
+      ref = getRef( paramOrRespSchema )
+
+      # --> ['definitions', 'doc']
+      arrOfElement = getPathElementFromReference( ref )
+
+      # doc  
+      arrOfElement.last
+      
+    end
+
+    def hasRef( paramOrRespSchema )
+      return true if  paramOrRespSchema['$ref']
+      return true if paramOrRespSchema['items'] && paramOrRespSchema['items']['$ref']
+      return false
+    end
+    
+
+
+    # get document pointed by 'ref' in 'swagger_hash'
+    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 )
+
+      # '#/definitions/doc  --> ['definitions', 'doc']
+      pathElements = getPathElementFromReference( ref )
+      
+      # puts "pathElements=#{pathElements} for ref=#{ref} in #{refs}"
+      defininedDoc = swagger_hash.traverse( *pathElements )
+      @logger.debug( "#{__method__} ref=#{ref} --> defininedDoc=#{defininedDoc}" )
+      raise "Could not resolve definition reference '#{ref}'" if defininedDoc.nil?
+      defininedDoc
+    end
+
+    # '#/definitions/doc  --> ['definitions', 'doc']    
+    def getPathElementFromReference( ref )
+      pathElements = ref[2..-1].split( '/' )
+    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
+    
+
+    def valid_local_ref(ref)
+      ref.match(%r{\A#\/})
+    end
+
+    
+    
+  end # class ResolverLoaderSwagger << ResolverLoader
+
+end # module Sbuilder