rack-reverse-proxy-ty 0.4.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 998bc49106c54f43f5981eb85a8a97c955359195
+  data.tar.gz: c0a1b3267a875a0b67c0039d9f7b2ef8c5871b2a
+SHA512:
+  metadata.gz: ab9c0de17f186ef32789c0e4805ec736820983e5304ded15be994587441d48b7902a1bf22312a7a90f671366e5409fb941773af013cbabdd14559bf597e372d3
+  data.tar.gz: c72582ff51ab8f18c20ce090bef674e943b06d2fef487e7c1ec0a755423eaf72fdbd2f59595ebae34f4eab42e796092c2e5432457c728abe53c426e568463313

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Jon Swope
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,56 @@
+= A Reverse Proxy for Rack
+
+This is a simple reverse proxy for Rack that pretty heavily rips off Rack Forwarder.  It is not meant for production systems (although it may work), as the webserver fronting your app is generally much better at this sort of thing.
+
+== Installation
+The gem is available on gemcutter.  Assuming you have a recent version of Rubygems you should just be able to install it via:
+  gem install rack-reverse-proxy
+
+For your Gemfile use:
+  gem "rack-reverse-proxy", :require => "rack/reverse_proxy"
+
+== Usage
+Matchers can be a regex or a string.  If a regex is used, you can use the subcaptures in your forwarding url by denoting them with a $.
+
+Right now if more than one matcher matches any given route, it throws an exception for an ambiguous match.  This will probably change later.  If no match is found, the call is forwarded to your application.
+
+Below is an example for configuring the middleware:
+
+  require 'rack/reverse_proxy'
+
+  use Rack::ReverseProxy do 
+    # Set :preserve_host to true globally (default is true already)
+    reverse_proxy_options :preserve_host => true
+
+    # Forward the path /test* to http://example.com/test*
+    reverse_proxy '/test', 'http://example.com/'
+
+    # Forward the path /foo/* to http://example.com/bar/*
+    reverse_proxy /^\/foo(\/.*)$/, 'http://example.com/bar$1', :username => 'name', :password => 'basic_auth_secret'
+  end
+
+  app = proc do |env|
+    [ 200, {'Content-Type' => 'text/plain'}, "b" ]
+  end
+  run app
+
+reverse_proxy_options sets global options for all reverse proxies. Available options are:
+* :preserve_host Set to false to omit Host headers
+* :username username for basic auth
+* :password password for basic auth
+* :matching is a global only option, if set to :first the first matched url will be requested (no ambigous error). Default: :all.
+* :timeout seconds to timout the requests
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Jon Swope. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,27 @@
+require 'rubygems'
+require 'rake'
+require 'bundler/gem_tasks'
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "rack-reverse-proxy #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.4.4

data/lib/rack/reverse_proxy.rb

@@ -0,0 +1,176 @@
+require 'net/http'
+require 'net/https'
+
+module Rack
+  class ReverseProxy
+    def initialize(app = nil, &b)
+      @app = app || lambda {|env| [404, [], []] }
+      @matchers = []
+      @global_options = {:preserve_host => true, :x_forwarded_host => true, :matching => :all, :verify_ssl => true}
+      instance_eval &b if block_given?
+    end
+
+    def call(env)
+      rackreq = Rack::Request.new(env)
+      matcher = get_matcher rackreq.fullpath
+      return @app.call(env) if matcher.nil?
+
+      uri = matcher.get_uri(rackreq.fullpath,env)
+      all_opts = @global_options.dup.merge(matcher.options)
+      headers = Rack::Utils::HeaderHash.new
+      env.each { |key, value|
+        if key =~ /HTTP_(.*)/
+          headers[$1] = value
+        end
+      }
+      headers['HOST'] = uri.host if all_opts[:preserve_host]
+      headers['X-Forwarded-Host'] = rackreq.host if all_opts[:x_forwarded_host]
+
+      session = Net::HTTP.new(uri.host, uri.port)
+      session.read_timeout=all_opts[:timeout] if all_opts[:timeout]
+
+      session.use_ssl = (uri.scheme == 'https')
+      if uri.scheme == 'https' && all_opts[:verify_ssl]
+        session.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      else
+        # DO NOT DO THIS IN PRODUCTION !!!
+        session.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+      session.start { |http|
+        m = rackreq.request_method
+        case m
+        when "GET", "HEAD", "DELETE", "OPTIONS", "TRACE"
+          req = Net::HTTP.const_get(m.capitalize).new(uri.request_uri, headers)
+          req.basic_auth all_opts[:username], all_opts[:password] if all_opts[:username] and all_opts[:password]
+        when "PUT", "POST"
+          req = Net::HTTP.const_get(m.capitalize).new(uri.request_uri, headers)
+          req.basic_auth all_opts[:username], all_opts[:password] if all_opts[:username] and all_opts[:password]
+
+          if rackreq.body.respond_to?(:read) && rackreq.body.respond_to?(:rewind)
+            body = rackreq.body.read
+            req.content_length = body.size
+            rackreq.body.rewind
+          else
+            req.content_length = rackreq.body.size
+          end
+
+          req.content_type = rackreq.content_type unless rackreq.content_type.nil?
+          req.body_stream = rackreq.body
+        else
+          raise "method not supported: #{m}"
+        end
+
+        body = ''
+        res = http.request(req) do |res|
+          res.read_body do |segment|
+            body << segment
+            # ensure content length header is correct
+            res.content_length = body.bytesize
+          end
+        end
+
+        [res.code, create_response_headers(res), [body]]
+      }
+    end
+
+    private
+
+    def get_matcher path
+      matches = @matchers.select do |matcher|
+        matcher.match?(path)
+      end
+
+      if matches.length < 1
+        nil
+      elsif matches.length > 1 && @global_options[:matching] != :first
+        raise AmbiguousProxyMatch.new(path, matches)
+      else
+        matches.first
+      end
+    end
+
+    def create_response_headers http_response
+      response_headers = Rack::Utils::HeaderHash.new(http_response.to_hash)
+      # handled by Rack
+      response_headers.delete('status')
+      # TODO: figure out how to handle chunked responses
+      response_headers.delete('transfer-encoding')
+      # TODO: Verify Content Length, and required Rack headers
+      response_headers
+    end
+
+
+    def reverse_proxy_options(options)
+      @global_options=options
+    end
+
+    def reverse_proxy matcher, url, opts={}
+      raise GenericProxyURI.new(url) if matcher.is_a?(String) && url.is_a?(String) && URI(url).class == URI::Generic
+      @matchers << ReverseProxyMatcher.new(matcher,url,opts)
+    end
+  end
+
+  class GenericProxyURI < Exception
+    attr_reader :url
+
+    def intialize(url)
+      @url = url
+    end
+
+    def to_s
+      %Q(Your URL "#{@url}" is too generic. Did you mean "http://#{@url}"?)
+    end
+  end
+
+  class AmbiguousProxyMatch < Exception
+    attr_reader :path, :matches
+    def initialize(path, matches)
+      @path = path
+      @matches = matches
+    end
+
+    def to_s
+      %Q(Path "#{path}" matched multiple endpoints: #{formatted_matches})
+    end
+
+    private
+
+    def formatted_matches
+      matches.map {|matcher| matcher.to_s}.join(', ')
+    end
+  end
+
+  class ReverseProxyMatcher
+    def initialize(matching,url,options)
+      @matching=matching
+      @url=url
+      @options=options
+      @matching_regexp= matching.kind_of?(Regexp) ? matching : /^#{matching.to_s}/
+    end
+
+    attr_reader :matching,:matching_regexp,:url,:options
+
+    def match?(path)
+      match_path(path) ? true : false
+    end
+
+    def get_uri(path,env)
+      _url=(url.respond_to?(:call) ? url.call(env) : url.clone)
+      if _url =~/\$\d/
+        match_path(path).to_a.each_with_index { |m, i| _url.gsub!("$#{i.to_s}", m) }
+        URI(_url)
+      else
+        URI.join(_url, path)
+      end
+    end
+    def to_s
+      %Q("#{matching.to_s}" => "#{url}")
+    end
+    private
+    def match_path(path)
+      path.match(matching_regexp)
+    end
+
+
+  end
+end

data/rack-reverse-proxy-ty.gemspec

@@ -0,0 +1,42 @@
+Gem::Specification.new do |s|
+  s.name = %q{rack-reverse-proxy-ty}
+  s.version = "0.4.4"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["TY"]
+  s.date = %q{2012-01-26}
+  s.description = %q{A Rack based reverse proxy for basic needs.  Useful for testing or in cases where webserver configuration is unavailable.}
+  s.email = %q{ty@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    "LICENSE",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "lib/rack/reverse_proxy.rb",
+    "rack-reverse-proxy-ty.gemspec",
+    "spec/rack/reverse_proxy_spec.rb",
+    "spec/spec.opts",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/prismaticence/rack-reverse-proxy-ty}
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{A Simple Reverse Proxy for Rack}
+  s.test_files = [
+    "spec/rack/reverse_proxy_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+
+  s.add_development_dependency "rspec", "~> 1.3.2"
+  s.add_development_dependency "bundler", "~> 1.0.15"
+  s.add_development_dependency "rake", "~> 0.8.7"
+  s.add_development_dependency "rack-test", "~> 0.5.7"
+  s.add_development_dependency "webmock", "~> 1.5.0"
+  s.add_dependency "rack", ">= 1.0.0"
+end
+

data/spec/rack/reverse_proxy_spec.rb

@@ -0,0 +1,231 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Rack::ReverseProxy do
+  include Rack::Test::Methods
+  include WebMock::API
+
+  def app
+    Rack::ReverseProxy.new
+  end
+
+  def dummy_app
+    lambda { |env| [200, {}, ['Dummy App']] }
+  end
+
+  describe "as middleware" do
+    def app
+      Rack::ReverseProxy.new(dummy_app) do
+        reverse_proxy '/test', 'http://example.com/', {:preserve_host => true}
+        reverse_proxy '/2test', lambda{ |env| 'http://example.com/'}
+      end
+    end
+
+    it "should forward requests to the calling app when the path is not matched" do
+      get '/'
+      last_response.body.should == "Dummy App"
+      last_response.should be_ok
+    end
+
+    it "should proxy requests when a pattern is matched" do
+      stub_request(:get, 'http://example.com/test').to_return({:body => "Proxied App"})
+      get '/test'
+      last_response.body.should == "Proxied App"
+    end
+
+    it "should proxy requests to a lambda url when a pattern is matched" do
+      stub_request(:get, 'http://example.com/2test').to_return({:body => "Proxied App2"})
+      get '/2test'
+      last_response.body.should == "Proxied App2"
+    end
+
+    it "the response header should never contain Status" do
+      stub_request(:any, 'example.com/test/stuff').to_return(:headers => {'Status' => '200 OK'})
+      get '/test/stuff'
+      last_response.headers['Status'].should == nil
+    end
+
+    it "the response header should never transfer-encoding" do
+      stub_request(:any, 'example.com/test/stuff').to_return(:headers => {'transfer-encoding' => 'Chunked'})
+      get '/test/stuff'
+      last_response.headers['transfer-encoding'].should == nil
+    end
+
+    it "should set the Host header" do
+      stub_request(:any, 'example.com/test/stuff')
+      get '/test/stuff'
+      a_request(:get, 'http://example.com/test/stuff').with(:headers => {"Host" => "example.com"}).should have_been_made
+    end
+
+    it "should set the X-Forwarded-Host header to the proxying host by default" do
+      stub_request(:any, 'example.com/test/stuff')
+      get '/test/stuff'
+      a_request(:get, 'http://example.com/test/stuff').with(:headers => {'X-Forwarded-Host' => 'example.org'}).should have_been_made
+    end
+
+    describe "with preserve host turned off" do
+      def app
+        Rack::ReverseProxy.new(dummy_app) do
+          reverse_proxy '/test', 'http://example.com/', {:preserve_host => false}
+        end
+      end
+
+      it "should not set the Host header" do
+        stub_request(:any, 'example.com/test/stuff')
+        get '/test/stuff'
+        a_request(:get, 'http://example.com/test/stuff').with(:headers => {"Host" => "example.com"}).should_not have_been_made
+        a_request(:get, 'http://example.com/test/stuff').should have_been_made
+      end
+    end
+
+    describe "with x_forwarded_host turned off" do
+      def app
+        Rack::ReverseProxy.new(dummy_app) do
+          reverse_proxy_options :x_forwarded_host => false
+          reverse_proxy '/test', 'http://example.com/'
+        end
+      end
+
+      it "should not set the X-Forwarded-Host header to the proxying host" do
+        stub_request(:any, 'example.com/test/stuff')
+        get '/test/stuff'
+        a_request(:get, 'http://example.com/test/stuff').with(:headers => {'X-Forwarded-Host' => 'example.org'}).should_not have_been_made
+        a_request(:get, 'http://example.com/test/stuff').should have_been_made
+      end
+    end
+
+    describe "with basic auth turned on" do
+      def app
+        Rack::ReverseProxy.new(dummy_app) do
+          reverse_proxy '/test', 'http://example.com/', {:username => "joe", :password => "shmoe"}
+        end
+      end
+
+      it "should make request with basic auth" do
+        stub_request(:get, "http://joe:shmoe@example.com/test/stuff").to_return(:body => "secured content")
+        get '/test/stuff'
+        last_response.body.should == "secured content"
+      end
+    end
+
+    describe "with ambiguous routes and all matching" do
+      def app
+        Rack::ReverseProxy.new(dummy_app) do
+          reverse_proxy_options :matching => :all
+          reverse_proxy '/test', 'http://example.com/'
+          reverse_proxy /^\/test/, 'http://example.com/'
+        end
+      end
+
+      it "should throw an exception" do
+        lambda { get '/test' }.should raise_error(Rack::AmbiguousProxyMatch)
+      end
+    end
+
+    describe "with ambiguous routes and first matching" do
+      def app
+        Rack::ReverseProxy.new(dummy_app) do
+          reverse_proxy_options :matching => :first
+          reverse_proxy '/test', 'http://example1.com/'
+          reverse_proxy /^\/test/, 'http://example2.com/'
+        end
+      end
+
+      it "should throw an exception" do
+        stub_request(:get, 'http://example1.com/test').to_return({:body => "Proxied App"})
+        get '/test'
+        last_response.body.should == "Proxied App"
+      end
+    end
+
+    describe "with a route as a regular expression" do
+      def app
+        Rack::ReverseProxy.new(dummy_app) do
+          reverse_proxy %r|^/test(/.*)$|, 'http://example.com$1'
+        end
+      end
+
+      it "should support subcaptures" do
+        stub_request(:get, 'http://example.com/path').to_return({:body => "Proxied App"})
+        get '/test/path'
+        last_response.body.should == "Proxied App"
+      end
+    end
+
+    describe "with a https route" do
+      def app
+        Rack::ReverseProxy.new(dummy_app) do
+          reverse_proxy '/test', 'https://example.com'
+        end
+      end
+
+      it "should make a secure request" do
+        stub_request(:get, 'https://example.com/test/stuff').to_return({:body => "Proxied Secure App"})
+        get '/test/stuff'
+        last_response.body.should == "Proxied Secure App"
+      end
+
+    end
+
+    describe "with a route as a string" do
+      def app
+        Rack::ReverseProxy.new(dummy_app) do
+          reverse_proxy '/test', 'http://example.com'
+          reverse_proxy '/path', 'http://example.com/foo$0'
+        end
+      end
+
+      it "should append the full path to the uri" do
+        stub_request(:get, 'http://example.com/test/stuff').to_return({:body => "Proxied App"})
+        get '/test/stuff'
+        last_response.body.should == "Proxied App"
+      end
+
+    end
+
+    describe "with a generic url" do
+      def app
+        Rack::ReverseProxy.new(dummy_app) do
+          reverse_proxy '/test', 'example.com'
+        end
+      end
+
+      it "should throw an exception" do
+        lambda{ app }.should raise_error(Rack::GenericProxyURI)
+      end
+    end
+
+    describe "with a matching route" do
+      def app
+        Rack::ReverseProxy.new(dummy_app) do
+          reverse_proxy '/test', 'http://example.com/'
+        end
+      end
+
+      %w|get head delete put post|.each do |method|
+        describe "and using method #{method}" do
+          it "should forward the correct request" do
+            stub_request(method.to_sym, 'http://example.com/test').to_return({:body => "Proxied App for #{method}"})
+            eval "#{method} '/test'"
+            last_response.body.should == "Proxied App for #{method}"
+          end
+
+          if %w|put post|.include?(method)
+            it "should forward the request payload" do
+              stub_request(method.to_sym, 'http://example.com/test').to_return { |req| {:body => req.body} }
+              eval "#{method} '/test', {:test => 'test'}"
+              last_response.body.should == "test=test"
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe "as a rack app" do
+    it "should respond with 404 when the path is not matched" do
+      get '/'
+      last_response.should be_not_found
+    end
+  end
+
+end

data/spec/spec.opts

@@ -0,0 +1,2 @@
+--color
+--format specdoc

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'rack/reverse_proxy'
+require 'spec'
+require 'spec/autorun'
+require 'rubygems'
+require 'rack/test'
+require 'webmock'
+require 'webmock/rspec'
+
+Spec::Runner.configure do |config|
+  WebMock.disable_net_connect!
+end

metadata

@@ -0,0 +1,141 @@
+--- !ruby/object:Gem::Specification
+name: rack-reverse-proxy-ty
+version: !ruby/object:Gem::Version
+  version: 0.4.4
+platform: ruby
+authors:
+- TY
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.2
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.15
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.15
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.7
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.7
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.7
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.7
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+description: A Rack based reverse proxy for basic needs.  Useful for testing or in
+  cases where webserver configuration is unavailable.
+email: ty@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.rdoc
+files:
+- ".document"
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/rack/reverse_proxy.rb
+- rack-reverse-proxy-ty.gemspec
+- spec/rack/reverse_proxy_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+homepage: http://github.com/prismaticence/rack-reverse-proxy-ty
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A Simple Reverse Proxy for Rack
+test_files:
+- spec/rack/reverse_proxy_spec.rb
+- spec/spec_helper.rb