rack-rewrite-matches 1.3.3

data/VERSION

@@ -0,0 +1 @@
+1.3.3

data/lib/rack-rewrite.rb

@@ -0,0 +1 @@
+require 'rack/rewrite'

data/lib/rack/rewrite.rb

@@ -0,0 +1,28 @@
+module Rack
+  autoload :RuleSet, 'rack/rewrite/rule'
+  autoload :VERSION, 'rack/rewrite/version'
+  
+  # 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/rule.rb

@@ -0,0 +1,247 @@
+require 'rack/mime'
+
+module Rack
+  class Rewrite
+    class RuleSet
+      attr_reader :rules
+      def initialize #:nodoc:
+        @rules = []
+      end
+
+      protected
+        # We're explicitly defining private functions for our DSL rather than
+        # using method_missing
+
+        # Creates a rewrite rule that will simply rewrite the REQUEST_URI,
+        # PATH_INFO, and QUERY_STRING headers of the Rack environment.  The
+        # user's browser will continue to show the initially requested URL.
+        #
+        #  rewrite '/wiki/John_Trupiano', '/john'
+        #  rewrite %r{/wiki/(\w+)_\w+}, '/$1'
+        #  rewrite %r{(.*)}, '/maintenance.html', :if => lambda { File.exists?('maintenance.html') }
+        def rewrite(*args)
+          add_rule :rewrite, *args
+        end
+
+        # Creates a redirect rule that will send a 301 when matching.
+        #
+        #  r301 '/wiki/John_Trupiano', '/john'
+        #  r301 '/contact-us.php', '/contact-us'
+        #
+        # You can use +moved_permanently+ or just +p+ instead of +r301+.
+        def r301(*args)
+          add_rule :r301, *args
+        end
+
+        alias :moved_permanently :r301
+        alias :p :r301
+
+        # Creates a redirect rule that will send a 302 when matching.
+        #
+        #  r302 '/wiki/John_Trupiano', '/john'
+        #  r302 '/wiki/(.*)', 'http://www.google.com/?q=$1'
+        #
+        # You can use +found+ instead of +r302+.
+        def r302(*args)
+          add_rule :r302, *args
+        end
+
+        alias :found :r302
+
+        # Creates a redirect rule that will send a 303 when matching.
+        #
+        #  r303 '/wiki/John_Trupiano', '/john'
+        #  r303 '/wiki/(.*)', 'http://www.google.com/?q=$1'
+        #
+        # You can use +see_other+ instead of +r303+.
+        def r303(*args)
+          add_rule :r303, *args
+        end
+
+        alias :see_other :r303
+
+        # Creates a redirect rule that will send a 307 when matching.
+        #
+        #  r307 '/wiki/John_Trupiano', '/john'
+        #  r307 '/wiki/(.*)', 'http://www.google.com/?q=$1'
+        #
+        # You can use +temporary_redirect+ or +t+ instead of +r307+.
+        def r307(*args)
+          add_rule :r307, *args
+        end
+
+        alias :temporary_redirect :r307
+        alias :t :r307
+
+        # Creates a rule that will render a file if matched.
+        #
+        #  send_file /*/, 'public/system/maintenance.html',
+        #    :if => Proc.new { File.exists?('public/system/maintenance.html') }
+        def send_file(*args)
+          add_rule :send_file, *args
+        end
+
+        # Creates a rule that will render a file using x-send-file
+        # if matched.
+        #
+        #  x_send_file /*/, 'public/system/maintenance.html',
+        #    :if => Proc.new { File.exists?('public/system/maintenance.html') }
+        def x_send_file(*args)
+          add_rule :x_send_file, *args
+        end
+
+      private
+        def add_rule(method, from, to, options = {}) #:nodoc:
+          @rules << Rule.new(method.to_sym, from, to, options)
+        end
+
+    end
+
+    # TODO: Break rules into subclasses
+    class Rule #:nodoc:
+      attr_reader :rule_type, :from, :to, :options
+      def initialize(rule_type, from, to, options={}) #:nodoc:
+        @rule_type, @from, @to, @options = rule_type, from, to, normalize_options(options)
+      end
+
+      def matches?(rack_env) #:nodoc:
+        return false if options[:if].respond_to?(:call) && !options[:if].call(rack_env)
+        path = build_path_from_env(rack_env)
+
+        self.match_options?(rack_env) && string_matches?(path, self.from)
+      end
+
+      # 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)
+        additional_headers = {}
+        if @options[:headers]
+          if @options[:headers].respond_to?(:call)
+            additional_headers = @options[:headers].call(*@matches) || {}
+          else
+            additional_headers = @options[:headers] || {}
+          end
+        end
+        status = @options[:status] || 200
+        case self.rule_type
+        when :r301
+          [301, {'Location' => interpreted_to, 'Content-Type' => Rack::Mime.mime_type(::File.extname(interpreted_to))}.merge!(additional_headers), [redirect_message(interpreted_to)]]
+        when :r302
+          [302, {'Location' => interpreted_to, 'Content-Type' => Rack::Mime.mime_type(::File.extname(interpreted_to))}.merge!(additional_headers), [redirect_message(interpreted_to)]]
+        when :r303
+          [303, {'Location' => interpreted_to, 'Content-Type' => Rack::Mime.mime_type(::File.extname(interpreted_to))}.merge!(additional_headers), [redirect_message(interpreted_to)]]
+        when :r307
+          [307, {'Location' => interpreted_to, 'Content-Type' => Rack::Mime.mime_type(::File.extname(interpreted_to))}.merge!(additional_headers), [redirect_message(interpreted_to)]]
+        when :rewrite
+          # return [200, {}, {:content => env.inspect}]
+          env['REQUEST_URI'] = interpreted_to
+          if q_index = interpreted_to.index('?')
+            env['PATH_INFO'] = interpreted_to[0..q_index-1]
+            env['QUERY_STRING'] = interpreted_to[q_index+1..interpreted_to.size-1]
+          else
+            env['PATH_INFO'] = interpreted_to
+            env['QUERY_STRING'] = ''
+          end
+          true
+        when :send_file
+          [status, {
+            'Content-Length' => ::File.size(interpreted_to).to_s,
+            'Content-Type'   => Rack::Mime.mime_type(::File.extname(interpreted_to))
+            }.merge!(additional_headers), [::File.read(interpreted_to)]]
+        when :x_send_file
+          [status, {
+            'X-Sendfile'     => interpreted_to,
+            'Content-Length' => ::File.size(interpreted_to).to_s,
+            'Content-Type'   => Rack::Mime.mime_type(::File.extname(interpreted_to))
+            }.merge!(additional_headers), []]
+        else
+          raise Exception.new("Unsupported rule: #{self.rule_type}")
+        end
+      end
+
+      protected
+        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
+        end
+
+        def is_a_regexp?(obj)
+          obj.is_a?(Regexp) || (Object.const_defined?(:Oniguruma) && obj.is_a?(Oniguruma::ORegexp))
+        end
+
+        def match_options?(env, path = build_path_from_env(env))
+          matches = []
+          request = Rack::Request.new(env)
+
+          # negative matches
+          matches << !string_matches?(path, options[:not]) if options[:not]
+
+          # possitive matches
+          matches << string_matches?(env['REQUEST_METHOD'], options[:method]) if options[:method]
+          matches << string_matches?(request.host, options[:host]) if options[:host]
+          matches << string_matches?(request.scheme, options[:scheme]) if options[:scheme]
+
+          matches.all?
+        end
+
+      private
+        def normalize_options(arg)
+          options = arg.respond_to?(:call) ? {:if => arg} : arg
+          options.symbolize_keys! if options.respond_to? :symbolize_keys!
+          options.freeze
+        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.is_a_regexp?(from) && match(path)
+        end
+
+        def match(path)
+          self.from.match(path)
+        end
+
+        def string_matches?(string, matcher)
+          if self.is_a_regexp?(matcher)
+            string =~ matcher
+          elsif matcher.is_a?(String)
+            string == matcher
+          elsif matcher.is_a?(Symbol)
+            string.downcase == matcher.to_s.downcase
+          else
+            false
+          end
+        end
+
+        def computed_to(path)
+          # is there a better way to do this?
+          computed_to = self.to.dup
+          computed_to.gsub!("$&",match(path).to_s)
+          @matches = []
+          (match(path).size - 1).downto(1) do |num|
+            m = match(path)[num].to_s
+            @matches << m
+            computed_to.gsub!("$#{num}", m)
+          end
+          return computed_to
+        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/lib/rack/rewrite/version.rb

@@ -0,0 +1,5 @@
+module Rack
+  class Rewrite
+    VERSION = File.read File.join(File.expand_path("..", __FILE__), "..", "..", "..", "VERSION")
+  end
+end

data/rack-rewrite.gemspec

@@ -0,0 +1,54 @@
+Gem::Specification.new do |s|
+  s.name = 'rack-rewrite-matches'
+  s.version = File.read('VERSION')
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Travis Jeffery", "John Trupiano"]
+  s.date = Date.today.to_s
+  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{travisjeffery@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "History.rdoc",
+  ]
+  s.files = [
+    "History.rdoc",
+    "LICENSE",
+    "README.markdown",
+    "Rakefile",
+    "VERSION",
+    "Gemfile",
+    "lib/rack-rewrite.rb",
+    "lib/rack/rewrite.rb",
+    "lib/rack/rewrite/rule.rb",
+    "lib/rack/rewrite/version.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.7}
+  s.summary = %q{A rack middleware for enforcing rewrite rules}
+  s.test_files = [
+    "test/rack-rewrite_test.rb",
+    "test/geminstaller.yml",
+    "test/rack-rewrite_test.rb",
+    "test/rule_test.rb",
+    "test/test_helper.rb"
+  ]
+  
+  s.add_development_dependency 'bundler'
+  s.add_development_dependency 'shoulda', '~> 2.10.2'
+  s.add_development_dependency 'mocha', '~> 0.9.7'
+  s.add_development_dependency 'rack'
+  
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+  end
+end
+

data/test/geminstaller.yml

@@ -0,0 +1,9 @@
+gems:
+- name: shoulda
+  version: '= 2.10.3'
+- name: mocha
+  version: '= 0.9.8'
+- name: rack
+  version: '= 1.1.0'
+# - name: oniguruma
+#   version: '= 1.1.0'

data/test/rack-rewrite_test.rb

@@ -0,0 +1,136 @@
+require 'test_helper'
+
+class RackRewriteTest < Test::Unit::TestCase
+
+  def call_args(overrides={})
+    {'REQUEST_URI' => '/wiki/Yair_Flicker', 'PATH_INFO' => '/wiki/Yair_Flicker', 'QUERY_STRING' => ''}.merge(overrides)
+  end
+  
+  def call_args_no_req(overrides={})
+    {'PATH_INFO' => '/wiki/Yair_Flicker', 'QUERY_STRING' => ''}.merge(overrides)
+  end
+  
+  def self.should_not_halt
+    should "not halt the rack chain" do
+      @app.expects(:call).once
+      @rack.call(call_args)
+    end
+  end
+  
+  def self.should_be_a_rack_response
+    should 'be a rack a response' do
+      ret = @rack.call(call_args)
+      assert ret.is_a?(Array), 'return value is not a valid rack response'
+      assert_equal 3, ret.size, 'should have 3 arguments'
+    end
+  end
+  
+  def self.should_halt
+    should "should halt the rack chain" do
+      @app.expects(:call).never
+      @rack.call(call_args)
+    end
+    should_be_a_rack_response
+  end
+      
+  def self.should_location_redirect_to(location, code)
+    should "respond with http status code #{code}" do
+      ret = @rack.call(call_args)
+      assert_equal code, ret[0]
+    end
+    should 'send a location header' do
+      ret = @rack.call(call_args)
+      assert_equal location, ret[1]['Location'], 'Location is incorrect'
+    end
+  end
+  
+  context 'Given an app' do
+    setup do
+      @app = Class.new { def call(app); true; end }.new
+    end
+  
+    context 'when no rewrite rule matches' do
+      setup {
+        @rack = Rack::Rewrite.new(@app)
+      }
+      should_not_halt
+    end
+    
+    [301, 302, 303, 307].each do |status|
+      context "when a #{status} rule matches" do
+        setup {
+          @rack = Rack::Rewrite.new(@app) do
+            send("r#{status}", '/wiki/Yair_Flicker', '/yair')
+          end
+        }
+        should_halt
+        should_location_redirect_to('/yair', status)
+      end
+    end
+    
+    [[:p, 301], [:moved_permanently, 301], [:found, 302], [:see_other, 303], [:t, 307], [:temporary_redirect, 307]].each do |rule|
+      context "when a #{rule.first} rule matches" do
+        setup {
+          @rack = Rack::Rewrite.new(@app) do
+            send(rule.first, '/wiki/Yair_Flicker', '/yair')
+          end
+        }
+        should_halt
+        should_location_redirect_to('/yair', rule.last)
+      end
+    end
+    
+    context 'when a rewrite rule matches' do
+      setup {
+        @rack = Rack::Rewrite.new(@app) do
+          rewrite '/wiki/Yair_Flicker', '/john'
+        end
+      }
+      should_not_halt
+      
+      context 'the env' do
+        setup do
+          @initial_args = call_args.dup
+          @rack.call(@initial_args)
+        end
+        
+        should "set PATH_INFO to '/john'" do
+          assert_equal '/john', @initial_args['PATH_INFO']
+        end
+        should "set REQUEST_URI to '/john'" do
+          assert_equal '/john', @initial_args['REQUEST_URI']
+        end
+        should "set QUERY_STRING to ''" do
+          assert_equal '', @initial_args['QUERY_STRING']
+        end
+      end
+    end
+
+    context 'when a rewrite rule matches but there is no REQUEST_URI set' do
+      setup {
+        @rack = Rack::Rewrite.new(@app) do
+          rewrite '/wiki/Yair_Flicker', '/john'
+        end
+      }
+      should_not_halt
+
+      context 'the env' do
+        setup do
+          @initial_args = call_args_no_req.dup
+          @rack.call(@initial_args)
+        end
+
+        should "set PATH_INFO to '/john'" do
+          assert_equal '/john', @initial_args['PATH_INFO']
+        end
+        should "set REQUEST_URI to '/john'" do
+          assert_equal '/john', @initial_args['REQUEST_URI']
+        end
+        should "set QUERY_STRING to ''" do
+          assert_equal '', @initial_args['QUERY_STRING']
+        end
+      end
+    end
+    
+  end
+end