rack-rewrite 0.1.3 → 0.2.0

data/History.rdoc

@@ -0,0 +1,23 @@
+=== 0.2.0 / 2009-11-14
+* API
+  * Allow Proc's to be be passed as the 'to' argument to rule declarations
+  * Introduce rule guard support using :if => Proc.new option.
+  * :send_file and :x_send_file rules
+  * proxy rack_env to rule guards for arbitrary rule writing
+
+* Documentation
+  * Add example of writing capistrano maintenance page rewrite rules
+  * Add examples of rule guards and arbitrary rewriting
+  * Add examples of :send_file and :x_send_file rules    
+
+=== 0.1.3 / 2009-11-14
+* Maintenance
+  * Ensure Content-Type header is set for 301's and 302's (thanks to Sebastian Röbke)
+* Documentation
+  * Add HISTORY.rdoc
+  
+=== 0.1.2 / 2009-10-13
+
+* Initial Feature Set
+  * :r301, :r302 and :redirect are supported in the rewrite DSL
+  * Regex matching/substitution patterns supported in rules

data/README.rdoc

@@ -3,6 +3,29 @@
 A rack middleware for defining and applying rewrite rules. In many cases you 
 can get away with rack-rewrite instead of writing Apache mod_rewrite rules.
 
+== Usage
+
+=== Sample rackup file
+  
+  gem 'rack-rewrite', '~> 0.1.3'
+  require 'rack-rewrite
+  use Rack::Rewrite do
+    rewrite '/wiki/John_Trupiano', '/john'
+    r301 '/wiki/Yair_Flicker', '/yair'
+    r302 '/wiki/Greg_Jastrab', '/greg'
+    r301 %r{/wiki/(\w+)_\w+}, '/$1'
+  end
+
+=== Sample usage in a rails app
+  config.gem 'rack-rewrite', '~> 0.1.3'
+  require 'rack-rewrite
+  config.middleware.insert_before(Rack::Lock, Rack::Rewrite) do
+    rewrite '/wiki/John_Trupiano', '/john'
+    r301 '/wiki/Yair_Flicker', '/yair'
+    r302 '/wiki/Greg_Jastrab', '/greg'
+    r301 %r{/wiki/(\w+)_\w+}, '/$1'
+  end
+
 == Use Cases
 
 === Rebuild of existing site in a new technology
@@ -30,27 +53,49 @@ to these routes and keep your routes.rb clean.
 
   rewrite %r{/features(.*)}, '/facial_features$1'
 
-== Sample rackup file
-  
-  gem 'rack-rewrite', '~> 0.1.2'
-  require 'rack-rewrite
-  use Rack::Rewrite do
-    rewrite '/wiki/John_Trupiano', '/john'
-    r301 '/wiki/Yair_Flicker', '/yair'
-    r302 '/wiki/Greg_Jastrab', '/greg'
-    r301 %r{/wiki/(\w+)_\w+}, '/$1'
-  end
+=== Site Maintenance
 
-== Sample usage in a rails app
-  config.gem 'rack-rewrite', '~> 0.1.2'
-  require 'rack-rewrite
-  config.middleware.insert_before(Rack::Lock, Rack::Rewrite) do
-    rewrite '/wiki/John_Trupiano', '/john'
-    r301 '/wiki/Yair_Flicker', '/yair'
-    r302 '/wiki/Greg_Jastrab', '/greg'
-    r301 %r{/wiki/(\w+)_\w+}, '/$1'
-  end
+Most capistrano users will be familiar with the following Apache rewrite rules:
+
+  RewriteCond %{REQUEST_URI} !\.(css|jpg|png)$
+  RewriteCond %{DOCUMENT_ROOT}/system/maintenance.html -f
+  RewriteCond %{SCRIPT_FILENAME} !maintenance.html
+  RewriteRule ^.*$ /system/maintenance.html [L]
+
+This rewrite rule says to render a maintenance page for all non-asset requests
+if the maintenance file exists.  In capistrano, you can quickly upload a 
+maintenance file using:
+
+  cap deploy:web:disable REASON=upgrade UNTIL=12:30PM
   
+We can replace the mod_rewrite rules with the following Rack::Rewrite rule:
+
+  maintenance_file = File.join(RAILS_ROOT, 'public', 'system', 'maintenance.html')
+  send_file /.*/, maintenance_file, :if => Proc.new { |rack_env|
+    File.exists?(maintenance_file) && !%w(css jpg png).any? {|ext| maintenance_file =~ Regexp.new("\.#{ext}$")}
+  }
+
+If you're running Ruby 1.9, this rule is highly simplified:
+
+  maintenance_file = File.join(RAILS_ROOT, 'public', 'system', 'maintenance.html')
+  send_file /(.*)$(?<!css|png|jpg)/, maintenance_file, :if => Proc.new { |rack_env|
+    File.exists?(maintenance_file)
+  }
+
+For those using the oniguruma gem with their ruby 1.8 installation, you can 
+get away with this:
+
+  maintenance_file = File.join(RAILS_ROOT, 'public', 'system', 'maintenance.html')
+  send_file Oniguruma::ORegexp.new("(.*)$(?<!css|png|jpg)"), maintenace_file, :if => Proc.new { |rack_env|
+    File.exists?(maintenance_file)
+  }
+
+NOTE: These replacement rules actually issue redirects.  The apache config
+snippet referenced above actually performs a rewrite.  With Rack::Rewrite
+we currently have to issue a redirect because rails will not recognize the
+maintenance route.  If you have any ideas on how to fix this, I would love
+to discuss it with you.
+
 == Rewrite Rules
 
 === :rewrite
@@ -86,6 +131,19 @@ Recall that rules are interpreted from top to bottom.  So you can install
 "default" rewrite rules if you like.  [2] is a sample default rule that
 will redirect all other requests to the wiki to a google search.
 
+=== :send_file, :x_send_file
+
+Calls to #send_file and #x_send_file also have the same signature as #rewrite.
+If the rule matches, the 'to' parameter is interpreted as a path to a file
+to be rendered instead of passing the application call up the rack stack.
+
+  send_file /*/, 'public/spammers.htm', :if => Proc.new { |rack_env|
+    rack_env['HTTP_REFERER'] =~ 'spammers.com'
+  }
+  x_send_file /^blog\/.*/, 'public/blog_offline.htm', :if => Proc.new { |rack_env|
+    File.exists?('public/blog_offline.htm')
+  }
+
 == Tips
 
 === Keeping your querystring
@@ -99,6 +157,39 @@ capture group and substitution pattern in your rewrite rule to achieve this.
 This rule will store the querystring in a capture group (via '(?.*)' ) and
 will substitute the querystring back into the rewritten URL (via $1).
 
+=== Rule Guards
+
+All rules support passing guards as Procs/lambdas.  Guards simply return
+true or false indicating whether the rule declaration is a match.  The
+following example demonstrates how the presence of a maintenance page
+on the filesystem can be utilized to take your site(s) offline.
+
+  maintenance_file = File.join(RAILS_ROOT, 'public', 'system', 'maintenance.html')
+  x_send_file /.*/, maintenance_file, :if => Proc.new { |rack_env| 
+    File.exists?(maintenance_file)
+  }
+
+=== Arbitrary Rewriting
+
+All rules support passing a Proc as the second argument allowing you to
+perform arbitrary rewrites.  The following rule will rewrite all requests
+received between 12AM and 8AM to an unavailable page.
+
+  rewrite %r{(.*)}, lambda { |match, rack_env|
+    Time.now.hour < 8 ? "/unavailable.html" : match[1]
+  }
+  
+Note also that the rack environment is yielded to the lambda.  The 
+following redirect rule will send all visitors coming from a 
+
+rewrite %r{(.*)}, lambda { |match, rack_env|
+  if rack_env['HTTP_REFERER'] =~ /microsoft\.com/
+    
+  Time.now.hour < 8 ? "/unavailable.html" : match[1]
+}
+
+
+  
 == Copyright
 
 Copyright (c) 2009 John Trupiano. See LICENSE for details.

data/TODO

@@ -1,4 +1,9 @@
-* Add :host support to restrict which URL's a rewrite rule matches [10/15/09]
-* Add :if => lambda support for arbitrary conditional rule application (this will allow us to do the capistrano maintenance page w/o apache's mod_rewrite)
-* Add support for specifying a config file instead of passing a block (e.g. config/rewrite.rb)
-* Better message than "Redirecting..." -- how about html that says where it's being redirected to?
+* OUTSTANDING
+  * Add :host support to restrict which URL's a rewrite rule matches [10/15/09]
+  * Add support for specifying a config file instead of passing a block (e.g. config/rewrite.rb) [10/15/09]
+  * Better message than "Redirecting..." -- how about html that says where it's being redirected to? [10/16/09]
+  * Provide testing helpers (e.g. should_rewrite) to facilitate straightforward testing. [10/25/09]
+  * Allow rules to return arbitrary html (e.g. the contents of the maintenance page) [10/25/09]
+
+* COMPLETED
+  * Add :if => lambda support for arbitrary conditional rule application (this will allow us to do the capistrano maintenance page w/o apache's mod_rewrite) [10/15/09]

data/VERSION

@@ -1 +1 @@
-0.1.3
+0.2.0

data/lib/rack-rewrite.rb

@@ -23,7 +23,7 @@ module Rack
         
     private
       def find_first_matching_rule(env) #:nodoc:
-        @rule_set.rules.detect { |rule| rule.matches?(env['REQUEST_URI']) }
+        @rule_set.rules.detect { |rule| rule.matches?(env) }
       end    
   end
 end

data/lib/rack-rewrite/rule.rb

@@ -1,3 +1,5 @@
+require 'rack/mime'
+
 module Rack
   class Rewrite
     class RuleSet
@@ -15,40 +17,64 @@ module Rack
         # user's browser will continue to show the initially requested URL.
         # 
         #  rewrite '/wiki/John_Trupiano', '/john'
-        #  rewrite %r{/wiki/(\w+)_\w+}, '/$1'        
-        def rewrite(from, to)
-          @rules << Rule.new(:rewrite, from, to)
+        #  rewrite %r{/wiki/(\w+)_\w+}, '/$1'
+        #  rewrite %r{(.*)}, '/maintenance.html', :if => lambda { File.exists?('maintenance.html') }
+        def rewrite(from, to, *args)
+          options = args.last.is_a?(Hash) ? args.last : {}
+          @rules << Rule.new(:rewrite, from, to, options[:if])
         end
         
         # Creates a redirect rule that will send a 301 when matching.
         #
         #  r301 '/wiki/John_Trupiano', '/john'
         #  r301 '/contact-us.php', '/contact-us'
-        def r301(from, to)
-          @rules << Rule.new(:r301, from, to)
+        def r301(from, to, *args)
+          options = args.last.is_a?(Hash) ? args.last : {}
+          @rules << Rule.new(:r301, from, to, options[:if])
         end
         
         # Creates a redirect rule that will send a 302 when matching.
         #
         #  r302 '/wiki/John_Trupiano', '/john'
         #  r302 '/wiki/(.*)', 'http://www.google.com/?q=$1'
-        def r302(from, to)
-          @rules << Rule.new(:r302, from, to)
+        def r302(from, to, *args)
+          options = args.last.is_a?(Hash) ? args.last : {}
+          @rules << Rule.new(:r302, from, to, options[:if])
         end
+        
+        # Creates a rule that will render a file if matched.
+        #
+        #  send_file /*/, 'public/system/maintenance.html', 
+        #    :if => { File.exists?('public/system/maintenance.html') }
+        def send_file(from, to, *args)
+          options = args.last.is_a?(Hash) ? args.last : {}
+          @rules << Rule.new(:send_file, from, to, options[:if])          
+        end
+        
+        # Creates a rule that will render a file using x-send-file
+        # if matched.
+        #
+        #  x_send_file /*/, 'public/system/maintenance.html', 
+        #    :if => { File.exists?('public/system/maintenance.html') }
+        def x_send_file(from, to, *args)
+          options = args.last.is_a?(Hash) ? args.last : {}
+          @rules << Rule.new(:x_send_file, from, to, options[:if])
+        end        
     end
 
     # TODO: Break rules into subclasses
     class Rule #:nodoc:
-      attr_reader :rule_type, :from, :to
-      def initialize(rule_type, from, to) #:nodoc:
-        @rule_type, @from, @to = rule_type, from, to
+      attr_reader :rule_type, :from, :to, :guard
+      def initialize(rule_type, from, to, guard=nil) #:nodoc:
+        @rule_type, @from, @to, @guard = rule_type, from, to, guard
       end
 
-      def matches?(path) #:nodoc:
-        case self.from
-        when Regexp
+      def matches?(rack_env) #:nodoc:
+        return false if !guard.nil? && !guard.call(rack_env)
+        path = rack_env['REQUEST_URI']
+        if self.from.is_a?(Regexp) || (Object.const_defined?(:Oniguruma) && self.from.is_a?(Oniguruma::ORegexp))
           path =~ self.from
-        when String
+        elsif self.from.is_a?(String)
           path == self.from
         else
           false
@@ -58,7 +84,7 @@ module Rack
       # Either (a) return a Rack response (short-circuiting the Rack stack), or
       # (b) alter env as necessary and return true
       def apply!(env) #:nodoc:
-        interpreted_to = self.send(:interpret_to, env['REQUEST_URI'])
+        interpreted_to = self.send(:interpret_to, env['REQUEST_URI'], env)
         case self.rule_type
         when :r301
           [301, {'Location' => interpreted_to, 'Content-Type' => 'text/html'}, ['Redirecting...']]
@@ -75,25 +101,50 @@ module Rack
             env['QUERYSTRING'] = ''
           end
           true
+        when :send_file
+          [200, {
+            'Content-Length' => ::File.size(interpreted_to).to_s,
+            'Content-Type'   => Rack::Mime.mime_type(::File.extname(interpreted_to))
+            }, ::File.read(interpreted_to)]
+        when :x_send_file
+          [200, {
+            'X-Sendfile'     => interpreted_to,
+            'Content-Length' => ::File.size(interpreted_to).to_s,
+            'Content-Type'   => Rack::Mime.mime_type(::File.extname(interpreted_to))
+            }, []]
         else
           raise Exception.new("Unsupported rule: #{self.rule_type}")
         end
       end
       
       private
-        # is there a better way to do this?
-        def interpret_to(path) #:nodoc:
-          if self.from.is_a?(Regexp)
-            if from_match_data = self.from.match(path)
-              computed_to = self.to.dup
-              (from_match_data.size - 1).downto(1) do |num|
-                computed_to.gsub!("$#{num}", from_match_data[num])
-              end
-              return computed_to
-            end
-          end
+        def interpret_to(path, env={}) #:nodoc:
+          return interpret_to_proc(path, env) if self.to.is_a?(Proc)
+          return computed_to(path) if compute_to?(path)
           self.to
         end
-    end 
+
+        def interpret_to_proc(path, env)
+          return self.to.call(match(path), env) if self.from.is_a?(Regexp)
+          self.to.call(self.from, env)
+        end
+
+        def compute_to?(path)
+          self.from.is_a?(Regexp) && match(path)
+        end
+
+        def match(path) 
+          self.from.match(path)
+        end
+
+        def computed_to(path)
+          # is there a better way to do this?
+          computed_to = self.to.dup
+          (match(path).size - 1).downto(1) do |num|
+            computed_to.gsub!("$#{num}", match(path)[num])
+          end
+          return computed_to
+        end
+    end
   end
-end
+end

data/rack-rewrite.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rack-rewrite}
-  s.version = "0.1.3"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["John Trupiano"]
@@ -19,7 +19,7 @@ Gem::Specification.new do |s|
   s.files = [
     ".document",
      ".gitignore",
-     "HISTORY.rdoc",
+     "History.rdoc",
      "LICENSE",
      "README.rdoc",
      "Rakefile",
@@ -28,6 +28,7 @@ Gem::Specification.new do |s|
      "lib/rack-rewrite.rb",
      "lib/rack-rewrite/rule.rb",
      "rack-rewrite.gemspec",
+     "test/geminstaller.yml",
      "test/rack-rewrite_test.rb",
      "test/rule_test.rb",
      "test/test_helper.rb"

data/test/geminstaller.yml

@@ -0,0 +1,9 @@
+gems:
+- name: jeweler
+  version: '~> 1.3.0'
+- name: shoulda
+  version: '~> 2.10.2'
+- name: mocha
+  version: '~> 0.9.7'
+- name: oniguruma
+  version: '~> 1.1.0'

data/test/rule_test.rb

@@ -1,7 +1,36 @@
-require 'test_helper'
+require File.join(File.dirname(__FILE__), 'test_helper')
 
 class RuleTest < Test::Unit::TestCase
+  
+  def self.should_pass_maintenance_tests
+    context 'and the maintenance file does in fact exist' do
+      setup { File.stubs(:exists?).returns(true) }
 
+      should('match for the root')              { assert @rule.matches?({'REQUEST_URI' => '/'}) }
+      should('match for a regular rails route') { assert @rule.matches?({'REQUEST_URI' => '/users/1'}) }
+      should('match for an html page')          { assert @rule.matches?({'REQUEST_URI' => '/index.html'}) }
+      should('not match for a css file')        { assert !@rule.matches?({'REQUEST_URI' => '/stylesheets/style.css'}) }
+      should('not match for a jpg file')        { assert !@rule.matches?({'REQUEST_URI' => '/images/sls.jpg'}) }
+      should('not match for a png file')        { assert !@rule.matches?({'REQUEST_URI' => '/images/sls.png'}) }
+    end
+  end
+  
+  def self.negative_lookahead_supported?
+    begin
+      require 'oniguruma'
+    rescue LoadError; end
+    RUBY_VERSION =~ /^1\.9/ || Object.const_defined?(:Oniguruma)
+  end
+  
+  def negative_lookahead_regexp
+    if RUBY_VERSION =~ /^1\.9/
+      # have to use the constructor instead of the literal syntax b/c load errors occur in Ruby 1.8
+      Regexp.new("(.*)$(?<!css|png|jpg)")
+    else
+      Oniguruma::ORegexp.new("(.*)$(?<!css|png|jpg)")
+    end
+  end
+  
   context '#Rule#apply' do
     should 'set Location header to result of #interpret_to for a 301' do
       rule = Rack::Rewrite::Rule.new(:r301, %r{/abc}, '/def')
@@ -40,6 +69,64 @@ class RuleTest < Test::Unit::TestCase
         assert_equal 'text/html', rule.apply!(env)[1]['Content-Type']
       end
     end
+    
+    context 'Given an :x_send_file rule that matches' do
+      setup do
+        @file = File.join(TEST_ROOT, 'geminstaller.yml')
+        @rule = Rack::Rewrite::Rule.new(:x_send_file, /.*/, @file)
+        env = {'PATH_INFO' => '/abc'}
+        @response = @rule.apply!(env)
+      end
+      
+      should 'return 200' do
+        assert_equal 200, @response[0]
+      end
+      
+      should 'return an X-Sendfile header' do
+        assert @response[1].has_key?('X-Sendfile')
+      end
+      
+      should 'return a Content-Type of text/yaml' do
+        assert_equal 'text/yaml', @response[1]['Content-Type']
+      end
+      
+      should 'return the proper Content-Length' do
+        assert_equal File.size(@file).to_s, @response[1]['Content-Length']
+      end
+      
+      should 'return empty content' do
+        assert_equal [], @response[2]
+      end
+    end
+    
+    context 'Given a :send_file rule that matches' do
+      setup do
+        @file = File.join(TEST_ROOT, 'geminstaller.yml')
+        @rule = Rack::Rewrite::Rule.new(:send_file, /.*/, @file)
+        env = {'PATH_INFO' => '/abc'}
+        @response = @rule.apply!(env)
+      end
+      
+      should 'return 200' do
+        assert_equal 200, @response[0]
+      end
+      
+      should 'not return an X-Sendfile header' do
+        assert !@response[1].has_key?('X-Sendfile')
+      end
+      
+      should 'return a Content-Type of text/yaml' do
+        assert_equal 'text/yaml', @response[1]['Content-Type']
+      end
+      
+      should 'return the proper Content-Length' do
+        assert_equal File.size(@file).to_s, @response[1]['Content-Length']
+      end
+      
+      should 'return the contents of geminstaller.yml' do
+        assert_equal File.read(@file), @response[2]
+      end
+    end
   end
   
   context 'Rule#matches' do
@@ -49,15 +136,15 @@ class RuleTest < Test::Unit::TestCase
       end
       
       should 'match PATH_INFO of /features' do
-        assert @rule.matches?("/features")
+        assert @rule.matches?({'REQUEST_URI' => "/features"})
       end
       
       should 'not match PATH_INFO of /features.xml' do
-        assert !@rule.matches?("/features.xml")
+        assert !@rule.matches?({'REQUEST_URI' => "/features.xml"})
       end
       
       should 'not match PATH_INFO of /my_features' do
-        assert !@rule.matches?("/my_features")
+        assert !@rule.matches?({'REQUEST_URI' => "/my_features"})
       end
     end
     
@@ -67,23 +154,72 @@ class RuleTest < Test::Unit::TestCase
       end
     
       should 'match PATH_INFO of /features' do
-        assert @rule.matches?("/features")
+        assert @rule.matches?({'REQUEST_URI' => "/features"})
       end
     
       should 'match PATH_INFO of /features.xml' do
-        assert @rule.matches?('/features.xml')
+        assert @rule.matches?({'REQUEST_URI' => '/features.xml'})
       end
     
       should 'match PATH_INFO of /features/1' do
-        assert @rule.matches?('/features/1')
+        assert @rule.matches?({'REQUEST_URI' => '/features/1'})
       end
     
       should 'match PATH_INFO of /features?filter_by=name' do
-        assert @rule.matches?('/features?filter_by_name=name')
+        assert @rule.matches?({'REQUEST_URI' => '/features?filter_by_name=name'})
       end
     
       should 'match PATH_INFO of /features/1?hide_bio=1' do
-        assert @rule.matches?('/features/1?hide_bio=1')
+        assert @rule.matches?({'REQUEST_URI' => '/features/1?hide_bio=1'})
+      end
+    end
+    
+    context 'Given a rule with a guard that checks for the presence of a file' do
+      setup do
+        @rule = Rack::Rewrite::Rule.new(:rewrite, %r{(.)*}, '/maintenance.html', lambda { |rack_env|
+          File.exists?('maintenance.html')
+        })
+      end
+      
+      context 'when the file exists' do
+        setup do
+          File.stubs(:exists?).returns(true)
+        end
+        
+        should 'match' do
+          assert @rule.matches?({'REQUEST_URI' => '/anything/should/match'})
+        end
+      end
+      
+      context 'when the file does not exist' do
+        setup do
+          File.stubs(:exists?).returns(false)
+        end
+        
+        should 'not match' do
+          assert !@rule.matches?({'REQUEST_URI' => '/nothing/should/match'})
+        end
+      end
+    end
+    
+    context 'Given the capistrano maintenance.html rewrite rule given in our README' do
+      setup do
+        @rule = Rack::Rewrite::Rule.new(:rewrite, /.*/, '/system/maintenance.html', lambda { |rack_env|
+          maintenance_file = File.join('system', 'maintenance.html')
+          File.exists?(maintenance_file) && !%w(css jpg png).any? {|ext| rack_env['REQUEST_URI'] =~ Regexp.new("\.#{ext}$")}
+        })
+      end
+      should_pass_maintenance_tests
+    end
+    
+    if negative_lookahead_supported?
+      context 'Given the negative lookahead regular expression version of the capistrano maintenance.html rewrite rule given in our README' do
+        setup do
+          @rule = Rack::Rewrite::Rule.new(:rewrite, negative_lookahead_regexp, '/system/maintenance.html', lambda { |rack_env|
+            File.exists?(File.join('public', 'system', 'maintenance.html'))
+          })
+        end
+        should_pass_maintenance_tests
       end
     end
   end
@@ -109,5 +245,16 @@ class RuleTest < Test::Unit::TestCase
       rule = Rack::Rewrite::Rule.new(:rewrite, %r{(\w)(\w)(\w)(\w)(\w)(\w)(\w)(\w)(\w)(\w)}, '$10$9$8$7$6$5$4$3$2$1')
       assert_equal 'jihgfedcba', rule.send(:interpret_to, "abcdefghij")
     end
+
+    should 'call to with from when it is a lambda' do
+      rule = Rack::Rewrite::Rule.new(:rewrite, 'a', lambda { |from, env| from * 2 })
+      assert_equal 'aa', rule.send(:interpret_to, 'a')
+    end
+
+    should 'call to with from match data' do
+      rule = Rack::Rewrite::Rule.new(:rewrite, %r{/person_(\d+)(.*)}, lambda {|match, env| "people-#{match[1].to_i * 3}#{match[2]}"})
+      assert_equal 'people-3?show_bio=1', rule.send(:interpret_to, '/person_1?show_bio=1')
+    end
   end
+  
 end

data/test/test_helper.rb

@@ -11,3 +11,5 @@ require 'rack-rewrite'
 
 class Test::Unit::TestCase
 end
+
+TEST_ROOT = File.dirname(__FILE__)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rack-rewrite
 version: !ruby/object:Gem::Version 
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors: 
 - John Trupiano
@@ -34,7 +34,7 @@ extra_rdoc_files:
 files: 
 - .document
 - .gitignore
-- HISTORY.rdoc
+- History.rdoc
 - LICENSE
 - README.rdoc
 - Rakefile
@@ -43,6 +43,7 @@ files:
 - lib/rack-rewrite.rb
 - lib/rack-rewrite/rule.rb
 - rack-rewrite.gemspec
+- test/geminstaller.yml
 - test/rack-rewrite_test.rb
 - test/rule_test.rb
 - test/test_helper.rb

data/HISTORY.rdoc

@@ -1,10 +0,0 @@
-=== 0.1.3 / 2009-11-14
-* Maintenance
-  * Ensure Content-Type header is set for 301's and 302's (thanks to Sebastian Röbke)
-* Documentation
-  * Add HISTORY.rdoc
-  
-=== 0.1.2 / 2009-10-15
-* API
-  * rewrite, r301 and r302 rules
-  * regular expression matching and substitution rules