joshbuddy-rack-rewrite 0.0.2 → 0.0.3

data/README.rdoc

@@ -10,31 +10,38 @@ Rack middleware for request rewriting.
       
       # When it sees /api or /test, it calls whatever is in the act block
       #
-      on :uri => %r{/(api|test)} do
+      on :path_info => %r{/(api|test)} do
         act { puts "hey way to go!" }
         pass
       end
   
       # When it sees /google, it makes a redirect to google with the value of the query string as the search
       #
-      on :uri => %r{/google.*} do
+      on :path_info => %r{/google.*} do
         redirect { "http://google.com/search?q=#{CGI.escape(query_string)}" }
       end
   
-      # If a URI starts with /valid_place, it strips it off and keeps on truckin'
+      # If a PATH_INFO starts with /valid_place, it strips it off and keeps on truckin'
       #
-      on :uri => %r{/valid_place/.*} do
-        set(:uri) { uri[%r{/valid_place(/.*)}, 1] }
+      on :path_info => %r{/valid_place/.*} do
+        set(:path_info) { path_info[%r{/valid_place(/.*)}, 1] }
         pass
       end
       
-      # If a URI starts with /hello_kitty, add a kitty header equal to your query string
+      # If a PATH_INFO starts with /hello_kitty, add a kitty header equal to your query string
       #
-      on :uri => %r{/hello_kitty/.*} do
+      on :path_info => %r{/hello_kitty/.*} do
         act { header['kitty'] = query_string }
         pass
       end
       
+      # If the request has a has a param of kitten=cute or kitten=happy, lets log it and pass it on!
+      #
+      on :params => {:kitten => /cute|happy/}  do
+        act { log('what a nice cat') }
+        pass
+      end
+      
       fail
     end
     

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :major: 0
 :minor: 0
-:patch: 2
+:patch: 3

data/lib/rack_rewrite/actions.rb

@@ -1,64 +1,38 @@
+require 'rack'
+require 'cgi'
+
 module Rack
   class Rewrite
     class Action
       
-      def uri
-        @env['PATH_INFO']
-      end
-      
-      def uri=(uri)
-        @env['PATH_INFO'] = uri
-        update_uri_qs
-      end
-      
-      def query_string
-        @env['QUERY_STRING']
-      end
-
-      def query_string=(query_string)
-        @env['QUERY_STRING'] = query_string
-        update_uri_qs
-      end
-      
-      def update_uri_qs
-        @env['REQUEST_PATH'] = uri
-        @env['REQUEST_URI'] = query_string.empty? ? uri : "#{uri}?#{query_string}"
-      end
-      
-      def method
-        @env['REQUEST_METHOD']
-      end
-      
-      def method=(method)
-        @env['REQUEST_METHOD'] = method.to_s.upcase
-      end
-      
-      def host
-        @env['HTTP_HOST']
-      end
-      
-      def host=(host)
-        @env['HTTP_HOST'] = host
-      end
-      
-      def port
-        @env['SERVER_PORT']
+      def setup(env)
+        @request = Rack::Request.new(env)
       end
       
-      def port=(port)
-        @env['SERVER_PORT'] = port.to_s
+      def respond_to?(method)
+        @request.respond_to?(method) || super
       end
       
-      def scheme
-        @env['rack.url_scheme']
+      def query_string=(params)
+        env = @request.env
+        env['QUERY_STRING'] = case params
+        when Hash
+          params.inject([]) { |qs, (k, v)| qs << "#{CGI.escape(k.to_s)}=#{CGI.escape(v.to_s)}"} * '&'
+        else
+          params
+        end
+        
+        @request = Rack::Request.new(env)
       end
       
       def scheme=(scheme)
-        @env['rack.url_scheme'] = scheme
+        env = @request.env
+        env['rack.url_scheme'] = scheme  
+        @request = Rack::Request.new(env)
       end
       
-      def setup(env)
-        @env = env
+      def method_missing(method, *args, &block)
+        @request.send(method, *args, &block)
       end
 
       class Pass < Action
@@ -69,7 +43,7 @@ module Rack
 
       class Fail < Action
         def call(env)
-          raise
+          raise Rack::Rewrite::FailError.new
         end
       end
 
@@ -82,12 +56,7 @@ module Rack
 
         def call(env)
           setup(env)
-          self.send :"#{@variable}=", case @action
-          when Proc
-            instance_eval(&@action)
-          else
-            instance_eval(@action)
-          end
+          self.send(:"#{@variable}=", instance_eval(&@action))
           env
         end
 
@@ -98,37 +67,37 @@ module Rack
           @caller = caller
           @action = action
         end
-
+        
         def method_missing(method, *args, &block)
-          @caller.send(method, *args, &block)
+          if respond_to?(method)
+            super
+          else
+            @caller.send(method, *args, &block)
+          end
         end
-
+        
         def call(env)
           setup(env)
-          case @action
-          when Proc
-            instance_eval(&@action)
-          else
-            instance_eval(@action)
-          end
+          instance_eval(&@action)
           env
         end
 
       end
 
       class Redirect < Action
-        def initialize(caller, action)
+        def initialize(caller, action, status)
           @caller = caller
           @action = action
+          @status = status
         end
 
         def call(env)
           setup(env)
-          @caller.redirect = [ 302, {'Location'=> case @action
+          @caller.redirect = [ @status, {'Location'=> case @action
           when Proc
             instance_eval(&@action)
           else
-            instance_eval(@action)
+            @action
           end}, []]
           throw :pass
         end

data/lib/rack_rewrite/condition_set.rb

@@ -0,0 +1,40 @@
+module Rack
+  class Rewrite
+    class ConditionSet
+  
+      attr_reader :parent_set, :actions, :conditions
+  
+      def initialize(parent_set, conditions = nil)
+        @parent_set = parent_set
+        @conditions = conditions
+        @actions = []
+      end
+
+      def satisfied?(env)
+        if conditions
+      
+          uri_ok = conditions.key?(:uri) ? conditions[:uri] === env['PATH_INFO'] : true
+          method_ok = conditions.key?(:method) ? conditions[:method] === env['REQUEST_METHOD'].downcase : true
+          host_ok = conditions.key?(:host) ? conditions[:host] === env['HTTP_HOST'] : true
+          port_ok = conditions.key?(:port) ? conditions[:port] === env['SERVER_PORT'].to_i : true
+          scheme_ok = conditions.key?(:scheme) ? conditions[:scheme] === env['rack.url_scheme'] : true
+          if conditions.key?(:params)
+            req = Rack::Request.new(env)
+            params_ok = true
+            conditions[:params].each do |key, test|
+              params_ok = test === req.params[key.to_s]
+              break unless params_ok
+            end
+          else
+            params_ok = true
+          end
+
+          uri_ok && method_ok && host_ok && port_ok && scheme_ok && params_ok
+        else
+          true
+        end
+      end
+  
+    end
+  end
+end

data/lib/rack_rewrite.rb

@@ -1,43 +1,14 @@
 $:.unshift(File.dirname(__FILE__))
+require 'rack'
 require 'rack_rewrite/actions'
+require 'rack_rewrite/condition_set'
 
 module Rack
   class Rewrite
     
-    attr_accessor :path, :redirect, :headers
+    FailError = Class.new(RuntimeError)
     
-    class ConditionSet
-      
-      attr_reader :parent_set, :actions, :conditions
-      
-      def initialize(parent_set, conditions = nil)
-        @parent_set = parent_set
-        @conditions = conditions
-        @actions = []
-      end
-
-      def satisfied?(env)
-        if conditions
-          
-          uri_ok = conditions.key?(:uri) ? conditions[:uri] === env['PATH_INFO'] : true
-          method_ok = conditions.key?(:method) ? conditions[:method] === env['REQUEST_METHOD'].downcase : true
-          host_ok = conditions.key?(:host) ? conditions[:host] === env['HTTP_HOST'] : true
-          port_ok = conditions.key?(:port) ? conditions[:port] === env['SERVER_PORT'].to_i : true
-          scheme_ok = conditions.key?(:scheme) ? conditions[:scheme] === env['rack.url_scheme'] : true
-          
-          #puts "uri_ok: #{uri_ok} method_ok #{method_ok} host_ok #{host_ok} port_ok #{port_ok} scheme_ok #{scheme_ok} for conditions #{conditions.inspect}"
-          
-          uri_ok && method_ok && host_ok && port_ok && scheme_ok
-        else
-          true
-        end
-      end
-      
-      def inspect
-        "#{id} .. conditions=#{conditions.inspect}\nactions=#{actions.inspect}"
-      end
-      
-    end
+    attr_accessor :path, :redirect, :headers
     
     def initialize(app, options = {}, &block)
       @app = app
@@ -69,15 +40,17 @@ module Rack
       @current_condition_set.actions << Action::Fail.new
     end
     
-    def redirect(pattern = nil, &block)
-      @current_condition_set.actions << Action::Redirect.new(self, pattern || block)
+    def redirect(*args, &block)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      pattern = args.first
+      @current_condition_set.actions << Action::Redirect.new(self, pattern || block, options[:status] || 302)
     end
     
     def call(env)
       @headers = {}
       catch(:pass) {
         env = call_conditions(env, @root)
-        raise
+        raise FailError.new
       }
       if @redirect
         redirect = @redirect

data/spec/action_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe "Rack::Rewrite Rewriting" do
+
+  it "should rewrite a path_info" do
+    env = Rack::MockRequest.env_for('/test', :method => 'get')
+    app = mock('app')
+    app.should_receive(:call) { |resp|
+      resp['PATH_INFO'].should == '/test/test'
+      [200, {}, ["body"]]
+    }
+    
+    Rack::Rewrite.new(app) { on(:path_info => '/test') { set(:path_info) { "/test#{path_info}" }; pass } }.call(env)
+  end
+
+  it "should rewrite a scheme" do
+    env = Rack::MockRequest.env_for('/test', :method => 'get')
+    app = mock('app')
+    app.should_receive(:call) { |resp|
+      resp['rack.url_scheme'].should == 'https'
+      [200, {}, ["body"]]
+    }
+    
+    Rack::Rewrite.new(app) { on(:path_info => '/test') { set(:scheme) { "https" }; pass } }.call(env)
+  end
+
+  it "should arbitrarily add a new header" do
+    env = Rack::MockRequest.env_for('/test?Happy-Land', :method => 'get')
+    app = mock('app')
+    app.should_receive(:call).and_return([200, {'Content-type' => 'text/html'}, ['mybody']])
+    response = Rack::Rewrite.new(app) { on(:path_info => '/test') { act{ headers['My-special-header'] = query_string }; pass } }.call(env)
+    response[1]['My-special-header'].should == 'Happy-Land'
+  end
+  
+  it "should let you create a new querystring from a hash" do
+    env = Rack::MockRequest.env_for('/test?Happy=Land', :method => 'get')
+    app = mock('app')
+    app.should_receive(:call) { |resp|
+      ['Happy=Land&more=query_goodness', 'more=query_goodness&Happy=Land'].should include(resp['QUERY_STRING'])
+      [200, {}, ["body"]]
+    }
+    response = Rack::Rewrite.new(app) { on(:path_info => '/test') { set(:query_string) { params.merge(:more => :query_goodness)}; pass } }.call(env)
+  end
+  
+  it "should let you create a new querystring from a string" do
+    env = Rack::MockRequest.env_for('/test?Happy=Land', :method => 'get')
+    app = mock('app')
+    app.should_receive(:call) { |resp|
+      resp['QUERY_STRING'].should == 'this_is_my_query_string'
+      [200, {}, ["body"]]
+    }
+    response = Rack::Rewrite.new(app) { on(:path_info => '/test') { set(:query_string) { "this_is_my_query_string" }; pass } }.call(env)
+    
+  end
+  
+  it "should fail" do
+    env = Rack::MockRequest.env_for('/test', :method => 'get')
+    app = mock('app')
+    proc { Rack::Rewrite.new(app) { on(:path_info => '/test') { fail }; pass }.call(env) }.should raise_error Rack::Rewrite::FailError
+  end
+  
+  it "should redirect from a proc" do
+    env = Rack::MockRequest.env_for('/test', :method => 'get')
+    app = mock('app')
+    Rack::Rewrite.new(app) { on(:path_info => '/test') { redirect {"/another/place"} }; fail }.call(env).should == [302, {'Location' => '/another/place'}, []]
+  end
+  
+  it "should redirect from a proc (with a special status)" do
+    env = Rack::MockRequest.env_for('/test', :method => 'get')
+    app = mock('app')
+    Rack::Rewrite.new(app) { on(:path_info => '/test') { redirect(:status => 304) {"/another/place"} }; fail }.call(env).should == [304, {'Location' => '/another/place'}, []]
+  end
+  
+  it "should redirect from a string" do
+    env = Rack::MockRequest.env_for('/test', :method => 'get')
+    app = mock('app')
+    Rack::Rewrite.new(app) { on(:path_info => '/test') { redirect "/another/place" }; fail }.call(env).should == [302, {'Location' => '/another/place'}, []]
+  end
+  
+end

data/spec/conditions_spec.rb

@@ -12,11 +12,19 @@ describe "Rack::Rewrite Conditions" do
     end
   end
   
-  it "should detect a simple uri" do
+  it "should detect a simple path_info" do
     env = Rack::MockRequest.env_for('/test', :method => 'get')
     app = mock('app')
     app.should_receive(:call).with(env).and_return([200, {}, ["body"]])
-    Rack::Rewrite.new(app) { on(:uri => '/test') { pass } }.call(env)
+    Rack::Rewrite.new(app) { on(:path_info => '/test') { pass } }.call(env)
   end
 
+  it "should detect a param in the query string" do
+    env = Rack::MockRequest.env_for('/test?test=helpme', :method => 'get')
+    app = mock('app')
+    app.should_receive(:call).with(env).and_return([200, {}, ["body"]])
+    Rack::Rewrite.new(app) { on(:params => {:test => 'helpme'}) { pass } }.call(env)
+    proc { Rack::Rewrite.new(app) { on(:params => {:test => 'helpme2'}) { pass } }.call(env) }.should raise_error
+  end
+  
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: joshbuddy-rack-rewrite
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - Joshua Hull
@@ -26,9 +26,10 @@ files:
 - VERSION.yml
 - lib/rack_rewrite
 - lib/rack_rewrite/actions.rb
+- lib/rack_rewrite/condition_set.rb
 - lib/rack_rewrite.rb
+- spec/action_spec.rb
 - spec/conditions_spec.rb
-- spec/rewrite_spec.rb
 - spec/spec_helper.rb
 has_rdoc: true
 homepage: http://github.com/joshbuddy/rack-rewrite

data/spec/rewrite_spec.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-
-describe "Rack::Rewrite Rewriting" do
-
-  it "should rewrite a uri" do
-    env = Rack::MockRequest.env_for('/test', :method => 'get')
-    app = mock('app')
-    app.should_receive(:call) { |resp|
-      resp['PATH_INFO'].should == '/test/test'
-      [200, {}, ["body"]]
-    }
-    
-    Rack::Rewrite.new(app) { on(:uri => '/test') { set(:uri) { "/test#{uri}" }; pass } }.call(env)
-  end
-
-  it "should arbitrarily add a new header" do
-    env = Rack::MockRequest.env_for('/test?Happy-Land', :method => 'get')
-    app = mock('app')
-    app.should_receive(:call).and_return([200, {'Content-type' => 'text/html'}, ['mybody']])
-    response = Rack::Rewrite.new(app) { on(:uri => '/test') { act{ headers['My-special-header'] = query_string }; pass } }.call(env)
-    response[1]['My-special-header'].should == 'Happy-Land'
-  end
-
-end