usher 0.4.8 → 0.5.1

data/README.rdoc

@@ -5,12 +5,14 @@ Tree-based router library. Useful for (specifically) for Rails and Rack, but pro
 == Features
 
 * Understands single and path-globbing variables
+* Understands arbitrary regex variables
 * Arbitrary HTTP header requirements
 * No optimization phase, so routes are always alterable after the fact
 * Understands Proc and Regex transformations, validations
 * Really, really fast
-* Relatively light and happy code-base, should be easy and fun to alter
+* Relatively light and happy code-base, should be easy and fun to alter (it hovers around 1,000 LOC, 800 for the core)
 * Interface and implementation are separate, encouraging cross-pollination
+* Works in 1.9!
 
 == Route format
 
@@ -57,6 +59,15 @@ But not
 As well, the same logic applies for * variables as well, where only parts matchable by the supplied regex will
 actually be bound to the variable
 
+Variables can also have a greedy regex matcher. These matchers ignore all delimiters, and continue matching for as long as much as their 
+regex allows.
+
+<b>Example:</b>
+<tt>/product/{!id,hello/world|hello}</tt> would match
+
+* <tt>/product/hello/world</tt>
+* <tt>/product/hello</tt>
+
 ==== Static
 
 Static parts of literal character sequences. For instance, <tt>/path/something.html</tt> would match only the same path.

data/Rakefile

@@ -9,8 +9,11 @@ begin
     s.homepage = "http://github.com/joshbuddy/usher"
     s.authors = ["Joshua Hull"]
     s.files = FileList["[A-Z]*", "{lib,spec,rails}/**/*"]
-    s.add_dependency 'fuzzyhash', '>=0.0.3'
-    s.rubyforge_project = 'joshbuddy-usher' # This line would be new
+    s.add_dependency 'fuzzyhash', '>=0.0.6'
+    s.rubyforge_project = 'joshbuddy-usher'
+  end
+  Jeweler::RubyforgeTasks.new do |rubyforge|
+    rubyforge.doc_task = "rdoc"
   end
 rescue LoadError
   puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
@@ -43,30 +46,3 @@ Rake::RDocTask.new do |rd|
   rd.rdoc_files.include("README.rdoc", "lib/**/*.rb")
   rd.rdoc_dir = 'rdoc'
 end
-
-# These are new tasks
-begin
-  require 'rake/contrib/sshpublisher'
-  namespace :rubyforge do
-
-    desc "Release gem and RDoc documentation to RubyForge"
-    task :release => ["rubyforge:release:gem", "rubyforge:release:docs"]
-
-    namespace :release do
-      desc "Publish RDoc to RubyForge."
-      task :docs => [:rdoc] do
-        config = YAML.load(
-            File.read(File.expand_path('~/.rubyforge/user-config.yml'))
-        )
-
-        host = "#{config['username']}@rubyforge.org"
-        remote_dir = "/var/www/gforge-projects/joshbuddy-usher/"
-        local_dir = 'rdoc'
-
-        Rake::SshDirPublisher.new(host, remote_dir, local_dir).upload
-      end
-    end
-  end
-rescue LoadError
-  puts "Rake SshDirPublisher is unavailable or your rubyforge environment is not configured."
-end

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
-:minor: 4
-:patch: 8
 :major: 0
+:minor: 5
+:patch: 1

data/lib/usher.rb

@@ -4,14 +4,12 @@ require File.join(File.dirname(__FILE__), 'usher', 'grapher')
 require File.join(File.dirname(__FILE__), 'usher', 'interface')
 require File.join(File.dirname(__FILE__), 'usher', 'splitter')
 require File.join(File.dirname(__FILE__), 'usher', 'exceptions')
+require File.join(File.dirname(__FILE__), 'usher', 'util')
 
 class Usher
-
-  autoload :Generators, File.join(File.dirname(__FILE__), 'usher', 'generate')
-
-  attr_reader :tree, :named_routes, :route_count, :routes, :splitter, :delimiters
-  
-  SymbolArraySorter = proc {|a,b| a.hash <=> b.hash} #:nodoc:
+  attr_reader :root, :named_routes, :routes, :splitter, 
+              :delimiters, :delimiter_chars, :delimiters_regex, 
+              :parent_route, :generator
   
   # Returns whether the route set is empty
   #   
@@ -20,9 +18,13 @@ class Usher
   #   set.add_route('/test')
   #   set.empty? => false
   def empty?
-    @route_count.zero?
+    @routes.empty?
   end
-
+  
+  def route_count
+    @routes.size
+  end
+  
   # Resets the route set back to its initial state
   #   
   #   set = Usher.new
@@ -31,19 +33,15 @@ class Usher
   #   set.reset!
   #   set.empty? => true
   def reset!
-    @tree = Node.root(self, @request_methods, @globs_capture_separators)
+    @root = Node.root(self, request_methods)
     @named_routes = {}
     @routes = []
-    @route_count = 0
     @grapher = Grapher.new
   end
   alias clear! reset!
   
   # Creates a route set, with options
   # 
-  # <tt>:globs_capture_separators</tt>: +true+ or +false+. (default +false+) Specifies whether glob matching will also include separators
-  # that are matched.
-  # 
   # <tt>:delimiters</tt>: Array of Strings. (default <tt>['/', '.']</tt>). Delimiters used in path separation. Array must be single character strings.
   # 
   # <tt>:valid_regex</tt>: String. (default <tt>'[0-9A-Za-z\$\-_\+!\*\',]+'</tt>). String that can be interpolated into regex to match
@@ -52,15 +50,26 @@ class Usher
   # <tt>:request_methods</tt>: Array of Symbols. (default <tt>[:protocol, :domain, :port, :query_string, :remote_ip, :user_agent, :referer, :method, :subdomains]</tt>)
   # Array of methods called against the request object for the purposes of matching route requirements.
   def initialize(options = nil)
-    @globs_capture_separators = options && options.key?(:globs_capture_separators) ? options.delete(:globs_capture_separators) : false
-    @delimiters = options && options.delete(:delimiters) || ['/', '.']
-    @valid_regex = options && options.delete(:valid_regex) || '[0-9A-Za-z\$\-_\+!\*\',]+'
-    @request_methods = options && options.delete(:request_methods) || [:protocol, :domain, :port, :query_string, :remote_ip, :user_agent, :referer, :method, :subdomains]
-    @splitter = Splitter.for_delimiters(@delimiters, @valid_regex)
+    self.generator = options && options.delete(:generator)
+    self.delimiters = options && options.delete(:delimiters) || ['/', '.']
+    self.valid_regex = options && options.delete(:valid_regex) || '[0-9A-Za-z\$\-_\+!\*\',]+'
+    self.request_methods = options && options.delete(:request_methods) || [:protocol, :domain, :port, :query_string, :remote_ip, :user_agent, :referer, :method, :subdomains]
     reset!
   end
 
-  # Adds a route referencable by +name+. Sett add_route for format +path+ and +options+.
+  def parser
+    @parser ||= Util::Parser.for_delimiters(self, valid_regex)
+  end
+
+  def can_generate?
+    !@generator.nil?
+  end
+  
+  def generator
+    @generator
+  end
+  
+  # Adds a route referencable by +name+. See add_route for format +path+ and +options+.
   #   
   #   set = Usher.new
   #   set.add_named_route(:test_route, '/test')
@@ -68,6 +77,15 @@ class Usher
     add_route(path, options).name(name)
   end
 
+  # Deletes a route referencable by +name+. At least the path and conditions have to match the route you intend to delete.
+  #   
+  #   set = Usher.new
+  #   set.delete_named_route(:test_route, '/test')
+  def delete_named_route(name, path, options = nil)
+    delete_route(path, options)
+    @named_routes.delete(name)
+  end
+
   # Attaches a +route+ to a +name+
   #   
   #   set = Usher.new
@@ -119,6 +137,15 @@ class Usher
   # As well, the same logic applies for * variables as well, where only parts matchable by the supplied regex will
   # actually be bound to the variable
   #
+  # Variables can also have a greedy regex matcher. These matchers ignore all delimiters, and continue matching for as long as much as their 
+  # regex allows.
+  #
+  # <b>Example:</b>
+  # <tt>/product/{!id,hello/world|hello}</tt> would match
+  # 
+  # * <tt>/product/hello/world</tt>
+  # * <tt>/product/hello</tt>
+  #
   # ==== Static
   #
   # Static parts of literal character sequences. For instance, <tt>/path/something.html</tt> would match only the same path.
@@ -140,25 +167,23 @@ class Usher
   # * +conditions+ - Accepts any of the +request_methods+ specificied in the construction of Usher. This can be either a <tt>string</tt> or a regular expression.
   # * Any other key is interpreted as a requirement for the variable of its name.
   def add_route(path, options = nil)
-    conditions = options && options.delete(:conditions) || nil
-    requirements = options && options.delete(:requirements) || nil
-    default_values = options && options.delete(:default_values) || nil
-    generate_with = options && options.delete(:generate_with) || nil
-    if options
-      options.delete_if do |k, v|
-        if v.is_a?(Regexp) || v.is_a?(Proc)
-          (requirements ||= {})[k] = v 
-          true
-        end
-      end
-    end
-    route = Route.new(path, self, conditions, requirements, default_values, generate_with)
-    route.to(options) if options && !options.empty?
-    
-    @tree.add(route)
+    route = get_route(path, options)
+    @root.add(route)
     @routes << route
     @grapher.add_route(route)
-    @route_count += 1
+    route.parent_route = parent_route if parent_route
+    route
+  end
+
+  # Deletes a route. At least the path and conditions have to match the route you intend to delete.
+  #   
+  #   set = Usher.new
+  #   set.delete_route('/test')
+  def delete_route(path, options = nil)
+    route = get_route(path, options)
+    @root.delete(route)
+    @routes = @root.unique_routes
+    rebuild_grapher!
     route
   end
 
@@ -169,7 +194,17 @@ class Usher
   #   route = set.add_route('/test')
   #   set.recognize(Request.new('/test')).path.route == route => true
   def recognize(request, path = request.path)
-    @tree.find(self, request, @splitter.url_split(path))
+    @root.find(self, request, path, @splitter.url_split(path))
+  end
+
+  # Recognizes a +path+ and returns +nil+ or an Usher::Node::Response, which is a struct containing a Usher::Route::Path and an array of arrays containing the extracted parameters. Convenience method for when recognizing on the request object is unneeded.
+  #   
+  #   Request = Struct.new(:path)
+  #   set = Usher.new
+  #   route = set.add_route('/test')
+  #   set.recognize_path('/test').path.route == route => true
+  def recognize_path(path)
+    recognize(nil, path)
   end
 
   # Recognizes a set of +parameters+ and gets the closest matching Usher::Route::Path or +nil+ if no route exists.
@@ -181,4 +216,58 @@ class Usher
     @grapher.find_matching_path(options)
   end
   
+  def parent_route=(route)
+    @parent_route = route
+    routes.each{|r| r.parent_route = route}
+  end
+  
+  private
+  
+  attr_accessor :request_methods
+  attr_reader :valid_regex
+
+  def generator=(generator)
+    if generator
+      @generator = generator
+      @generator.usher = self
+    end
+    @generator
+  end
+  
+  def delimiters=(delimiters)
+    @delimiters = delimiters
+    @delimiter_chars = @delimiters.collect{|d| d[0]}
+    @delimiters_regex = @delimiters.collect{|d| Regexp.quote(d)} * '|'
+    @delimiters
+  end
+
+  def valid_regex=(valid_regex)
+    @valid_regex = valid_regex
+    @splitter = Splitter.for_delimiters(self, @valid_regex)
+    @valid_regex
+  end
+
+  def get_route(path, options = nil)
+    conditions = options && options.delete(:conditions) || nil
+    requirements = options && options.delete(:requirements) || nil
+    default_values = options && options.delete(:default_values) || nil
+    generate_with = options && options.delete(:generate_with) || nil
+    if options
+      options.delete_if do |k, v|
+        if v.is_a?(Regexp) || v.is_a?(Proc)
+          (requirements ||= {})[k] = v 
+          true
+        end
+      end
+    end
+    
+    route = parser.generate_route(path, conditions, requirements, default_values, generate_with)
+    route.to(options) if options && !options.empty?
+    route
+  end
+  
+  def rebuild_grapher!
+    @grapher = Grapher.new
+    @routes.each{|r| @grapher.add_route(r)}
+  end
 end

data/lib/usher/grapher.rb

@@ -14,7 +14,7 @@ class Usher
 
     def add_route(route)
       route.paths.each do |path|
-        unless path.dynamic_keys.size.zero?
+        if path.dynamic?
           path.dynamic_keys.each do |k|
             @orders[path.dynamic_keys.size][k] << path
             @key_count[k] += 1
@@ -50,16 +50,17 @@ class Usher
         end
         set.size.downto(1) do |o|
           set.each do |k|
-            @orders[o][k].each { |r| 
+            @orders[o][k].each do |r| 
               if r.can_generate_from?(set)
                 @cache[set] = r
                 return r
               end
-            }
+            end
           end
         end
-        nil
       end
+      nil
     end
+    
   end
 end

data/lib/usher/interface.rb

@@ -5,19 +5,26 @@ class Usher
     autoload :MerbInterface, File.join(File.dirname(__FILE__), 'interface', 'merb_interface')
     autoload :RackInterface, File.join(File.dirname(__FILE__), 'interface', 'rack_interface')
     autoload :EmailInterface, File.join(File.dirname(__FILE__), 'interface', 'email_interface')
+    autoload :Rails3Interface, File.join(File.dirname(__FILE__), 'interface', 'rails3_interface')
     
     def self.for(type, &blk)
+      class_for(type).new(&blk)
+    end
+    
+    def self.class_for(type)
       case type
       when :rails2_2
-        Rails2_2Interface.new(&blk)
+        Rails2_2Interface
       when :rails2_3
-        Rails2_3Interface.new(&blk)
+        Rails2_3Interface
       when :merb
-        MerbInterface.new(&blk)
+        MerbInterface
       when :rack
-        RackInterface.new(&blk)
+        RackInterface
       when :email
-        EmailInterface.new(&blk)
+        EmailInterface
+      when :rails3
+        Rails3Interface
       end
       
     end

data/lib/usher/interface/email_interface.rb

@@ -3,7 +3,7 @@ class Usher
     class EmailInterface
       
       def initialize(&blk)
-        @routes = Usher.new(:delimiters => ['@', '-', '.'], :valid_regex => '[\+a-zA-Z0-9]+', :globs_capture_separators => true)
+        @routes = Usher.new(:delimiters => ['@', '-', '.'], :valid_regex => '[\+a-zA-Z0-9]+')
         instance_eval(&blk) if blk
       end
       

data/lib/usher/interface/rack_interface.rb

@@ -4,34 +4,52 @@ class Usher
   module Interface
     class RackInterface
       
-      attr_accessor :routes
-      
       def initialize(&blk)
-        @routes = Usher.new(:request_methods => [:method, :host, :port, :scheme])
-        @generator = Usher::Generators::URL.new(@routes)
+        @router = Usher.new(:request_methods => [:method, :host, :port, :scheme], :generator => Usher::Util::Generators::URL.new)
         instance_eval(&blk) if blk
       end
       
       def add(path, options = nil)
-        @routes.add_route(path, options)
+        @router.add_route(path, options)
+      end
+      
+      def parent_route=(route)
+        @router.parent_route = route
+      end
+      
+      def parent_route
+        @router.parent_route
       end
 
       def reset!
-        @routes.reset!
+        @router.reset!
       end
 
       def call(env)
-        response = @routes.recognize(Rack::Request.new(env))
-        params = {}
-        response.params.each{ |hk| params[hk.first] = hk.last}
-        env['usher.params'] = params
-        response.path.route.destination.call(env)
+        env['usher.params'] ||= {}
+        response = @router.recognize(request = Rack::Request.new(env), request.path_info)
+        if response.nil?
+          body = "No route found"
+          headers = {"Content-Type" => "text/plain", "Content-Length" => body.length.to_s}
+          [404, headers, [body]]
+        else
+          params = response.path.route.default_values || {}
+          response.params.each{ |hk| params[hk.first] = hk.last}
+          
+          # consume the path_info to the script_name response.remaining_path
+          env["SCRIPT_NAME"] << response.matched_path   || ""
+          env["PATH_INFO"] = response.remaining_path    || ""
+                    
+          env['usher.params'].merge!(params)
+          
+          response.path.route.destination.call(env)
+        end
       end
 
       def generate(route, params = nil, options = nil)
-        @generator.generate(route, params, options)
+        @usher.generator.generate(route, params, options)
       end
 
     end
   end
-end
+end