usher 0.8.0 → 0.8.1

data/README.markdown

@@ -143,7 +143,7 @@ In your config/initializers/usher.rb (create if it doesn't exist) add:
 
 ## Sinatra
 
-In Sinatra, you get the extra method, +generate+, which lets you generate a url. Name your routes with `:name` when you define them.
+In Sinatra, you get the extra method, `generate`, which lets you generate a url. Name your routes with `:name` when you define them.
 
     require 'rubygems'
     require 'usher'

data/Rakefile

@@ -9,7 +9,7 @@ YARD::Rake::YardocTask.new do |t|
   t.options = ['--markup=markdown'] # optional
 end
 
-task :spec => ['spec:private', 'spec:rails2_2:cleanup', 'spec:rails2_3:cleanup']
+task :spec => ['spec:private', 'spec:rails2_2:spec', 'spec:rails2_3:spec']
 namespace(:spec) do
   Spec::Rake::SpecTask.new(:private) do |t|
     t.spec_opts ||= []
@@ -24,7 +24,7 @@ namespace(:spec) do
       sh('unzip -qq spec/rails2_2/vendor.zip -dspec/rails2_2')
     end
 
-    Spec::Rake::SpecTask.new(:spec) do |t|
+    Spec::Rake::SpecTask.new(:only_spec) do |t|
       t.spec_opts ||= []
       t.spec_opts << "-rubygems"
       t.spec_opts << "--options" << "spec/spec.opts"
@@ -34,9 +34,8 @@ namespace(:spec) do
     task :cleanup do
       sh('rm -rf spec/rails2_2/vendor')
     end
-    
-    task :spec => :unzip
-    task :cleanup => :spec
+
+    task :spec => [:unzip, :only_spec, :cleanup]
   end
 
   namespace(:rails2_3) do
@@ -45,7 +44,7 @@ namespace(:spec) do
       sh('unzip -qq spec/rails2_3/vendor.zip -dspec/rails2_3')
     end
 
-    Spec::Rake::SpecTask.new(:spec) do |t|
+    Spec::Rake::SpecTask.new(:only_spec) do |t|
       t.spec_opts ||= []
       t.spec_opts << "-rubygems"
       t.spec_opts << "--options" << "spec/spec.opts"
@@ -55,8 +54,7 @@ namespace(:spec) do
       sh('rm -rf spec/rails2_3/vendor')
     end
 
-    task :spec => :unzip
-    task :cleanup => :spec
+    task :spec => [:unzip, :only_spec, :cleanup]
   end
   
   

data/lib/usher.rb

@@ -252,6 +252,11 @@ class Usher
     route
   end
 
+  def add_meta(meta, path, options = nil)
+    route = get_route(path, options)
+    root.add_meta(route, meta)
+  end
+
   # Recognizes a `request`
   # @param request [#path] The request object. Must minimally respond to #path if no path argument is supplied here.
   # @param path [String] The path to be recognized.

data/lib/usher/interface/rack.rb

@@ -23,7 +23,7 @@ class Usher
       # * <tt>generator</tt> - Route generator to use. (Default <tt>Usher::Util::Generators::URL.new</tt>)
       # * <tt>allow_identical_variable_names</tt> - Option to prevent routes with identical variable names to be added. eg, /:variable/:variable would raise an exception if this option is not enabled. (Default <tt>false</tt>)
       def initialize(options = {}, &blk)
-        @_app = options[:default_app] || proc{|env| ::Rack::Response.new("No route found", 404).finish }
+        @_app = options[:default_app] || proc{|env| ::Rack::Response.new("Not Found", 404).finish }
         @use_destinations = options.key?(:use_destinations) ? options.delete(:use_destinations) : true
         @router_key = options.delete(:router_key) || ENV_KEY_DEFAULT_ROUTER
         request_methods = options.delete(:request_methods) || [:request_method, :host, :port, :scheme]
@@ -56,14 +56,14 @@ class Usher
         new_one
       end
       
-      # Adds a route to the route set with a +path+ and optional +options+.
+      # Adds a route to the route set with a `path` and optional `options`.
       # See <tt>Usher#add_route</tt> for more details about the format of the route and options accepted here.
       def add(path, options = nil)
         @router.add_route(path, options)
       end
       alias_method :path, :add
 
-      # Sets the default application when route matching is unsuccessful. Accepts either an application +app+ or a block to call.
+      # Sets the default application when route matching is unsuccessful. Accepts either an application `app` or a block to call.
       #
       # default { |env| ... }
       # default DefaultApp
@@ -79,27 +79,27 @@ class Usher
       # it returns route, and because you may want to work with the route,
       # for example give it a name, we returns the route with GET request
 
-      # Convenience method for adding a route that only matches request method +GET+.
+      # Convenience method for adding a route that only matches request method `GET`.
       def only_get(path, options = {})
         add(path, options.merge!(:conditions => {:request_method => ["GET"]}))
       end
 
-      # Convenience method for adding a route that only matches request methods +GET+ and +HEAD+.
+      # Convenience method for adding a route that only matches request methods `GET` and `HEAD`.
       def get(path, options = {})
         add(path, options.merge!(:conditions => {:request_method => ["HEAD", "GET"]}))
       end
 
-      # Convenience method for adding a route that only matches request method +POST+.
+      # Convenience method for adding a route that only matches request method `POST`.
       def post(path, options = {})
         add(path, options.merge!(:conditions => {:request_method => "POST"}))
       end
 
-      # Convenience method for adding a route that only matches request method +PUT+.
+      # Convenience method for adding a route that only matches request method `PUT`.
       def put(path, options = {})
         add(path, options.merge!(:conditions => {:request_method => "PUT"}))
       end
 
-      # Convenience method for adding a route that only matches request method +DELETE+.
+      # Convenience method for adding a route that only matches request method `DELETE`.
       def delete(path, options = {})
         add(path, options.merge!(:conditions => {:request_method => "DELETE"}))
       end
@@ -167,7 +167,7 @@ class Usher
         elsif usable_response && response.destination.respond_to?(:args) && response.destination.args.first.respond_to?(:call)
           response.args.first
         elsif !response.succeeded? && response.request_method?
-          rack_response = ::Rack::Response.new("Method not allowed", 405)
+          rack_response = ::Rack::Response.new("Method Not Allowed", 405)
           rack_response['Allow'] = response.acceptable_responses_only_strings.join(", ")
           proc { |env| rack_response.finish }
         else
@@ -177,8 +177,8 @@ class Usher
 
       # Consume the path from path_info to script_name
       def consume_path!(request, response)
-        request.env["SCRIPT_NAME"] = (request.env["SCRIPT_NAME"] + response.matched_path)   || ""
-        request.env["PATH_INFO"] = response.remaining_path    || ""
+        request.env["SCRIPT_NAME"] = (request.env["SCRIPT_NAME"] + response.matched_path)
+        request.env["PATH_INFO"] = response.remaining_path || ""
       end
 
       def default_app

data/lib/usher/interface/rack/route.rb

@@ -4,7 +4,7 @@ class Usher
       # Route specific for Rack with redirection support built in.
       class Route < Usher::Route
         
-        # Redirect route to some other path. 
+        # Redirect route to some other path.
         def redirect(path, status = 302)
           unless (300..399).include?(status)
             raise ArgumentError, "Status has to be an integer between 300 and 399"
@@ -18,9 +18,14 @@ class Usher
           self
         end
         
+        # Serves either files from a directory, or a single static file.
         def serves_static_from(root)
-          match_partially!
-          @destination = ::Rack::File.new(root)
+          if File.directory?(root)
+            match_partially!
+            @destination = ::Rack::File.new(root)
+          else
+            @destination = proc{|env| env['PATH_INFO'] = File.basename(root); ::Rack::File.new(File.dirname(root)).call(env)}
+          end
         end
       end
     end

data/lib/usher/interface/rails23.rb

@@ -93,11 +93,11 @@ class Usher
         Array(destinations).each do |d| d.module_eval { include Helpers }
           @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::Routes.generate(options, {}, :generate, :#{name})
+              def #{name}_url(*args)
+                UsherRailsRouter.generate(args, {}, :generate, :#{name})
               end
-              def #{name}_path(options = {})
-                ActionController::Routing::Routes.generate(options, {}, :generate, :#{name})
+              def #{name}_path(*args)
+                UsherRailsRouter.generate(args, {}, :generate, :#{name})
               end
             end_eval
           end
@@ -107,12 +107,24 @@ class Usher
               { }
             end
           "
+          unless @module.const_defined?(:UsherRailsRouter)
+            @module.const_set(:UsherRailsRouter, self)
+          end
+          
           @router.named_routes.helpers.__send__(:extend, @module)
         end
       end
 
-      def generate(options, recall = {}, method = :generate, route_name = nil)
-        route = if(route_name)
+      def generate(args, recall = {}, method = :generate, route_name = nil)
+        if args.is_a?(Hash)
+          options = args
+          args = nil
+        else
+          args = Array(args)
+          options = args.last.is_a?(Hash) ? args.pop : {}
+        end
+          
+        route = if route_name
           @router.named_routes[route_name]
         else
           merged_options = options
@@ -125,7 +137,7 @@ class Usher
         case method
           when :generate
             merged_options ||= recall.merge(options)
-            url = generate_url(route, merged_options)
+            url = generate_url(route, args ? args << merged_options : merged_options)
             url.slice!(-1) if url[-1] == ?/
             url
           else

data/lib/usher/interface/rails3.rb

@@ -35,7 +35,7 @@ class Usher
       
       # Generates a url from Rack env and identifiers or significant keys.
       #
-      # To generate a url by named route, pass the name in as a +Symbol+.
+      # To generate a url by named route, pass the name in as a `Symbol`.
       #   url(env, :dashboard) # => "/dashboard"
       #
       # Additional parameters can be passed in as a hash

data/lib/usher/node.rb

@@ -1,3 +1,5 @@
+require 'set'
+
 require File.join('usher', 'node', 'root')
 require File.join('usher', 'node', 'root_ignoring_trailing_delimiters')
 require File.join('usher', 'node', 'response')
@@ -19,8 +21,10 @@ class Usher
   # @see Root
   class Node
 
-    attr_reader :normal, :greedy, :request
-    attr_accessor :terminates, :request_method_type, :parent, :value, :request_methods
+    Terminates = Struct.new(:choices, :default)
+
+    attr_reader :normal, :greedy, :request, :terminates, :unique_terminating_routes, :meta
+    attr_accessor :default_terminates, :request_method_type, :parent, :value, :request_methods
 
     def initialize(parent, value)
       @parent, @value = parent, value
@@ -29,7 +33,7 @@ class Usher
     def inspect
       out = ''
       out << " " * depth
-      out << "#{terminates? ? '* ' : ''}#{depth}: #{value.inspect}\n"
+      out << "#{terminates ? '* ' : ''}#{depth}: #{value.inspect}\n"
       [:normal, :greedy, :request].each do |node_type|
         send(node_type).each do |k,v|
           out << (" " * (depth + 1)) << "#{node_type.to_s[0].chr} #{k.inspect} ==> \n" << v.inspect
@@ -38,15 +42,44 @@ class Usher
       out
     end
 
-    protected
+    def add_meta(obj)
+      create_meta << obj
+    end
 
+    def add_terminate(path)
+      if path.route.when_proc
+        create_terminate.choices << path
+      else
+        create_terminate.default = path
+      end
+      unique_terminating_routes << path.route
+    end
 
+    def remove_terminate(path)
+      if terminates
+        terminates.choices.delete(path)
+        terminates.default = nil if terminates.default == path
+      end
+      unique_terminating_routes.delete_if{|r| r == path.route}
+    end
+
+    protected
+
+    def create_terminate
+      @unique_terminating_routes ||= Set.new
+      @terminates ||= Terminates.new([], nil)
+    end
+    
+    def create_meta
+      @meta ||= []
+    end
+    
     def depth
       @depth ||= parent.is_a?(Node) ? parent.depth + 1 : 0
     end
 
-    def terminates?
-      @terminates && @terminates.route.recognizable?
+    def pick_terminate(request_object)
+      @terminates.choices.find{|(p, t)| p.call(request_object) && t && t.route.recognizable?} || (@terminates.default && @terminates.default.route.recognizable? ? @terminates.default : nil) if @terminates
     end
 
     def ancestors
@@ -69,19 +102,19 @@ class Usher
       @route_set ||= root.route_set
     end
 
-    def find(request_object, original_path, path, params = [])
+    def find(request_object, original_path, path, params = [], gathered_meta = nil)
+      (gathered_meta ||= []).concat(meta) if meta
       # terminates or is partial
-
-      if terminates? && (path.empty? || terminates.route.partial_match?)
-        response = terminates.route.partial_match? ?
-          Response.new(terminates, params, path.join, original_path[0, original_path.size - path.join.size]) :
-          Response.new(terminates, params, nil, original_path)
+      if terminating_path = pick_terminate(request_object) and (path.empty? || terminating_path.route.partial_match?)
+        response = terminating_path.route.partial_match? ?
+          Response.new(terminating_path, params, path.join, original_path[0, original_path.size - path.join.size], false, gathered_meta) :
+          Response.new(terminating_path, params, nil, original_path, false, gathered_meta)
       # terminates or is partial
       elsif !path.empty? and greedy and match_with_result_output = greedy.match_with_result(whole_path = path.join)
         child_node, matched_part = match_with_result_output
         whole_path.slice!(0, matched_part.size)
         params << matched_part if child_node.value.is_a?(Route::Variable)
-        child_node.find(request_object, original_path, whole_path.empty? ? whole_path : route_set.splitter.split(whole_path), params)
+        child_node.find(request_object, original_path, whole_path.empty? ? whole_path : route_set.splitter.split(whole_path), params, gathered_meta)
       elsif !path.empty? and normal and child_node = normal[path.first] || normal[nil]
         part = path.shift
         case child_node.value
@@ -93,7 +126,7 @@ class Usher
             next_path_part = path.shift                             # and until they are satified,
             part << next_path_part
           end if variable.look_ahead
-          params << part                                              # because its a variable, we need to add it to the params array
+          params << part                                            # because its a variable, we need to add it to the params array
         when Route::Variable::Glob
           params << []
           loop do
@@ -110,22 +143,22 @@ class Usher
             end
           end
         end
-        child_node.find(request_object, original_path, path, params)
+        child_node.find(request_object, original_path, path, params, gathered_meta)
       elsif request_method_type
         if route_set.priority_lookups?
           route_candidates = []
-          if specific_node = request[request_object.send(request_method_type)] and ret = specific_node.find(request_object, original_path, path.dup, params && params.dup)
+          if specific_node = request[request_object.send(request_method_type)] and ret = specific_node.find(request_object, original_path, path.dup, params.dup, gathered_meta && gathered_meta.dup)
             route_candidates << ret
           end
-          if general_node = request[nil] and ret = general_node.find(request_object, original_path, path.dup, params && params.dup)
+          if general_node = request[nil] and ret = general_node.find(request_object, original_path, path.dup, params.dup, gathered_meta && gathered_meta.dup)
             route_candidates << ret
           end
           route_candidates.sort!{|r1, r2| r1.path.route.priority <=> r2.path.route.priority}
           request_method_respond(route_candidates.last, request_method_type)
         else
-          if specific_node = request[request_object.send(request_method_type)] and ret = specific_node.find(request_object, original_path, path.dup, params && params.dup)
+          if specific_node = request[request_object.send(request_method_type)] and ret = specific_node.find(request_object, original_path, path.dup, params.dup, gathered_meta && gathered_meta.dup)
             ret
-          elsif general_node = request[nil] and ret = general_node.find(request_object, original_path, path.dup, params && params.dup)
+          elsif general_node = request[nil] and ret = general_node.find(request_object, original_path, path.dup, params.dup, gathered_meta && gathered_meta.dup)
             request_method_respond(ret, request_method_type)
           else
             request_method_respond(nil, request_method_type)

data/lib/usher/node/response.rb

@@ -1,7 +1,7 @@
 class Usher
   class Node
     # The response from {Usher::Node::Root#lookup}. Adds some convenience methods for common parameter manipulation.
-    class Response < Struct.new(:path, :params_as_array, :remaining_path, :matched_path, :only_trailing_delimiters)
+    class Response < Struct.new(:path, :params_as_array, :remaining_path, :matched_path, :only_trailing_delimiters, :meta)
       
       # The success of the response
       # @return [Boolean] Always returns true

data/lib/usher/node/root.rb

@@ -12,15 +12,19 @@ class Usher
       end
       
       def add(route)
-        route.paths.each { |path| set_path_with_destination(path) }
+        get_nodes_for_route(route) {|p, n| n.add_terminate(p)}
       end
 
       def delete(route)
-        route.paths.each { |path| set_path_with_destination(path, nil) }
+        get_nodes_for_route(route) {|p, n| n.remove_terminate(p)}
+      end
+
+      def add_meta(route, obj)
+        get_nodes_for_route(route) {|p, n| n.add_meta(obj)}
       end
 
       def unique_routes(node = self, routes = [])
-        routes << node.terminates.route if node.terminates
+        routes.concat(node.unique_terminating_routes.to_a) if node.unique_terminating_routes
         [:normal, :greedy, :request].each { |type| node.send(type).values.each { |v| unique_routes(v, routes) } if node.send(type) }
         routes.uniq!
         routes
@@ -33,16 +37,22 @@ class Usher
       private
       
       def set_path_with_destination(path, destination = path)
-        nodes = [path.parts ? path.parts.inject(self){ |node, key| process_path_part(node, key)} : self]
-        nodes = process_request_parts(nodes, request_methods_for_path(path)) if request_methods
-        nodes.each do |node|
-          while node.request_method_type
-            node = (node.request[nil] ||= Node.new(node, Route::RequestMethod.new(node.request_method_type, nil)))
+        get_nodes(path) {|n| n.add_terminate(destination)}
+      end
+
+      def get_nodes_for_route(route)
+        route.paths.each do |path|
+          nodes = [path.parts ? path.parts.inject(self){ |node, key| process_path_part(node, key)} : self]
+          nodes = process_request_parts(nodes, request_methods_for_path(path)) if request_methods
+          nodes.each do |node|
+            while node.request_method_type
+              node = (node.request[nil] ||= Node.new(node, Route::RequestMethod.new(node.request_method_type, nil)))
+            end
+            yield path, node
           end
-          node.terminates = destination
         end
       end
-
+      
       def request_method_index(type)
         request_methods.index(type)
       end

data/lib/usher/route.rb

@@ -6,7 +6,7 @@ require File.join('usher', 'route', 'request_method')
 
 class Usher
   class Route
-    attr_reader   :original_path, :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, :when_proc
     attr_accessor :parent_route, :router, :recognizable
 
     class GenerateWith < Struct.new(:scheme, :port, :host)
@@ -15,6 +15,12 @@ class Usher
       end
     end
 
+    def ==(other_route)
+      if other_route.is_a?(Route)
+        original_path == other_route.original_path && requirements == other_route.requirements && conditions == other_route.conditions && match_partially == other_route.match_partially && recognizable == other_route.recognizable && parent_route == other_route.parent_route && generate_with == other_route.generate_with
+      end
+    end
+
     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
@@ -22,6 +28,11 @@ class Usher
       @generate_with = GenerateWith.new(generate_with[:scheme], generate_with[:port], generate_with[:host]) if generate_with
     end
 
+    def when(&block)
+      @when_proc = block
+      self
+    end
+
     def destination_keys
       @destination_keys ||= case
         when Hash

data/lib/usher/route/path.rb

@@ -11,6 +11,10 @@ class Usher
         build_generator
       end
 
+      def ==(other_path)
+        other_path.is_a?(Path) ? route == other_path.route && parts == other_path.parts : nil
+      end
+      
       def convert_params_array(ary)
         ary.empty? ? ary : dynamic_keys.zip(ary)
       end
@@ -79,35 +83,39 @@ class Usher
         @dynamic = @parts && @parts.any?{|p| p.is_a?(Variable)}
       end
       
-      def build_generator
-        if parts
-          interpolating_path = ''
-        
+      def interpolating_path
+        unless @interpolating_path
+          @interpolating_path = ''
           parts.each_with_index do |part, index|
             case part
             when String
-              interpolating_path << part
+              @interpolating_path << part
             when Static::Greedy
-              interpolating_path << part.generate_with
+              @interpolating_path << part.generate_with
             when Variable::Glob
-              interpolating_path << '#{('
-              interpolating_path << "Array(arg#{index})"
+              @interpolating_path << '#{('
+              @interpolating_path << "Array(arg#{index})"
               if part.default_value
-                interpolating_path << ' || '
-                interpolating_path << part.default_value.inspect
+                @interpolating_path << ' || '
+                @interpolating_path << part.default_value.inspect
               end
-              interpolating_path << ').join(route.router.delimiters.first)}'
+              @interpolating_path << ').join(route.router.delimiters.first)}'
             when Variable
-              interpolating_path << '#{'
-              interpolating_path << "arg#{index}"
+              @interpolating_path << '#{'
+              @interpolating_path << "arg#{index}"
               if part.default_value
-                interpolating_path << ' || '
-                interpolating_path << part.default_value.inspect
+                @interpolating_path << ' || '
+                @interpolating_path << part.default_value.inspect
               end
-              interpolating_path << '}'
+              @interpolating_path << '}'
             end
           end
-        
+        end
+        @interpolating_path
+      end
+      
+      def build_generator
+        if parts
           generating_method =  "def generate"
           if dynamic?
             generating_method << "("

data/lib/usher/util/generate.rb

@@ -75,7 +75,7 @@ class Usher
           result << generate_path(path, params)
         end
 
-        # Generates a completed URL based on a +route+ or set of optional +params+
+        # Generates a completed URL based on a `route` or set of optional `params`
         #
         #   set = Usher.new
         #   route = set.add_named_route(:test_route, '/:controller/:action')

data/lib/usher/util/parser.rb

@@ -43,14 +43,16 @@ class Usher
             part.default_value = default_values[part.name] if part.is_a?(Usher::Route::Variable) && default_values && default_values[part.name]
             case part
             when Usher::Route::Variable::Glob
-              if part.look_ahead && !part.look_ahead_priority
+              possible_look_ahead = path[index + 1, path.size].find{|p| !p.is_a?(Usher::Route::Variable) && !router.delimiters.unescaped.include?(p)} || nil
+              if part.look_ahead && !part.look_ahead_priority && possible_look_ahead != part.look_ahead
                 part.look_ahead = nil
                 part.look_ahead_priority = true
               else
                 part.look_ahead = path[index + 1, path.size].find{|p| !p.is_a?(Usher::Route::Variable) && !router.delimiters.unescaped.include?(p)} || nil
               end
             when Usher::Route::Variable
-              if part.look_ahead && !part.look_ahead_priority
+              possible_look_ahead = router.delimiters.first_in(path[index + 1, path.size]) || router.delimiters.unescaped.first
+              if part.look_ahead && !part.look_ahead_priority && possible_look_ahead != part.look_ahead
                 part.look_ahead = nil
                 part.look_ahead_priority = true
               else

data/lib/usher/util/rails.rb

@@ -10,16 +10,18 @@ class Usher
           ActionController::Routing.module_eval "remove_const(:Routes); Routes = Usher::Interface.for(:rails23)"
 
         when '2.2'
-          class Usher::Interface::Rails22::Mapper
-            include ActionController::Resources
-          end
+          Usher::Interface::Rails22::Mapper.module_eval("include ActionController::Resources")
           ActionController::Routing.module_eval "remove_const(:Routes); Routes = Usher::Interface.for(:rails22)"
 
         when '2.0'
-          class Usher::Interface::Rails20::Mapper
-            include ActionController::Resources
-          end
-
+          Usher::Interface::Rails20::Mapper.module_eval("include ActionController::Resources")
+          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
+        when '3.0'
           ActionController::Routing.module_eval <<-CODE
             remove_const(:Routes);
             interface = Usher::Interface.for(:rails20);

data/spec/private/meta_spec.rb

@@ -0,0 +1,23 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "spec_helper"))
+require "usher"
+
+describe "Usher metadata" do
+
+  it "should add meta data to a path" do
+    usher = Usher.new
+    usher.add_route('/test')
+    usher.add_route('/test/test2')
+    usher.add_route('/test/test3')
+    usher.add_route('/test/test2/:variable')
+    usher.add_meta(:test, '/test')
+    usher.add_meta(:test2, '/test/test2')
+    usher.add_meta(:test3, '/test/test2/:something')
+    
+    usher.recognize_path('/test').meta.should == [:test]
+    usher.recognize_path('/test/test3').meta.should == [:test]
+    usher.recognize_path('/test/test2').meta.should == [:test, :test2]
+    usher.recognize_path('/test/test2/variable1').meta.should == [:test, :test2, :test3]
+    usher.recognize_path('/test/test2/variable2').meta.should == [:test, :test2, :test3]
+    
+  end
+end

data/spec/private/path_spec.rb

@@ -36,7 +36,7 @@ describe "Usher route adding" do
     route_set.add_named_route(:route, '/bad/route', :controller => 'sample').should == route_set.named_routes[:route]
   end
 
-  it "should allow named routes to be added" do
+  it "should allow named routes to be deleted" do
     route_set.add_named_route(:route, '/bad/route', :controller => 'sample').should == route_set.named_routes[:route]
     route_set.route_count.should == 1
     route_set.named_routes.size == 1

data/spec/private/rack/route_spec.rb

@@ -37,6 +37,13 @@ describe "Rack interface extensions for Usher::Route" do
       status, headers, body = @route_set.call(@env)
       body.path.should == File.join(File.dirname(__FILE__), File.basename(__FILE__))
     end
+
+    it "should serve a specific file" do
+      @route_set.get("/static-file").serves_static_from(__FILE__)
+      @env = Rack::MockRequest.env_for("/static-file")
+      status, headers, body = @route_set.call(@env)
+      body.path.should == __FILE__
+    end
   end
 
   describe "chaining" do

data/spec/private/recognize_spec.rb

@@ -84,6 +84,15 @@ describe "Usher route recognition" do
     end
   end
 
+  describe 'when proc' do
+
+    it "pick the correct route" do
+      not_target_route = @route_set.add_route('/sample').when{|r| r.protocol == 'https'}
+      target_route =     @route_set.add_route('/sample').when{|r| r.protocol == 'http'}
+      @route_set.recognize(build_request({:method => 'get', :path => '/sample', :protocol => 'http'})).path.route.should == target_route
+    end
+  end
+
   it "should recognize path with a trailing slash" do
     @route_set = Usher.new(:request_methods => [:protocol, :domain, :port, :query_string, :remote_ip, :user_agent, :referer, :method, :subdomains], :ignore_trailing_delimiters => true)
 
@@ -399,14 +408,14 @@ describe "Usher route recognition" do
 
     it "should not add routes added to the dup to the original" do
       @r2.add_route("/bar", :bar => "bar")
-      @r2.recognize(        build_request(:path => "/bar")).path.route.destination.should == {:bar => "bar"}
-      @route_set.recognize(  build_request(:path => "/bar")).should == nil
+      @r2.recognize(       build_request(:path => "/bar")).path.route.destination.should == {:bar => "bar"}
+      @route_set.recognize(build_request(:path => "/bar")).should == nil
     end
 
     it "should not delete routes added to the dup to the original" do
       @r2.delete_route("/foo")
-      @route_set.recognize(  build_request(:path => "/foo")).path.route.destination.should == {:foo => "foo"}
-      @r2.recognize(        build_request(:path => "/foo")).should == nil
+      @route_set.recognize(build_request(:path => "/foo")).path.route.destination.should == {:foo => "foo"}
+      @r2.recognize(       build_request(:path => "/foo")).should == nil
     end
 
 

data/spec/private/sinatra/recognize_spec.rb

@@ -106,6 +106,16 @@ describe "Usher (for Sinatra) route recognition" do
       response.status.should == 200
       response.body.should == "/hi-18"
     end
+
+    it "should map route with complex params" do
+      @app.get('/hi/:foo/:bar/:baz(.:format)') { "/#{params[:foo]}/#{params[:bar]}/#{params[:baz]}/#{params[:format]}" }
+      response = @app.call_with_mock_request('/hi/foo/bar/baz')
+      response.status.should == 200
+      response.body.should == "/foo/bar/baz/"
+      response = @app.call_with_mock_request('/hi/foo/bar-bax/baz')
+      response.status.should == 200
+      response.body.should == "/foo/bar-bax/baz/"
+    end
   end
 
   describe "not found" do
@@ -128,5 +138,4 @@ describe "Usher (for Sinatra) route recognition" do
       response.body.should_not match(/__sinatra__/)
     end
   end
-
 end

data/spec/spec_helper.rb

@@ -1,6 +1,8 @@
 libdir = File.expand_path("lib")
 $:.unshift(libdir) unless $:.include?(libdir)
 
+require 'usher'
+
 module CallWithMockRequestMixin
   def call_with_mock_request(url = "/sample", method = "GET", params = Hash.new)
     params.merge!(:method => method)

data/usher.gemspec

@@ -5,7 +5,7 @@ require "base64"
 
 Gem::Specification.new do |s|
   s.name = "usher"
-  s.version = "0.8.0"
+  s.version = "0.8.1"
   s.authors = ["Daniel Neighman", "Daniel Vartanov", "Jakub Šťastný", "Joshua Hull", "Davide D'Agostino"].sort
   s.homepage = "http://github.com/joshbuddy/usher"
   s.summary = "Pure ruby general purpose router with interfaces for rails, rack, email or choose your own adventure"

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 8
-  - 0
-  version: 0.8.0
+  - 1
+  version: 0.8.1
 platform: ruby
 authors: 
 - Daniel Neighman
@@ -19,7 +19,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: 
-date: 2010-05-05 00:00:00 -04:00
+date: 2010-05-20 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -142,6 +142,7 @@ files:
 - spec/private/generate_spec.rb
 - spec/private/generate_with_spec.rb
 - spec/private/grapher_spec.rb
+- spec/private/meta_spec.rb
 - spec/private/parser_spec.rb
 - spec/private/path_spec.rb
 - spec/private/rack/dispatch_spec.rb