rack-rewrite 0.2.1 → 1.0.0

data/History.rdoc

@@ -1,3 +1,9 @@
+=== 1.0.0 / 2010-05-13
+* API
+  * Fix rack 1.1.0 / rails3 compatibility by eliminating reliance on REQUEST_URI env param.  Paths are now constructed with PATH_INFO and QUERY_STRING
+  * Follow rack directory/require convention: require 'rack/rewrite' instead of 'rack-rewrite'
+  * Include an HTML anchor tag linked to where the URL being redirected to in the body of 301's and 302's
+
 === 0.2.1 / 2010-01-06
 * API
   * Implement $& substitution pattern (thanks to {Ben Brinckerhoff}[http://github.com/bhb])

data/README.rdoc

@@ -15,7 +15,7 @@ can get away with rack-rewrite instead of writing Apache mod_rewrite rules.
 === Sample rackup file
   
   gem 'rack-rewrite', '~> 0.2.1'
-  require 'rack-rewrite
+  require 'rack/rewrite
   use Rack::Rewrite do
     rewrite '/wiki/John_Trupiano', '/john'
     r301 '/wiki/Yair_Flicker', '/yair'
@@ -25,7 +25,7 @@ can get away with rack-rewrite instead of writing Apache mod_rewrite rules.
 
 === Sample usage in a rails app
   config.gem 'rack-rewrite', '~> 0.2.1'
-  require 'rack-rewrite
+  require 'rack/rewrite'
   config.middleware.insert_before(Rack::Lock, Rack::Rewrite) do
     rewrite '/wiki/John_Trupiano', '/john'
     r301 '/wiki/Yair_Flicker', '/yair'
@@ -89,7 +89,7 @@ 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) && rack_env['REQUEST_URI'] !~ /\.(css|jpg|png)/
+    File.exists?(maintenance_file) && rack_env['PATH_INFO'] !~ /\.(css|jpg|png)/
   }
 
 If you're running Ruby 1.9, this rule is simplified:
@@ -111,9 +111,10 @@ get away with:
 
 === :rewrite
 
-Calls to #rewrite will simply update the PATH_INFO and REQUEST_URI HTTP header
-values and pass the request onto the next chain in the Rack stack.  The URL
-that a user's browser will show will not be changed.  See these examples:
+Calls to #rewrite will simply update the PATH_INFO, QUERY_STRING and 
+REQUEST_URI HTTP header values and pass the request onto the next chain in 
+the Rack stack.  The URL that a user's browser will show will not be changed.  
+See these examples:
 
   rewrite '/wiki/John_Trupiano', '/john'   # [1]
   rewrite %r{/wiki/(\w+)_\w+}, '/$1'       # [2]

data/Rakefile

@@ -24,7 +24,7 @@ end
 
 require 'rake/testtask'
 Rake::TestTask.new(:test) do |test|
-  test.libs << 'lib' << 'test'
+  test.libs << 'lib' << 'test' << '.'
   test.pattern = 'test/**/*_test.rb'
   test.verbose = true
 end
@@ -42,8 +42,6 @@ rescue LoadError
   end
 end
 
-task :test => :check_dependencies
-
 task :default => :test
 
 require 'rake/rdoctask'

data/VERSION

@@ -1 +1 @@
-0.2.1
+1.0.0

data/lib/rack-rewrite.rb

@@ -1,29 +1 @@
-$: << File.expand_path(File.dirname(__FILE__))
-
-require 'rack-rewrite/rule'
-
-module Rack
-  # 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.  
-  class Rewrite
-    def initialize(app, &rule_block)
-      @app = app
-      @rule_set = RuleSet.new
-      @rule_set.instance_eval(&rule_block) if block_given?
-    end
-    
-    def call(env)
-      if matched_rule = find_first_matching_rule(env)
-        rack_response = matched_rule.apply!(env)
-        # Don't invoke the app if applying the rule returns a rack response
-        return rack_response unless rack_response === true
-      end
-      @app.call(env)
-    end
-        
-    private
-      def find_first_matching_rule(env) #:nodoc:
-        @rule_set.rules.detect { |rule| rule.matches?(env) }
-      end    
-  end
-end
+require 'rack/rewrite'

data/lib/rack/rewrite.rb

@@ -0,0 +1,27 @@
+require 'rack/rewrite/rule'
+
+module Rack
+  # 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.  
+  class Rewrite
+    def initialize(app, &rule_block)
+      @app = app
+      @rule_set = RuleSet.new
+      @rule_set.instance_eval(&rule_block) if block_given?
+    end
+    
+    def call(env)
+      if matched_rule = find_first_matching_rule(env)
+        rack_response = matched_rule.apply!(env)
+        # Don't invoke the app if applying the rule returns a rack response
+        return rack_response unless rack_response === true
+      end
+      @app.call(env)
+    end
+        
+    private
+      def find_first_matching_rule(env) #:nodoc:
+        @rule_set.rules.detect { |rule| rule.matches?(env) }
+      end    
+  end
+end

data/lib/{rack-rewrite → rack/rewrite}/rule.rb

@@ -71,7 +71,7 @@ module Rack
 
       def matches?(rack_env) #:nodoc:
         return false if !guard.nil? && !guard.call(rack_env)
-        path = rack_env['REQUEST_URI'].nil? ? rack_env['PATH_INFO'] : rack_env['REQUEST_URI']
+        path = build_path_from_env(rack_env)
         if self.is_a_regexp?(self.from)
           path =~ self.from
         elsif self.from.is_a?(String)
@@ -84,12 +84,12 @@ 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.interpret_to(env['REQUEST_URI'], env)
+        interpreted_to = self.interpret_to(env)
         case self.rule_type
         when :r301
-          [301, {'Location' => interpreted_to, 'Content-Type' => 'text/html'}, ['Redirecting...']]
+          [301, {'Location' => interpreted_to, 'Content-Type' => 'text/html'}, [redirect_message(interpreted_to)]]
         when :r302
-          [302, {'Location' => interpreted_to, 'Content-Type' => 'text/html'}, ['Redirecting...']]
+          [302, {'Location' => interpreted_to, 'Content-Type' => 'text/html'}, [redirect_message(interpreted_to)]]
         when :rewrite
           # return [200, {}, {:content => env.inspect}]
           env['REQUEST_URI'] = interpreted_to
@@ -118,7 +118,8 @@ module Rack
       end
       
       protected
-        def interpret_to(path, env={}) #:nodoc:
+        def interpret_to(env) #:nodoc:
+          path = build_path_from_env(env)
           return interpret_to_proc(path, env) if self.to.is_a?(Proc)
           return computed_to(path) if compute_to?(path)
           self.to
@@ -150,7 +151,18 @@ module Rack
             computed_to.gsub!("$#{num}", match(path)[num].to_s)
           end
           return computed_to
-        end        
+        end
+        
+        # Construct the URL (without domain) from PATH_INFO and QUERY_STRING
+        def build_path_from_env(env)
+          path = env['PATH_INFO']
+          path += "?#{env['QUERY_STRING']}" unless env['QUERY_STRING'].nil? || env['QUERY_STRING'].empty?
+          path
+        end
+        
+        def redirect_message(location)
+          %Q(Redirecting to <a href="#{location}">#{location}</a>)
+        end
     end
   end
 end

data/rack-rewrite.gemspec

@@ -5,58 +5,49 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rack-rewrite}
-  s.version = "0.2.1"
+  s.version = "1.0.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["John Trupiano"]
-  s.date = %q{2010-01-06}
+  s.date = %q{2010-05-13}
   s.description = %q{A rack middleware for enforcing rewrite rules. In many cases you can get away with rack-rewrite instead of writing Apache mod_rewrite rules.}
   s.email = %q{jtrupiano@gmail.com}
   s.extra_rdoc_files = [
     "LICENSE",
-     "README.rdoc",
-     "TODO"
+    "History.rdoc",
+    "README.rdoc"
   ]
   s.files = [
     ".document",
-     ".gitignore",
-     "History.rdoc",
-     "LICENSE",
-     "README.rdoc",
-     "Rakefile",
-     "TODO",
-     "VERSION",
-     "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"
+    ".gitignore",
+    "History.rdoc",
+    "LICENSE",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "lib/rack-rewrite.rb",
+    "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"
   ]
   s.homepage = %q{http://github.com/jtrupiano/rack-rewrite}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
   s.rubyforge_project = %q{johntrupiano}
-  s.rubygems_version = %q{1.3.5}
+  s.rubygems_version = %q{1.3.6}
   s.summary = %q{A rack middleware for enforcing rewrite rules}
   s.test_files = [
     "test/rack-rewrite_test.rb",
-     "test/rule_test.rb",
-     "test/test_helper.rb"
+    "test/rule_test.rb",
+    "test/test_helper.rb"
   ]
 
   if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
-
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<shoulda>, [">= 0"])
-    else
-      s.add_dependency(%q<shoulda>, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<shoulda>, [">= 0"])
   end
 end
 

data/test/geminstaller.yml

@@ -1,9 +1,9 @@
 gems:
-- name: jeweler
-  version: '~> 1.3.0'
 - name: shoulda
-  version: '~> 2.10.2'
+  version: '= 2.10.3'
 - name: mocha
-  version: '~> 0.9.7'
-- name: oniguruma
-  version: '~> 1.1.0'
+  version: '= 0.9.8'
+- name: rack
+  version: '= 1.1.0'
+# - name: oniguruma
+#   version: '= 1.1.0'

data/test/rule_test.rb

@@ -2,16 +2,18 @@ require File.join(File.dirname(__FILE__), 'test_helper')
 
 class RuleTest < Test::Unit::TestCase
   
+  TEST_ROOT = File.dirname(__FILE__)
+  
   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'}) }
+      should('match for the root')              { assert @rule.matches?(rack_env_for('/')) }
+      should('match for a regular rails route') { assert @rule.matches?(rack_env_for('/users/1')) }
+      should('match for an html page')          { assert @rule.matches?(rack_env_for('/index.html')) }
+      should('not match for a css file')        { assert !@rule.matches?(rack_env_for('/stylesheets/style.css')) }
+      should('not match for a jpg file')        { assert !@rule.matches?(rack_env_for('/images/sls.jpg')) }
+      should('not match for a png file')        { assert !@rule.matches?(rack_env_for('/images/sls.png')) }
     end
   end
   
@@ -38,15 +40,21 @@ class RuleTest < Test::Unit::TestCase
       assert_equal rule.send(:interpret_to, '/abc'), rule.apply!(env)[1]['Location']
     end
     
+    should 'include a link to the result of #interpret_to for a 301' do
+      rule = Rack::Rewrite::Rule.new(:r301, %r{/abc}, '/def')
+      env = {'PATH_INFO' => '/abc'}
+      assert_match /\/def/, rule.apply!(env)[2][0]
+    end
+    
     should 'keep the QUERY_STRING when a 301 rule matches a URL with a querystring' do
       rule = Rack::Rewrite::Rule.new(:r301, %r{/john(.*)}, '/yair$1')
-      env = {'REQUEST_URI' => '/john?show_bio=1', 'PATH_INFO' => '/john', 'QUERY_STRING' => 'show_bio=1'}
+      env = {'PATH_INFO' => '/john', 'QUERY_STRING' => 'show_bio=1'}
       assert_equal '/yair?show_bio=1', rule.apply!(env)[1]['Location']
     end
     
     should 'keep the QUERY_STRING when a rewrite rule that requires a querystring matches a URL with a querystring' do
       rule = Rack::Rewrite::Rule.new(:rewrite, %r{/john(\?.*)}, '/yair$1')
-      env = {'REQUEST_URI' => '/john?show_bio=1', 'PATH_INFO' => '/john', 'QUERY_STRING' => 'show_bio=1'}
+      env = {'PATH_INFO' => '/john', 'QUERY_STRING' => 'show_bio=1'}
       rule.apply!(env)
       assert_equal '/yair', env['PATH_INFO']
       assert_equal 'show_bio=1', env['QUERY_STRING']
@@ -55,7 +63,7 @@ class RuleTest < Test::Unit::TestCase
     
     should 'update the QUERY_STRING when a rewrite rule changes its value' do
       rule = Rack::Rewrite::Rule.new(:rewrite, %r{/(\w+)\?show_bio=(\d)}, '/$1?bio=$2')
-      env = {'REQUEST_URI' => '/john?show_bio=1', 'PATH_INFO' => '/john', 'QUERY_STRING' => 'show_bio=1'}
+      env = {'PATH_INFO' => '/john', 'QUERY_STRING' => 'show_bio=1'}
       rule.apply!(env)
       assert_equal '/john', env['PATH_INFO']
       assert_equal 'bio=1', env['QUERY_STRING']
@@ -136,41 +144,46 @@ class RuleTest < Test::Unit::TestCase
       end
       
       should 'match PATH_INFO of /features' do
-        assert @rule.matches?({'REQUEST_URI' => "/features"})
+        assert @rule.matches?(rack_env_for("/features"))
       end
       
       should 'not match PATH_INFO of /features.xml' do
-        assert !@rule.matches?({'REQUEST_URI' => "/features.xml"})
+        assert !@rule.matches?(rack_env_for("/features.xml"))
       end
       
       should 'not match PATH_INFO of /my_features' do
-        assert !@rule.matches?({'REQUEST_URI' => "/my_features"})
+        assert !@rule.matches?(rack_env_for("/my_features"))
       end
     end
     
+    should 'match with the ^ operator for regexps' do
+      rule = Rack::Rewrite::Rule.new(:rewrite, %r{^/jason}, '/steve')
+      assert rule.matches?(rack_env_for('/jason'))
+    end
+        
     context 'Given any rule with a "from" regular expression of /features(.*)' do
       setup do
         @rule = Rack::Rewrite::Rule.new(:rewrite, %r{/features(.*)}, '/facial_features$1')
       end
     
       should 'match PATH_INFO of /features' do
-        assert @rule.matches?({'REQUEST_URI' => "/features"})
+        assert @rule.matches?(rack_env_for("/features"))
       end
     
       should 'match PATH_INFO of /features.xml' do
-        assert @rule.matches?({'REQUEST_URI' => '/features.xml'})
+        assert @rule.matches?(rack_env_for('/features.xml'))
       end
     
       should 'match PATH_INFO of /features/1' do
-        assert @rule.matches?({'REQUEST_URI' => '/features/1'})
+        assert @rule.matches?(rack_env_for('/features/1'))
       end
     
       should 'match PATH_INFO of /features?filter_by=name' do
-        assert @rule.matches?({'REQUEST_URI' => '/features?filter_by_name=name'})
+        assert @rule.matches?(rack_env_for('/features?filter_by_name=name'))
       end
     
       should 'match PATH_INFO of /features/1?hide_bio=1' do
-        assert @rule.matches?({'REQUEST_URI' => '/features/1?hide_bio=1'})
+        assert @rule.matches?(rack_env_for('/features/1?hide_bio=1'))
       end
     end
     
@@ -187,7 +200,7 @@ class RuleTest < Test::Unit::TestCase
         end
         
         should 'match' do
-          assert @rule.matches?({'REQUEST_URI' => '/anything/should/match'})
+          assert @rule.matches?(rack_env_for('/anything/should/match'))
         end
       end
       
@@ -197,7 +210,7 @@ class RuleTest < Test::Unit::TestCase
         end
         
         should 'not match' do
-          assert !@rule.matches?({'REQUEST_URI' => '/nothing/should/match'})
+          assert !@rule.matches?(rack_env_for('/nothing/should/match'))
         end
       end
     end
@@ -206,7 +219,7 @@ class RuleTest < Test::Unit::TestCase
       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) && rack_env['REQUEST_URI'] !~ /\.(css|jpg|png)/
+          File.exists?(maintenance_file) && rack_env['PATH_INFO'] !~ /\.(css|jpg|png)/
         })
       end
       should_pass_maintenance_tests
@@ -231,14 +244,14 @@ class RuleTest < Test::Unit::TestCase
       end
       
       should 'match requests for domain myolddomain.com and redirect to mynewdomain.com' do
-        env = {'REQUEST_URI' => '/anything?abc=1', 'PATH_INFO' => '/anything', 'QUERY_STRING' => 'abc=1', 'SERVER_NAME' => 'myolddomain.com'}
+        env = {'PATH_INFO' => '/anything', 'QUERY_STRING' => 'abc=1', 'SERVER_NAME' => 'myolddomain.com'}
         assert @rule.matches?(env)
         rack_response = @rule.apply!(env)
         assert_equal 'http://mynewdomain.com/anything?abc=1', rack_response[1]['Location']
       end
       
       should 'not match requests for domain mynewdomain.com' do
-        assert !@rule.matches?({'REQUEST_URI' => '/anything', 'SERVER_NAME' => 'mynewdomain.com'})
+        assert !@rule.matches?({'PATH_INFO' => '/anything', 'SERVER_NAME' => 'mynewdomain.com'})
       end
     end
   end
@@ -246,44 +259,48 @@ class RuleTest < Test::Unit::TestCase
   context 'Rule#interpret_to' do
     should 'return #to when #from is a string' do
       rule = Rack::Rewrite::Rule.new(:rewrite, '/abc', '/def')
-      assert_equal '/def', rule.send(:interpret_to, '/abc')
+      assert_equal '/def', rule.send(:interpret_to, rack_env_for('/abc'))
     end
     
     should 'replace $1 on a match' do
       rule = Rack::Rewrite::Rule.new(:rewrite, %r{/person_(\d+)}, '/people/$1')
-      assert_equal '/people/1', rule.send(:interpret_to, "/person_1")
+      assert_equal '/people/1', rule.send(:interpret_to, rack_env_for("/person_1"))
     end
     
     should 'be able to catch querystrings with a regexp match' do
       rule = Rack::Rewrite::Rule.new(:rewrite, %r{/person_(\d+)(.*)}, '/people/$1$2')
-      assert_equal '/people/1?show_bio=1', rule.send(:interpret_to, '/person_1?show_bio=1')
+      assert_equal '/people/1?show_bio=1', rule.send(:interpret_to, rack_env_for('/person_1?show_bio=1'))
     end
     
     should 'be able to make 10 replacements' do
       # regexp to reverse 10 characters
       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")
+      assert_equal 'jihgfedcba', rule.send(:interpret_to, rack_env_for("abcdefghij"))
     end
 
     should 'replace $& on a match' do
       rule = Rack::Rewrite::Rule.new(:rewrite, %r{.*}, 'http://example.org$&')
-      assert_equal 'http://example.org/person/1', rule.send(:interpret_to, "/person/1")
+      assert_equal 'http://example.org/person/1', rule.send(:interpret_to, rack_env_for("/person/1"))
     end
 
     should 'ignore empty captures' do
       rule = Rack::Rewrite::Rule.new(:rewrite, %r{/person(_\d+)?}, '/people/$1')
-      assert_equal '/people/', rule.send(:interpret_to, "/person")
+      assert_equal '/people/', rule.send(:interpret_to, rack_env_for("/person"))
     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')
+      assert_equal 'aa', rule.send(:interpret_to, rack_env_for('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')
+      assert_equal 'people-3?show_bio=1', rule.send(:interpret_to, rack_env_for('/person_1?show_bio=1'))
     end
   end
   
+  def rack_env_for(url)
+    components = url.split('?')
+    {'PATH_INFO' => components[0], 'QUERY_STRING' => components[1] || ''}
+  end
 end

data/test/test_helper.rb

@@ -7,9 +7,7 @@ require 'mocha'
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
-require 'rack-rewrite'
+require 'rack/rewrite'
 
 class Test::Unit::TestCase
 end
-
-TEST_ROOT = File.dirname(__FILE__)

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: rack-rewrite
 version: !ruby/object:Gem::Version 
-  version: 0.2.1
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
 platform: ruby
 authors: 
 - John Trupiano
@@ -9,19 +14,10 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-06 00:00:00 -05:00
+date: 2010-05-13 00:00:00 -04:00
 default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: shoulda
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
-    version: 
+dependencies: []
+
 description: A rack middleware for enforcing rewrite rules. In many cases you can get away with rack-rewrite instead of writing Apache mod_rewrite rules.
 email: jtrupiano@gmail.com
 executables: []
@@ -30,8 +26,8 @@ extensions: []
 
 extra_rdoc_files: 
 - LICENSE
+- History.rdoc
 - README.rdoc
-- TODO
 files: 
 - .document
 - .gitignore
@@ -39,10 +35,10 @@ files:
 - LICENSE
 - README.rdoc
 - Rakefile
-- TODO
 - VERSION
 - lib/rack-rewrite.rb
-- lib/rack-rewrite/rule.rb
+- lib/rack/rewrite.rb
+- lib/rack/rewrite/rule.rb
 - rack-rewrite.gemspec
 - test/geminstaller.yml
 - test/rack-rewrite_test.rb
@@ -61,18 +57,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: johntrupiano
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: A rack middleware for enforcing rewrite rules

data/TODO

@@ -1,9 +0,0 @@
-* 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]