rack-reverse-proxy 0.4.4 → 0.8.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d51045cd47dd0cee3f5afb010a2915f9dd6367ba
+  data.tar.gz: c675c804802eb806d6fca45b471630ed0d980268
+SHA512:
+  metadata.gz: dada6c70259a95d63705ffad9ad59f54d492b721b98d2496322ba33cec38d1005a778830091dfe44c2f5a2b23a9d4b91ff002d761f90a93a37dc32f4de38c7ad
+  data.tar.gz: 7aa447d71a827b37b3a53818723b426c8c0135b90b7c7dcdc2b850dcd1717531e5dddd99afc82ffdcee57f6ebc4a761bb4fba320529f793ad239e21b08a99c3b

data/README.md

@@ -0,0 +1,64 @@
+# A Reverse Proxy for Rack
+[![TravisCI](https://secure.travis-ci.org/pex/rack-reverse-proxy.png "Build Status")](http://travis-ci.org/pex/rack-reverse-proxy "Build Status")
+
+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:
+
+```ruby
+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:
+
+```ruby
+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/lib/rack/exception.rb

@@ -0,0 +1,31 @@
+module Rack
+  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
+end

data/lib/rack/reverse_proxy.rb

@@ -1,173 +1,133 @@
 require 'net/http'
 require 'net/https'
+require "rack-proxy"
+require "rack/reverse_proxy_matcher"
+require "rack/exception"
 
 module Rack
   class ReverseProxy
+    include NewRelic::Agent::Instrumentation::ControllerInstrumentation if defined? NewRelic
+
     def initialize(app = nil, &b)
       @app = app || lambda {|env| [404, [], []] }
       @matchers = []
-      @global_options = {:preserve_host => true, :matching => :all, :verify_ssl => true}
+      @global_options = {:preserve_host => true, :x_forwarded_host => true, :matching => :all, :replace_response_host => false}
       instance_eval &b if block_given?
     end
 
     def call(env)
       rackreq = Rack::Request.new(env)
-      matcher = get_matcher rackreq.fullpath
+      matcher = get_matcher(rackreq.fullpath, extract_http_request_headers(rackreq.env), rackreq)
       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
+      if @global_options[:newrelic_instrumentation]
+        action_name = "#{rackreq.path.gsub(/\/\d+/,'/:id').gsub(/^\//,'')}/#{rackreq.request_method}" # Rack::ReverseProxy/foo/bar#GET
+        perform_action_with_newrelic_trace(:name => action_name, :request => rackreq) do
+          proxy(env, rackreq, matcher)
         end
-      }
-      headers['HOST'] = uri.host if all_opts[:preserve_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
+        proxy(env, rackreq, matcher)
       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
-          end
-        end
-
-        [res.code, create_response_headers(res), [body]]
-      }
     end
 
     private
 
-    def get_matcher path
-      matches = @matchers.select do |matcher|
-        matcher.match?(path)
+    def proxy(env, source_request, matcher)
+      uri = matcher.get_uri(source_request.fullpath,env)
+      if uri.nil?
+        return @app.call(env)
       end
+      options = @global_options.dup.merge(matcher.options)
 
-      if matches.length < 1
-        nil
-      elsif matches.length > 1 && @global_options[:matching] != :first
-        raise AmbiguousProxyMatch.new(path, matches)
-      else
-        matches.first
+      # Initialize request
+      target_request = Net::HTTP.const_get(source_request.request_method.capitalize).new(uri.request_uri)
+
+      # Setup headers
+      target_request_headers = extract_http_request_headers(source_request.env)
+
+      if options[:preserve_host]
+        target_request_headers['HOST'] = "#{uri.host}:#{uri.port}"
       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
+      if options[:x_forwarded_host]
+        target_request_headers['X-Forwarded-Host'] = source_request.host
+        target_request_headers['X-Forwarded-Port'] = "#{source_request.port}"
+      end
 
+      target_request.initialize_http_header(target_request_headers)
 
-    def reverse_proxy_options(options)
-      @global_options=options
-    end
+      # Basic auth
+      target_request.basic_auth options[:username], options[:password] if options[:username] and options[:password]
 
-    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
+      # Setup body
+      if target_request.request_body_permitted? && source_request.body
+        source_request.body.rewind
+        target_request.body_stream    = source_request.body
+      end
 
-  class GenericProxyURI < Exception
-    attr_reader :url
+      target_request.content_length = source_request.content_length || 0
+      target_request.content_type   = source_request.content_type if source_request.content_type
 
-    def intialize(url)
-      @url = url
-    end
+      # Create a streaming response (the actual network communication is deferred, a.k.a. streamed)
+      target_response = HttpStreamingResponse.new(target_request, uri.host, uri.port)
 
-    def to_s
-      %Q(Your URL "#{@url}" is too generic. Did you mean "http://#{@url}"?)
-    end
-  end
+      target_response.use_ssl = "https" == uri.scheme
 
-  class AmbiguousProxyMatch < Exception
-    attr_reader :path, :matches
-    def initialize(path, matches)
-      @path = path
-      @matches = matches
-    end
+      # Let rack set the transfer-encoding header
+      response_headers = target_response.headers
+      response_headers.delete('transfer-encoding')
 
-    def to_s
-      %Q(Path "#{path}" matched multiple endpoints: #{formatted_matches})
+      # Replace the location header with the proxy domain
+      if response_headers['location'] && options[:replace_response_host]
+        response_location = URI(response_headers['location'][0])
+        response_location.host = source_request.host
+        response_headers['location'] = response_location.to_s
+      end
+
+      [target_response.status, response_headers, target_response.body]
     end
 
-    private
+    def extract_http_request_headers(env)
+      headers = env.reject do |k, v|
+        !(/^HTTP_[A-Z_]+$/ === k) || v.nil?
+      end.map do |k, v|
+        [reconstruct_header_name(k), v]
+      end.inject(Utils::HeaderHash.new) do |hash, k_v|
+        k, v = k_v
+        hash[k] = v
+        hash
+      end
 
-    def formatted_matches
-      matches.map {|matcher| matcher.to_s}.join(', ')
-    end
-  end
+      x_forwarded_for = (headers["X-Forwarded-For"].to_s.split(/, +/) << env["REMOTE_ADDR"]).join(", ")
 
-  class ReverseProxyMatcher
-    def initialize(matching,url,options)
-      @matching=matching
-      @url=url
-      @options=options
-      @matching_regexp= matching.kind_of?(Regexp) ? matching : /^#{matching.to_s}/
+      headers.merge!("X-Forwarded-For" =>  x_forwarded_for)
     end
 
-    attr_reader :matching,:matching_regexp,:url,:options
-
-    def match?(path)
-      match_path(path) ? true : false
+    def reconstruct_header_name(name)
+      name.sub(/^HTTP_/, "").gsub("_", "-")
     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)
+    def get_matcher(path, headers, rackreq)
+      matches = @matchers.select do |matcher|
+        matcher.match?(path, headers, rackreq)
+      end
+
+      if matches.length < 1
+        nil
+      elsif matches.length > 1 && @global_options[:matching] != :first
+        raise AmbiguousProxyMatch.new(path, matches)
       else
-        URI.join(_url, path)
+        matches.first
       end
     end
-    def to_s
-      %Q("#{matching.to_s}" => "#{url}")
-    end
-    private
-    def match_path(path)
-      path.match(matching_regexp)
-    end
 
+    def reverse_proxy_options(options)
+      @global_options=options
+    end
 
+    def reverse_proxy(matcher, url=nil, 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
 end

data/lib/rack/reverse_proxy_matcher.rb

@@ -0,0 +1,53 @@
+module Rack
+  class ReverseProxyMatcher
+    def initialize(matcher,url=nil,options)
+      @default_url=url
+      @url=url
+      @options=options
+
+      if matcher.kind_of?(String)
+        @matcher = /^#{matcher.to_s}/
+      elsif matcher.respond_to?(:match)
+        @matcher = matcher
+      else
+        raise "Invalid Matcher for reverse_proxy"
+      end
+    end
+
+    attr_reader :matcher,:url, :default_url,:options
+
+    def match?(path, *args)
+      match_path(path, *args) ? true : false
+    end
+
+    def get_uri(path,env)
+      return nil if url.nil?
+      _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
+        default_url.nil? ? URI.parse(_url) : URI.join(_url, path)
+      end
+    end
+
+    def to_s
+      %Q("#{matcher.to_s}" => "#{url}")
+    end
+
+    private
+    def match_path(path, *args)
+      headers = args[0]
+      rackreq = args[1]
+      arity = matcher.method(:match).arity
+      if arity == -1
+        match = matcher.match(path)
+      else
+        params = [path, (@options[:accept_headers] ? headers : nil), rackreq]
+        match = matcher.match(*params[0..(arity - 1)])
+      end
+      @url = match.url(path) if match && default_url.nil?
+      match
+    end
+  end
+end

metadata

@@ -1,125 +1,167 @@
 --- !ruby/object:Gem::Specification
 name: rack-reverse-proxy
 version: !ruby/object:Gem::Version
-  version: 0.4.4
-  prerelease: 
+  version: 0.8.1
 platform: ruby
 authors:
 - Jon Swope
+- Ian Ehlert
+- Roman Ernst
+- Oleksii Fedorov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-26 00:00:00.000000000Z
+date: 2015-05-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &21582760 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.3.2
+        version: '3.1'
   type: :development
   prerelease: false
-  version_requirements: *21582760
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: &21581540 !ruby/object:Gem::Requirement
-    none: false
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.15
-  type: :development
-  prerelease: false
-  version_requirements: *21581540
+        version: '3.1'
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &21580900 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.7
+        version: '10.3'
   type: :development
   prerelease: false
-  version_requirements: *21580900
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
 - !ruby/object:Gem::Dependency
   name: rack-test
-  requirement: &21580220 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.7
+        version: '0.6'
   type: :development
   prerelease: false
-  version_requirements: *21580220
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
 - !ruby/object:Gem::Dependency
   name: webmock
-  requirement: &21578760 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.18'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.18'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.5.0
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
   prerelease: false
-  version_requirements: *21578760
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rack
-  requirement: &21577540 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.0.0
   type: :runtime
   prerelease: false
-  version_requirements: *21577540
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: rack-proxy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
 description: A Rack based reverse proxy for basic needs.  Useful for testing or in
   cases where webserver configuration is unavailable.
-email: jaswope@gmail.com
+email:
+- jaswope@gmail.com
+- ehlertij@gmail.com
+- rernst@farbenmeer.net
+- waterlink000@gmail.com
 executables: []
 extensions: []
-extra_rdoc_files:
-- LICENSE
-- README.rdoc
+extra_rdoc_files: []
 files:
-- .document
 - LICENSE
-- README.rdoc
-- Rakefile
-- VERSION
+- README.md
+- lib/rack/exception.rb
 - lib/rack/reverse_proxy.rb
-- rack-reverse-proxy.gemspec
-- spec/rack/reverse_proxy_spec.rb
-- spec/spec.opts
-- spec/spec_helper.rb
-homepage: http://github.com/jaswope/rack-reverse-proxy
+- lib/rack/reverse_proxy_matcher.rb
+homepage: http://github.com/waterlink/rack-reverse-proxy
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A Simple Reverse Proxy for Rack
-test_files:
-- spec/rack/reverse_proxy_spec.rb
-- spec/spec_helper.rb
+test_files: []

data/.document

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

data/README.rdoc

@@ -1,56 +0,0 @@
-= 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

@@ -1,27 +0,0 @@
-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

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

data/rack-reverse-proxy.gemspec

@@ -1,42 +0,0 @@
-Gem::Specification.new do |s|
-  s.name = %q{rack-reverse-proxy}
-  s.version = "0.4.4"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Jon Swope"]
-  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{jaswope@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.gemspec",
-    "spec/rack/reverse_proxy_spec.rb",
-    "spec/spec.opts",
-    "spec/spec_helper.rb"
-  ]
-  s.homepage = %q{http://github.com/jaswope/rack-reverse-proxy}
-  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

@@ -1,209 +0,0 @@
-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
-
-    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 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

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

data/spec/spec_helper.rb

@@ -1,13 +0,0 @@
-$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