module Faraday::MiddlewareRegistry

def fetch_middleware(key) 

def fetch_middleware(key)
  defined?(@registered_middleware) && @registered_middleware[key]
end

def load_middleware(key) 

def load_middleware(key)
  value = fetch_middleware(key)
  case value
  when Module
    value
  when Symbol, String
    middleware_mutex do
      @registered_middleware[key] = const_get(value)
    end
  when Proc
    middleware_mutex do
      @registered_middleware[key] = value.call
    end
  when Array
    middleware_mutex do
      const, path = value
      if root = @middleware_autoload_path
        path = "#{root}/#{path}"
      end
      require(path)
      @registered_middleware[key] = const
    end
    load_middleware(key)
  end
end

def lookup_middleware(key)

Returns a middleware Class.

# => Faraday::Whatever::Foo
Faraday::Whatever.lookup_middleware(:foo)

end
end
register_middleware :foo => Foo
class Whatever
module Faraday

Examples

key - The Symbol key for the registered middleware.

Public: Lookup middleware class with a registered Symbol shortcut. 
def lookup_middleware(key)
  load_middleware(key) ||
    raise(Faraday::Error.new("#{key.inspect} is not registered on #{self}"))
end

def middleware_mutex(&block) 

def middleware_mutex(&block)
  @middleware_mutex ||= begin
    require 'monitor'
    Monitor.new
  end
  @middleware_mutex.synchronize(&block)
end

def register_middleware(autoload_path = nil, mapping = nil)

Returns nothing.

end
end
register_middleware :baz => [:Baz, 'baz']
# Middleware looked up by :baz requires 'baz' and returns Faraday::Whatever.const_get(:Baz)

register_middleware :bar => :Bar
# Middleware looked up by :bar returns Faraday::Whatever.const_get(:Bar)

register_middleware :foo => Foo
# Middleware looked up by :foo returns Faraday::Whatever::Foo.
class Whatever
module Faraday

Examples

called to return the former.
as fully qualified constant, or a Proc that will be lazily
mapping - A Hash mapping Symbol keys to classes. Classes can be expressed

Public: Register middleware class(es) on the current module. 
def register_middleware(autoload_path = nil, mapping = nil)
  if mapping.nil?
    mapping = autoload_path
    autoload_path = nil
  end
  middleware_mutex do
    @middleware_autoload_path = autoload_path if autoload_path
    (@registered_middleware ||= {}).update(mapping)
  end
end