usher 0.5.13 → 0.6.0

data/README.rdoc

@@ -89,6 +89,7 @@ For instance, the path, <tt>/path/something(.xml|.html)</tt> would only match <t
 * +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.
 * +default_values+ - Provides values for variables in your route for generation. If you're using URL generation, then any values supplied here that aren't included in your path will be appended to the query string.
+* +priority+ - If there are two routes which equally match, the route with the highest priority will match first.
 * Any other key is interpreted as a requirement for the variable of its name.
 
 == Rails
@@ -123,6 +124,21 @@ For instance, the path, <tt>/path/something(.xml|.html)</tt> would only match <t
   >> curl http://127.0.0.1:3000/hello/samueltanders
   << Hi there samueltanders
 
+
+== Sinatra
+
+In Sinatra, you get the extra method, +generate+, which lets you generate a url. Name your routes with <tt>:name</tt> when you define them.
+
+  require 'rubygems'
+  require 'usher'
+  require 'sinatra'
+  
+  Usher::Interface.for(:sinatra)
+  
+  get '/hi', :name => :hi do
+    "Hello World! #{generate(:hi)}"
+  end
+
 == DONE
 
 * add support for () optional parts

data/Rakefile

@@ -11,7 +11,7 @@ begin
     s.homepage = "http://github.com/joshbuddy/usher"
     s.authors = ["Joshua Hull", 'Jakub Šťastný', 'Daniel Neighman', 'Daniel Vartanov'].sort
     s.files = FileList["[A-Z]*", "{lib,spec,rails}/**/*"]
-    s.add_dependency 'fuzzyhash', '>=0.0.9'
+    s.add_dependency 'fuzzyhash', '>=0.0.11'
     s.rubyforge_project = 'joshbuddy-usher'
   end
   Jeweler::GemcutterTasks.new

data/VERSION.yml

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

data/lib/usher.rb

@@ -1,4 +1,4 @@
-$: << File.expand_path(File.dirname(__FILE__))
+$LOAD_PATH << File.expand_path(File.dirname(__FILE__))
 require File.join('usher', 'node')
 require File.join('usher', 'route')
 require File.join('usher', 'grapher')
@@ -6,7 +6,6 @@ require File.join('usher', 'interface')
 require File.join('usher', 'splitter')
 require File.join('usher', 'exceptions')
 require File.join('usher', 'util')
-require File.join('usher', 'spinoffs', 'strscan_additions')
 require File.join('usher', 'delimiters')
 
 class Usher
@@ -26,6 +25,8 @@ class Usher
     @routes.empty?
   end
 
+  # Returns the number of routes
+  #
   def route_count
     @routes.size
   end
@@ -41,7 +42,7 @@ class Usher
     @root = Node.root(self, request_methods)
     @named_routes = {}
     @routes = []
-    @grapher = Grapher.new
+    @grapher = Grapher.new(self)
     @priority_lookups = false
   end
   alias clear! reset!
@@ -55,14 +56,34 @@ 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.
+  #
+  # <tt>:generator</tt>: +nil+ or Generator instance. (default: +nil+) Take a look at <tt>Usher::Util::Generators for examples.</tt>.
+  #
+  # <tt>:ignore_trailing_delimiters</tt>: +true+ or +false+. (default: +false+) Ignore trailing delimiters in recognizing paths.
+  #
+  # <tt>:consider_destination_keys</tt>: +true+ or +false+. (default: +false+) When generating, and using hash destinations, you can have
+  # Usher use the destination hash to match incoming params.
+  #
+  # 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.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
     reset!
   end
 
+  def ignore_trailing_delimiters?
+    @ignore_trailing_delimiters
+  end
+  
+  def consider_destination_keys?
+    @consider_destination_keys
+  end
+  
   def parser
     @parser ||= Util::Parser.for_delimiters(self, valid_regex)
   end
@@ -172,6 +193,7 @@ 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.
   # * +default_values+ - Provides values for variables in your route for generation. If you're using URL generation, then any values supplied here that aren't included in your path will be appended to the query string.
+  # * +priority+ - If there are two routes which equally match, the route with the highest priority will match first.
   # * Any other key is interpreted as a requirement for the variable of its name.
   def add_route(path, options = nil)
     route = get_route(path, options)
@@ -252,7 +274,7 @@ class Usher
 
   private
 
-  attr_accessor :request_methods
+  attr_accessor :request_methods, :ignore_trailing_delimiters, :consider_destination_keys
   attr_reader :valid_regex
 
   def generator=(generator)
@@ -308,7 +330,7 @@ class Usher
   end
 
   def rebuild_grapher!
-    @grapher = Grapher.new
+    @grapher = Grapher.new(self)
     @routes.each{|r| @grapher.add_route(r)}
   end
 end

data/lib/usher/delimiters.rb

@@ -1,22 +1,24 @@
-class Delimiters < Array
+class Usher
+  class Delimiters < Array
 
-  attr_reader :unescaped
+    attr_reader :unescaped
   
-  def initialize(ary)
-    super ary
-    @unescaped = self.map do |delimiter|
-      (delimiter[0] == ?\\) ? delimiter[1..-1] : delimiter
+    def initialize(ary)
+      super ary
+      @unescaped = self.map do |delimiter|
+        (delimiter[0] == ?\\) ? delimiter[1..-1] : delimiter
+      end
     end
-  end
   
-  def first_in(array)
-    # TODO: should we optimize this O(n*m)? hash or modified or KNP or at leaset sort + b-search. But they are so short
+    def first_in(array)
+      # TODO: should we optimize this O(n*m)? hash or modified or KNP or at leaset sort + b-search. But they are so short
 
-    array.each do |element|
-      return element if self.unescaped.any? { |delimiter| delimiter == element }
+      array.each do |element|
+        return element if self.unescaped.any? { |delimiter| delimiter == element }
+      end
+      nil    
     end
-    nil    
-  end
 
-  # TODO: Delimiters#regex and so on  
+    # TODO: Delimiters#regex and so on  
+  end
 end

data/lib/usher/grapher.rb

@@ -1,7 +1,10 @@
 class Usher
   class Grapher
 
-    def initialize
+    attr_reader :routes, :router, :orders, :key_count, :cache
+
+    def initialize(router)
+      @router = router
       reset!
     end
 
@@ -10,49 +13,69 @@ class Usher
       @orders = Hash.new{|h,k| h[k] = Hash.new{|h2, k2| h2[k2] = []}}
       @key_count = Hash.new(0)
       @cache = {}
+      @routes = []
     end
 
     def add_route(route)
-      route.paths.each do |path|
-        if path.dynamic?
-          path.dynamic_keys.each do |k|
-            @orders[path.dynamic_keys.size][k] << path
-            @key_count[k] += 1
-          end
-          
-          dynamic_parts_with_defaults = path.dynamic_parts.select{|part| part.default_value }.map{|dp| dp.name}
-          dynamic_parts_without_defaults = path.dynamic_parts.select{|part| !part.default_value }.map{|dp| dp.name}
+      routes << route
+    end
+
+    def process_routes
+      return if @processed 
+      routes.each do |route|
+        route.paths.each do |path|
+          if path.dynamic?
+            path.dynamic_keys.each do |k|
+              orders[path.dynamic_keys.size][k] << path
+              key_count[k] += 1
+            end
+
+            dynamic_parts_with_defaults    = path.dynamic_parts.select{|part| part.default_value }.map{|dp| dp.name}
+            dynamic_parts_without_defaults = path.dynamic_parts.select{|part| !part.default_value }.map{|dp| dp.name}
 
-          (1...(2 ** (dynamic_parts_with_defaults.size))).each do |i|
-            current_set = dynamic_parts_without_defaults.dup
-            dynamic_parts_with_defaults.each_with_index do |dp, index|
-              current_set << dp unless (index & i) == 0
+            (1...(2 ** (dynamic_parts_with_defaults.size))).each do |i|
+              current_set = dynamic_parts_without_defaults.dup
+              dynamic_parts_with_defaults.each_with_index do |dp, index|
+                current_set << dp unless (index & i) == 0
+              end
+
+              current_set.each do |k|
+                orders[current_set.size][k] << path
+                key_count[k] += 1
+              end
             end
 
-            current_set.each do |k|
-              @orders[current_set.size][k] << path
-              @key_count[k] += 1
+          end
+
+          if router.consider_destination_keys?
+            path.route.destination_keys.each do |k|
+              orders[path.route.destination_keys.size][k] << path
+              key_count[k] += 1
             end
           end
         end
       end
+      @processed = true
     end
 
     def significant_keys
-      @significant_keys ||= @key_count.keys.uniq
+      @significant_keys ||= key_count.keys.uniq
     end
 
     def find_matching_path(params)
       unless params.empty?
+        process_routes
         set = params.keys & significant_keys
-        if cached = @cache[set] 
+        if cached = cache[set] 
           return cached
         end
         set.size.downto(1) do |o|
           set.each do |k|
-            @orders[o][k].each do |r| 
-              if r.can_generate_from?(set)
-                @cache[set] = r
+            orders[o][k].each do |r| 
+              if r.can_generate_from_keys?(set)
+                cache[set] = r
+                return r
+              elsif router.consider_destination_keys? && r.can_generate_from_params?(params)
                 return r
               end
             end

data/lib/usher/interface.rb

@@ -15,18 +15,22 @@ class Usher
     register(:rack,     File.join(File.dirname(__FILE__), 'interface', 'rack'))
     register(:rails3,   File.join(File.dirname(__FILE__), 'interface', 'rails3'))
     register(:text,     File.join(File.dirname(__FILE__), 'interface', 'text'))
+    register(:sinatra,  File.join(File.dirname(__FILE__), 'interface', 'sinatra'))
 
-    # Usher::Interface.for(:rack, &block)
-    def self.for(name, &block)
+    def self.class_for(name)
       name = name.to_sym
       if InterfaceRegistry[name]
         require InterfaceRegistry[name]
-        const = Usher::Interface.const_get(File.basename(InterfaceRegistry[name]).to_s.split(/_/).map{|e| e.capitalize}.join)
-        const.new(&block)
+        Usher::Interface.const_get(File.basename(InterfaceRegistry[name]).to_s.split(/_/).map{|e| e.capitalize}.join)
       else
         raise ArgumentError, "Interface #{name.inspect} doesn't exist. Choose one of: #{InterfaceRegistry.keys.inspect}"
       end
     end
 
+    # Usher::Interface.for(:rack, &block)
+    def self.for(name, *args, &block)
+      class_for(name).new(*args, &block)
+    end
+
   end
 end

data/lib/usher/interface/sinatra.rb

@@ -0,0 +1,66 @@
+class Usher
+  module Interface
+    class Sinatra
+      
+      module Extension
+        
+        def self.included(cls)
+          cls::Base.class_eval(<<-HERE_DOC, __FILE__, __LINE__)
+            def self.route(verb, path, options={}, &block)
+              @router ||= Usher.new(:request_methods => [:request_method, :host, :port, :scheme], :generator => Usher::Util::Generators::URL.new)
+
+              name = options.delete(:name)
+              options[:conditions] ||= {}
+              options[:conditions][:request_method] = verb
+              options[:conditions][:host] = options.delete(:host) if options.key?(:host)
+
+              # Because of self.options.host
+              host_name(options.delete(:host)) if options.key?(:host)
+
+              define_method "\#{verb} \#{path}", &block
+              unbound_method = instance_method("\#{verb} \#{path}")
+              block =
+                if block.arity != 0
+                  lambda { unbound_method.bind(self).call(*@block_params) }
+                else
+                  lambda { unbound_method.bind(self).call }
+                end
+
+              invoke_hook(:route_added, verb, path, block)
+
+              route = @router.add_route(path, options).to(block)
+              route.name(name) if name
+              route
+            end          
+
+            def self.router
+              @router
+            end
+
+            def route!(base = self.class)
+              if self.class.router and match = self.class.router.recognize(@request)
+                @block_params = match.params.map{|p| p.last}
+                @params = @params ? @params.merge(match.params_as_hash) : match.params_as_hash
+                route_eval(&match.destination)
+              elsif base.superclass.respond_to?(:routes)
+                route! base.superclass
+              else
+                route_missing
+              end
+            end
+            
+            def generate(name, *params)
+              self.class.router.generator.generate(name, *params)
+            end
+
+          HERE_DOC
+        end
+        
+      end
+      
+      def initialize
+        ::Sinatra.send(:include, Extension)
+      end
+    end
+  end
+end

data/lib/usher/node.rb

@@ -8,6 +8,14 @@ class Usher
       def partial_match?
         !remaining_path.nil?
       end
+      
+      def params_as_hash
+        params.inject({}){|hash, pair| hash[pair.first] = pair.last; hash}
+      end
+      
+      def destination
+        path && path.route.destination
+      end
     end
     
     attr_reader :normal, :greedy, :request
@@ -112,7 +120,7 @@ class Usher
     end
     
     def find(usher, request_object, original_path, path, params = [], position = 0)
-      if terminates? && (path.empty? || terminates.route.partial_match?)
+      if terminates? && (path.empty? || terminates.route.partial_match? || (usher.ignore_trailing_delimiters? && path.all?{|p| usher.delimiters.include?(p)}))
         terminates.route.partial_match? ?
           Response.new(terminates, params, original_path[position, original_path.size], original_path[0, position]) :
           Response.new(terminates, params, nil, original_path)

data/lib/usher/route.rb

@@ -22,9 +22,20 @@ class Usher
       @generate_with = GenerateWith.new(generate_with[:scheme], generate_with[:port], generate_with[:host]) if generate_with
     end
 
+    def destination_keys
+      @destination_keys ||= case
+      when Hash
+        destination.keys
+      when CompoundDestination
+        destination.options.keys
+      else
+        nil
+      end
+    end
+
     def grapher
       unless @grapher
-        @grapher = Grapher.new
+        @grapher = Grapher.new(router)
         @grapher.add_route(self)
       end
       @grapher
@@ -53,12 +64,17 @@ class Usher
     end
 
     def find_matching_path(params)
-      if params.nil? || params.empty?
-        matching_path = @paths.first
+      #if router.find_matching_paths_based_on_destination_keys?
+      matching_path = if params.nil? || params.empty?
+        @paths.first
       else
-        matching_path = @paths.size == 1 ? @paths.first : grapher.find_matching_path(params)
+        @paths.size == 1 ? @paths.first : grapher.find_matching_path(params)
       end
-
+      
+      if matching_path.nil? and router.find_matching_paths_based_on_destination_keys?
+        # do something
+      end
+      
       if parent_route
         matching_path = parent_route.find_matching_path(params).merge(matching_path)
         matching_path.route = self
@@ -67,21 +83,38 @@ class Usher
       matching_path
     end
 
-    # Sets +options+ on a route. Returns +self+.
+    CompoundDestination = Struct.new(:args, :block, :options)
+
+    # Sets destination on a route. Returns +self+.
+    #
+    # This method acceps varargs. If you pass in more than one variable, it will be returned to you wrapped in a +CompoundDestination+.
+    # If you send it varargs and the last member is a Hash, it will pop off the hash, and will be stored under <tt>#options</tt>.
+    # Otherwise, if you use send a single variable, or call it with a block, these will be returned to you by <tt>#destination</tt>.
     #
     #   Request = Struct.new(:path)
     #   set = Usher.new
     #   route = set.add_route('/test')
     #   route.to(:controller => 'testing', :action => 'index')
     #   set.recognize(Request.new('/test')).first.params => {:controller => 'testing', :action => 'index'}
-    def to(options = nil, &block)
-      raise "cannot set destination as block and argument" if block_given? && options
-      @destination = if block_given?
-        block
+    #
+    #   
+    #
+    def to(*args, &block)
+      if !args.empty? && block
+        @destination = CompoundDestination.new(args, block, args.last.is_a?(Hash) ? args.pop : {})
+      elsif block.nil?
+        case args.size
+        when 0 
+          raise "destination should be set as something"
+        when 1
+          @destination = args.first
+        else
+          @destination = CompoundDestination.new(args, nil, args.last.is_a?(Hash) ? args.pop : {})
+        end
       else
-        options.parent_route = self if options.respond_to?(:parent_route=)
-        options
+        @destination = block
       end
+      args.first.parent_route = self if args.first.respond_to?(:parent_route=)
       self
     end