joshbuddy-usher 0.5.1 → 0.5.2

data/README.rdoc

@@ -12,6 +12,7 @@ Tree-based router library. Useful for (specifically) for Rails and Rack, but pro
 * Really, really fast
 * 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
 
@@ -67,6 +68,7 @@ regex allows.
 * <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

@@ -10,6 +10,11 @@ begin
     s.authors = ["Joshua Hull"]
     s.files = FileList["[A-Z]*", "{lib,spec,rails}/**/*"]
     s.add_dependency 'fuzzyhash', '>=0.0.6'
+    s.rubyforge_project = 'joshbuddy-usher'
+  end
+  Jeweler::RubyforgeTasks.new do |rubyforge|
+    rubyforge.doc_task = "rdoc"
+    rubyforge.remote_doc_path = ''
   end
 rescue LoadError
   puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
@@ -42,30 +47,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 @@
 --- 
-:major: 0
 :minor: 5
-:patch: 1
+:patch: 2
+:major: 0

data/lib/usher.rb

@@ -7,11 +7,9 @@ require File.join(File.dirname(__FILE__), 'usher', 'exceptions')
 require File.join(File.dirname(__FILE__), 'usher', 'util')
 
 class Usher
-
-
-  attr_reader :tree, :named_routes, :route_count, :routes, :splitter, :delimiters, :delimiter_chars, :delimiters_regex
-  
-  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,10 +33,9 @@ class Usher
   #   set.reset!
   #   set.empty? => true
   def reset!
-    @tree = Node.root(self, @request_methods)
+    @root = Node.root(self, request_methods)
     @named_routes = {}
     @routes = []
-    @route_count = 0
     @grapher = Grapher.new
   end
   alias clear! reset!
@@ -49,20 +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)
-    @delimiters = options && options.delete(:delimiters) || ['/', '.']
-    @delimiter_chars = @delimiters.collect{|d| d[0]}
-    @delimiters_regex = @delimiters.collect{|d| Regexp.quote(d)} * '|'
-    @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(self, @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
 
   def parser
-    @parser ||= Util::Parser.for_delimiters(self, @valid_regex)
+    @parser ||= Util::Parser.for_delimiters(self, valid_regex)
   end
 
-  # Adds a route referencable by +name+. Sett add_route for format +path+ and +options+.
+  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')
@@ -70,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
@@ -150,57 +166,24 @@ class Usher
   # * +requirements+ - After transformation, tests the condition using ===. If it returns false, it raises an <tt>Usher::ValidationException</tt>
   # * +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(unprocessed_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
-    
-    unprocessed_path = parser.parse(unprocessed_path, requirements, default_values) if unprocessed_path.is_a?(String)
-    
-    unless unprocessed_path.first.is_a?(Route::Util::Group)
-      group = Usher::Route::Util::Group.new(:all, nil)
-      unprocessed_path.each{|p| group << p}
-      unprocessed_path = group
-    end
-
-    paths = Route::Util.expand_path(unprocessed_path)
-    
-    paths.each do |path|
-      path.each_with_index do |part, index|
-        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
-          part.look_ahead = path[index + 1, path.size].find{|p| !p.is_a?(Usher::Route::Variable) && !delimiter_chars.include?(p[0])} || nil
-        when Usher::Route::Variable
-          part.look_ahead = path[index + 1, path.size].find{|p| delimiter_chars.include?(p[0])} || delimiters.first
-        end
-      end
-    end
-
-    route = Route.new(
-      paths,
-      self, 
-      conditions, 
-      requirements, 
-      default_values, 
-      generate_with
-    )
-    
-    route.to(options) if options && !options.empty?
-    
-    @tree.add(route)
+  def add_route(path, options = nil)
+    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
 
@@ -211,7 +194,7 @@ 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, path, @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.
@@ -233,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

@@ -58,8 +58,9 @@ class Usher
             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/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::Util::Generators::URL.new(@routes)
+        @router = Usher.new(:request_methods => [:request_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

data/lib/usher/interface/rails2_2_interface.rb

@@ -12,8 +12,7 @@ class Usher
       end
       
       def reset!
-        @usher ||= Usher.new
-        @url_generator ||= Usher::Util::Generators::URL.new(@usher)
+        @usher ||= Usher.new(:generator => Usher::Util::Generators::URL.new)
         @module ||= Module.new
         @module.instance_methods.each do |selector|
           @module.class_eval { remove_method selector }
@@ -86,7 +85,7 @@ class Usher
       end
       
       def generate_url(route, params)
-        @url_generator.generate(route, params)
+        @usher.generator.generate(route, params)
       end
       
       def path_for_options(options)

data/lib/usher/interface/rails2_3_interface.rb

@@ -72,8 +72,7 @@ class Usher
       end
       
       def reset!
-        @router = Usher.new
-        @url_generator = Usher::Util::Generators::URL.new(@router)
+        @router = Usher.new(:generator => Usher::Util::Generators::URL.new)
         @configuration_files = []
         @module ||= Module.new
         @controller_route_added = false
@@ -123,7 +122,7 @@ class Usher
       end
       
       def generate_url(route, params)
-        @url_generator.generate(route, params)
+        @router.generator.generate(route, params)
       end
       
       def path_for_options(options)