usher 0.6.7 → 0.6.8

data/README.rdoc

@@ -108,6 +108,10 @@ For instance, the path, <tt>/path/something(.xml|.html)</tt> would only match <t
 
   script/plugin install git://github.com/joshbuddy/usher.git
 
+In your config/initializers/usher.rb (create if it doesn't exist) add:
+
+  Usher::Util::Rails.activate
+
 == Rack
 
 === config.ru

data/VERSION.yml

@@ -1,5 +1,5 @@
 --- 
 :build: 
-:major: 0
 :minor: 6
-:patch: 7
+:patch: 8
+:major: 0

data/lib/usher/interface/rails23.rb

@@ -9,10 +9,11 @@ class Usher
       end
 
       def add_named_route(name, route, options = {})
-        @router.add_route(route, options).name(name)
+        add_route(route, options).name(name)
       end
 
       def add_route(path, options = {})
+        path.gsub!(/(\..*?(?!\)))$/, '(\1)')
         if !@controller_action_route_added && path =~ %r{^/?:controller/:action/:id$}
           add_route('/:controller/:action', options.dup)
           @controller_action_route_added = true
@@ -66,6 +67,7 @@ class Usher
 
       def recognize(request)
         response = @router.recognize(request)
+        request.path_parameters.merge!(response.destination)
         request.path_parameters.merge!(response.params_as_hash)
         "#{request.path_parameters[:controller].camelize}Controller".constantize
       end
@@ -73,7 +75,6 @@ class Usher
       def reset!(options={})
         options[:generator] = options[:generator] || Usher::Util::Generators::URL.new
         options[:request_methods] = options[:request_methods] || [:protocol, :domain, :port, :query_string, :remote_ip, :user_agent, :referer, :method, :subdomains]
-
         @router = Usher.new(options)
         @configuration_files = []
         @module ||= Module.new
@@ -93,11 +94,20 @@ class Usher
           @router.named_routes.keys.each do |name|
             @module.module_eval <<-end_eval # We use module_eval to avoid leaks
               def #{name}_url(options = {})
-                ActionController::Routing::UsherRoutes.generate(options, {}, :generate, :#{name})
+                ActionController::Routing::Routes.generate(options, {}, :generate, :#{name})
+              end
+              def #{name}_path(options = {})
+                ActionController::Routing::Routes.generate(options, {}, :generate, :#{name})
               end
             end_eval
           end
           d.__send__(:include, @module)
+          @router.named_routes.instance_eval "
+            def helpers
+              { }
+            end
+          "
+          @router.named_routes.helpers.__send__(:extend, @module)
         end
       end
 

data/lib/usher/route.rb

@@ -6,7 +6,7 @@ require File.join('usher', 'route', 'request_method')
 
 class Usher
   class Route
-    attr_reader   :paths, :requirements, :conditions, :named, :generate_with, :default_values, :match_partially, :destination, :priority
+    attr_reader   :original_path, :paths, :requirements, :conditions, :named, :generate_with, :default_values, :match_partially, :destination, :priority
     attr_accessor :parent_route, :router, :recognizable
 
     class GenerateWith < Struct.new(:scheme, :port, :host)
@@ -15,8 +15,8 @@ class Usher
       end
     end
 
-    def initialize(parsed_paths, router, conditions, requirements, default_values, generate_with, match_partially, priority)
-      @router, @requirements, @conditions, @default_values, @match_partially, @priority = router, requirements, conditions, default_values, match_partially, priority
+    def initialize(original_path, parsed_paths, router, conditions, requirements, default_values, generate_with, match_partially, priority)
+      @original_path, @router, @requirements, @conditions, @default_values, @match_partially, @priority = original_path, router, requirements, conditions, default_values, match_partially, priority
       @recognizable = true
       @paths = parsed_paths.collect {|path| Path.new(self, path)}
       @generate_with = GenerateWith.new(generate_with[:scheme], generate_with[:port], generate_with[:host]) if generate_with

data/lib/usher/util/parser.rb

@@ -21,25 +21,26 @@ class Usher
 
       def generate_route(unprocessed_path, conditions, requirements, default_values, generate_with, priority)
         match_partially = false
+        processed_path = unprocessed_path
         case unprocessed_path
         when String
           if unprocessed_path[-1] == ?*
             unprocessed_path.slice!(-1)
             match_partially = true
           end
-          unprocessed_path = parse(unprocessed_path, requirements, default_values)
+          processed_path = parse(unprocessed_path, requirements, default_values)
         when Regexp
-          unprocessed_path = [Route::Static::Greedy.new(unprocessed_path)]
+          processed_path = [Route::Static::Greedy.new(unprocessed_path)]
         else
           match_partially = false
         end
         
-        unless unprocessed_path.first.is_a?(Route::Util::Group)
+        unless processed_path.first.is_a?(Route::Util::Group)
           group = Usher::Route::Util::Group.new(:all, nil)
-          unprocessed_path.each{|p| group << p}
-          unprocessed_path = group
+          processed_path.each{|p| group << p}
+          processed_path = group
         end
-        paths = Route::Util.expand_path(unprocessed_path)
+        paths = Route::Util.expand_path(processed_path)
 
         paths.each do |path|
           path.each_with_index do |part, index|
@@ -64,6 +65,7 @@ class Usher
         end
 
         Route.new(
+          unprocessed_path,
           paths,
           router, 
           conditions, 

data/lib/usher/util/rack-mixins.rb

@@ -2,30 +2,39 @@ require 'rack'
 
 unless Rack::Utils.respond_to?(:uri_escape)
   module Rack
-
     module Utils
-
       def uri_escape(s)
         s.to_s.gsub(/([^:\/?\[\]\-_~\.!\$&'\(\)\*\+,;=@a-zA-Z0-9]+)/n) {
           '%'<<$1.unpack('H2'*$1.size).join('%').upcase
         }
       end
       module_function :uri_escape
+    end
+  end
+end
 
+unless Rack::Utils.respond_to?(:uri_escape!)
+  module Rack
+    module Utils
       def uri_escape!(s)
         s.to_s.gsub!(/([^:\/?\[\]\-_~\.!\$&'\(\)\*\+,;=@a-zA-Z0-9]+)/n) {
           '%'<<$1.unpack('H2'*$1.size).join('%').upcase
         }
       end
       module_function :uri_escape!
+    end
+  end
+end
 
+unless Rack::Utils.respond_to?(:uri_unescape)
+  module Rack
+    module Utils
       def uri_unescape(s)
         gsub(/((?:%[0-9a-fA-F]{2})+)/n){
           [$1.delete('%')].pack('H*')
         }
       end
       module_function :uri_unescape
-
     end
   end
-end
+end

data/lib/usher/util/rails.rb

@@ -0,0 +1,34 @@
+class Usher
+  module Util
+    class Rails
+      
+      def self.activate
+        rails_version = "#{::Rails::VERSION::MAJOR}.#{::Rails::VERSION::MINOR}"
+
+        case rails_version
+        when '2.3'
+          ActionController::Routing.module_eval "remove_const(:Routes); Routes = Usher::Interface.for(:rails23)"
+
+        when '2.2'
+          class Usher::Interface::Rails22::Mapper
+            include ActionController::Resources
+          end
+          ActionController::Routing.module_eval "remove_const(:Routes); Routes = Usher::Interface.for(:rails22)"
+
+        when '2.0'
+          class Usher::Interface::Rails20::Mapper
+            include ActionController::Resources
+          end
+
+          ActionController::Routing.module_eval <<-CODE
+            remove_const(:Routes);
+            interface = Usher::Interface.for(:rails20);
+            interface.configuration_file = File.join(RAILS_ROOT, 'config', 'routes.rb')
+            Routes = interface;
+          CODE
+        end
+      end
+      
+    end
+  end
+end

data/lib/usher/util.rb

@@ -2,5 +2,6 @@ class Usher
   module Util
     autoload :Generators, File.join('usher', 'util', 'generate')
     autoload :Parser,     File.join('usher', 'util', 'parser')
+    autoload :Rails,      File.join('usher', 'util', 'rails')
   end
 end

data/lib/usher.rb

@@ -71,13 +71,13 @@ class Usher
   # Example, you create a route with a destination of :controller => 'test', :action => 'action'. If you made a call to generator with :controller => 'test', 
   # :action => 'action', it would pick that route to use for generation.
   def initialize(options = nil)
-    self.generator                      = options && options.delete(:generator)
-    self.delimiters                     = Delimiters.new(options && options.delete(:delimiters) || ['/', '.'])
-    self.valid_regex                    = options && options.delete(:valid_regex) || '[0-9A-Za-z\$\-_\+!\*\',]+'
-    self.request_methods                = options && options.delete(:request_methods)
-    self.ignore_trailing_delimiters     = options && options.key?(:ignore_trailing_delimiters) ? options.delete(:ignore_trailing_delimiters) : false
-    self.consider_destination_keys      = options && options.key?(:consider_destination_keys) ? options.delete(:consider_destination_keys) : false
-    self.allow_identical_variable_names = options && options.key?(:allow_identical_variable_names) ? options.delete(:allow_identical_variable_names) : true
+    self.generator                       = options && options.delete(:generator)
+    self.delimiters                      = Delimiters.new(options && options.delete(:delimiters) || ['/', '.'])
+    self.valid_regex                     = options && options.delete(:valid_regex) || '[0-9A-Za-z\$\-_\+!\*\',]+'
+    self.request_methods                 = options && options.delete(:request_methods)
+    self.ignore_trailing_delimiters      = options && options.key?(:ignore_trailing_delimiters) ? options.delete(:ignore_trailing_delimiters) : false
+    self.consider_destination_keys       = options && options.key?(:consider_destination_keys) ? options.delete(:consider_destination_keys) : false
+    self.allow_identical_variable_names  = options && options.key?(:allow_identical_variable_names) ? options.delete(:allow_identical_variable_names) : true
     reset!
   end
 

data/spec/private/rails2_2/recognize_spec.rb

@@ -1,11 +1,10 @@
 require File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "spec_helper"))
 require File.expand_path(File.join(File.dirname(__FILE__), 'compat'))
 require "usher"
-require 'action_controller'
 
 route_set = Usher::Interface.for(:rails22)
 
-def build_request_mock(path, method, params)
+def build_request_mock_rails22(path, method, params)
   request = mock "Request"
   request.should_receive(:path).any_number_of_times.and_return(path)
   request.should_receive(:method).any_number_of_times.and_return(method)
@@ -25,35 +24,35 @@ describe "Usher (for rails 2.2) route recognition" do
 
   it "should recognize a simple request" do
     route_set.add_route('/sample', :controller => 'sample', :action => 'action')
-    route_set.recognize(build_request_mock('/sample', 'get', {:controller => 'sample', :action => 'action'})).should == SampleController
+    route_set.recognize(build_request_mock_rails22('/sample', 'get', {:controller => 'sample', :action => 'action'})).should == SampleController
   end
 
   it "should interpolate action :index" do
     route_set.add_route('/sample', :controller => 'sample')
-    route_set.recognize(build_request_mock('/sample', 'get', {:controller => 'sample', :action => 'index'})).should == SampleController
+    route_set.recognize(build_request_mock_rails22('/sample', 'get', {:controller => 'sample', :action => 'index'})).should == SampleController
   end
 
   it "should correctly distinguish between multiple request methods" do
     route_set.add_route('/sample', :controller => 'not_sample', :conditions => {:method => :get})
     correct_route = route_set.add_route('/sample', :controller => 'sample', :conditions => {:method => :post})
     route_set.add_route('/sample', :controller => 'not_sample', :conditions => {:method => :put})
-    route_set.recognize(build_request_mock('/sample', :post, {:controller => 'sample', :action => 'index'})).should == SampleController
+    route_set.recognize(build_request_mock_rails22('/sample', :post, {:controller => 'sample', :action => 'index'})).should == SampleController
   end
 
   it "should prefer the static route to the dynamic route" do
     route_set.add_route('/sample/:action', :controller => 'not_sample')
     route_set.add_route('/sample/test', :controller => 'sample', :action => 'action')
-    route_set.recognize(build_request_mock('/sample/test', 'get', {:controller => 'sample', :action => 'action'})).should == SampleController
+    route_set.recognize(build_request_mock_rails22('/sample/test', 'get', {:controller => 'sample', :action => 'action'})).should == SampleController
   end
   
   it "should raise based upon an invalid param" do
     route_set.add_named_route(:sample, '/sample/:action', :controller => 'sample', :requirements => {:action => /\d+/})
-    proc { route_set.recognize(build_request_mock('/sample/asdqwe', :post, {})) }.should raise_error
+    proc { route_set.recognize(build_request_mock_rails22('/sample/asdqwe', :post, {})) }.should raise_error
   end
   
   it "should raise based upon an invalid route" do
     route_set.add_named_route(:sample, '/sample', :controller => 'sample', :action => 'test')
-    proc { route_set.recognize(build_request_mock('/test/asdqwe', :post, {})) }.should raise_error
+    proc { route_set.recognize(build_request_mock_rails22('/test/asdqwe', :post, {})) }.should raise_error
   end
   
   it "should add /:controller and /:controller/:action if /:controller/:action/:id is added" do
@@ -63,17 +62,17 @@ describe "Usher (for rails 2.2) route recognition" do
   
   it "should correctly recognize a format (dynamic path path with . delimiter)" do
     route_set.add_route('/:controller/:action/:id.:format')
-    route_set.recognize(build_request_mock('/sample/test/123.html', 'get', {:controller => 'sample', :action => 'test', :id => '123', :format => 'html'})).should == SampleController
+    route_set.recognize(build_request_mock_rails22('/sample/test/123.html', 'get', {:controller => 'sample', :action => 'test', :id => '123', :format => 'html'})).should == SampleController
   end
   
   it "should support root nodes" do
     route_set.add_route('/', :controller => 'sample')
-    route_set.recognize(build_request_mock('/', :get, {:controller => 'sample', :action => 'index'})).should == SampleController
+    route_set.recognize(build_request_mock_rails22('/', :get, {:controller => 'sample', :action => 'index'})).should == SampleController
   end
   
   it "should default action to 'index' when controller (and not index) is specified" do
     route_set.add_route('/:controller/:action')
-    route_set.recognize(build_request_mock('/sample', :get, {:controller => 'sample', :action => 'index'})).should == SampleController
+    route_set.recognize(build_request_mock_rails22('/sample', :get, {:controller => 'sample', :action => 'index'})).should == SampleController
   end
   
   

data/spec/private/rails2_3/recognize_spec.rb

@@ -1,11 +1,10 @@
 require File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "spec_helper"))
 require File.expand_path(File.join(File.dirname(__FILE__), 'compat'))
 require "usher"
-require 'action_controller'
 
 route_set = Usher::Interface.for(:rails23)
 
-def build_request_mock(path, method, params)
+def build_request_mock_rails23(path, method, params)
   request = mock "Request"
   request.should_receive(:path).any_number_of_times.and_return(path)
   request.should_receive(:method).any_number_of_times.and_return(method)
@@ -25,35 +24,35 @@ describe "Usher (for rails 2.3) route recognition" do
 
   it "should recognize a simple request" do
     route_set.add_route('/sample', :controller => 'sample', :action => 'action')
-    route_set.recognize(build_request_mock('/sample', 'get', {:controller => 'sample', :action => 'action'})).should == SampleController
+    route_set.recognize(build_request_mock_rails23('/sample', 'get', {:controller => 'sample', :action => 'action'})).should == SampleController
   end
 
   it "should interpolate action :index" do
     route_set.add_route('/sample', :controller => 'sample')
-    route_set.recognize(build_request_mock('/sample', 'get', {:controller => 'sample', :action => 'index'})).should == SampleController
+    route_set.recognize(build_request_mock_rails23('/sample', 'get', {:controller => 'sample', :action => 'index'})).should == SampleController
   end
 
   it "should correctly distinguish between multiple request methods" do
     route_set.add_route('/sample', :controller => 'not_sample', :conditions => {:method => :get})
     correct_route = route_set.add_route('/sample', :controller => 'sample', :conditions => {:method => :post})
     route_set.add_route('/sample', :controller => 'not_sample', :conditions => {:method => :put})
-    route_set.recognize(build_request_mock('/sample', :post, {:controller => 'sample', :action => 'index'})).should == SampleController
+    route_set.recognize(build_request_mock_rails23('/sample', :post, {:controller => 'sample', :action => 'index'})).should == SampleController
   end
 
   it "should prefer the static route to the dynamic route" do
     route_set.add_route('/sample/:action', :controller => 'not_sample')
     route_set.add_route('/sample/test', :controller => 'sample', :action => 'action')
-    route_set.recognize(build_request_mock('/sample/test', 'get', {:controller => 'sample', :action => 'action'})).should == SampleController
+    route_set.recognize(build_request_mock_rails23('/sample/test', 'get', {:controller => 'sample', :action => 'action'})).should == SampleController
   end
 
   it "should raise based upon an invalid param" do
     route_set.add_named_route(:sample, '/sample/:action', :controller => 'sample', :requirements => {:action => /\d+/})
-    proc { route_set.recognize(build_request_mock('/sample/asdqwe', :post, {})) }.should raise_error
+    proc { route_set.recognize(build_request_mock_rails23('/sample/asdqwe', :post, {})) }.should raise_error
   end
 
   it "should raise based upon an invalid route" do
     route_set.add_named_route(:sample, '/sample', :controller => 'sample', :action => 'test')
-    proc { route_set.recognize(build_request_mock('/test/asdqwe', :post, {})) }.should raise_error
+    proc { route_set.recognize(build_request_mock_rails23('/test/asdqwe', :post, {})) }.should raise_error
   end
 
   it "should add /:controller and /:controller/:action if /:controller/:action/:id is added" do
@@ -63,17 +62,17 @@ describe "Usher (for rails 2.3) route recognition" do
 
   it "should correctly recognize a format (dynamic path path with . delimiter)" do
     route_set.add_route('/:controller/:action/:id.:format')
-    route_set.recognize(build_request_mock('/sample/test/123.html', 'get', {:controller => 'sample', :action => 'test', :id => '123', :format => 'html'})).should == SampleController
+    route_set.recognize(build_request_mock_rails23('/sample/test/123.html', 'get', {:controller => 'sample', :action => 'test', :id => '123', :format => 'html'})).should == SampleController
   end
 
   it "should support root nodes" do
     route_set.add_route('/', :controller => 'sample')
-    route_set.recognize(build_request_mock('/', :get, {:controller => 'sample', :action => 'index'})).should == SampleController
+    route_set.recognize(build_request_mock_rails23('/', :get, {:controller => 'sample', :action => 'index'})).should == SampleController
   end
 
   it "should default action to 'index' when controller (and not index) is specified" do
     route_set.add_route('/:controller/:action')
-    route_set.recognize(build_request_mock('/sample', :get, {:controller => 'sample', :action => 'index'})).should == SampleController
+    route_set.recognize(build_request_mock_rails23('/sample', :get, {:controller => 'sample', :action => 'index'})).should == SampleController
   end
 
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: usher
 version: !ruby/object:Gem::Version 
-  version: 0.6.7
+  version: 0.6.8
 platform: ruby
 authors: 
 - Daniel Neighman
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-24 00:00:00 -05:00
+date: 2010-03-03 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -76,7 +76,7 @@ files:
 - lib/usher/util/mapper.rb
 - lib/usher/util/parser.rb
 - lib/usher/util/rack-mixins.rb
-- rails/init.rb
+- lib/usher/util/rails.rb
 - spec/private/delimiters_spec.rb
 - spec/private/destination_spec.rb
 - spec/private/email/recognize_spec.rb

data/rails/init.rb

@@ -1,24 +0,0 @@
-rails_version = "#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}"
-
-case rails_version
-  when '2.3'
-    ActionController::Routing.module_eval "remove_const(:Routes); Routes = Usher::Interface.for(:rails23)"
-
-  when '2.2'
-    class Usher::Interface::Rails22::Mapper
-      include ActionController::Resources
-    end
-    ActionController::Routing.module_eval "remove_const(:Routes); Routes = Usher::Interface.for(:rails22)"
-
-  when '2.0'
-    class Usher::Interface::Rails20::Mapper
-      include ActionController::Resources
-    end
-
-    ActionController::Routing.module_eval <<CODE
-      remove_const(:Routes);
-      interface = Usher::Interface.for(:rails20);
-      interface.configuration_file = File.join(RAILS_ROOT, 'config', 'routes.rb')
-      Routes = interface;
-CODE
-end