usher 0.7.1 → 0.7.2

data/lib/usher/interface/sinatra.rb

@@ -1,66 +1,125 @@
 class Usher
   module Interface
     class Sinatra
-      
+
+      def initialize
+        ::Sinatra.send(:include, Extension)
+      end
+
       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, @request.path_info)
-                @block_params = match.params.map{|p| p.last}
-                @params = @params ? @params.merge(match.params_as_hash) : match.params_as_hash
+        def self.registered(app)
+          app.send(:include, Extension)
+        end
+
+        def self.included(base)
+          base.extend ClassMethods
+        end
+
+        def generate(name, *params)
+          self.class.generate(name, *params)
+        end
+
+        private
+          def route!(base=self.class, pass_block=nil)
+            if base.router and match = base.router.recognize(@request, @request.path_info)
+              @block_params = match.params.map { |p| p.last }
+              (@params ||= {}).merge!(match.params_as_hash)
+              pass_block = catch(:pass) do
                 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)
+
+            # Run routes defined in superclass.
+            if base.superclass.respond_to?(:router)
+              route! base.superclass, pass_block
+              return
             end
 
-          HERE_DOC
-        end
-        
-      end
-      
-      def initialize
-        ::Sinatra.send(:include, Extension)
-      end
-    end
-  end
-end
+            route_eval(&pass_block) if pass_block
+
+            route_missing
+          end
+
+        module ClassMethods
+
+          def new(*args, &bk)
+            configure! unless @_configured
+            super(*args, &bk)
+          end
+
+          def route(verb, path, options={}, &block)
+            path.gsub!(/\/\?$/, "(/)")
+            name = options.delete(:name)
+            options[:conditions] ||= {}
+            options[:conditions][:request_method] = verb
+            options[:conditions][:host] = 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 router
+            @router ||= Usher.new(:request_methods => [:request_method, :host, :port, :scheme],
+                                  :ignore_trailing_delimiters => true,
+                                  :generator => Usher::Util::Generators::URL.new,
+                                  :delimiters => ['/', '.', '-'],
+                                  :valid_regex => '[0-9A-Za-z\$_\+!\*\',]+')
+            block_given? ? yield(@router) : @router
+          end
+
+          def generate(name, *params)
+            router.generator.generate(name, *params)
+          end
+
+          def reset!
+            router.reset!
+            super
+          end
+
+          def configure!
+            configure :development do
+              error 404 do
+                content_type 'text/html'
+
+                (<<-HTML).gsub(/^ {17}/, '')
+                <!DOCTYPE html>
+                <html>
+                <head>
+                  <style type="text/css">
+                  body { text-align:center;font-family:helvetica,arial;font-size:22px;
+                    color:#888;margin:20px}
+                  #c {margin:0 auto;width:500px;text-align:left}
+                  </style>
+                </head>
+                <body>
+                  <h2>Sinatra doesn't know this ditty.</h2>
+                  <div id="c">
+                    Try this:
+                    <pre>#{request.request_method.downcase} '#{request.path_info}' do\n  "Hello World"\nend</pre>
+                  </div>
+                </body>
+                </html>
+                HTML
+              end
+            end
+
+            @_configured = true
+          end
+        end # ClassMethods
+      end # Extension
+    end # Sinatra
+  end # Interface
+end # Usher

data/lib/usher/interface.rb

@@ -1,30 +1,20 @@
 class Usher
+  # Various interfaces for Usher.
   module Interface
 
-    InterfaceRegistry = {}
-
-    def self.register(name, cls)
-      InterfaceRegistry[name] = cls
-    end
-
-    register(:email,    File.join(File.dirname(__FILE__), 'interface', 'email'))
-    register(:merb,     File.join(File.dirname(__FILE__), 'interface', 'merb'))
-    register(:rails20,  File.join(File.dirname(__FILE__), 'interface', 'rails20'))
-    register(:rails22,  File.join(File.dirname(__FILE__), 'interface', 'rails22'))
-    register(:rails23,  File.join(File.dirname(__FILE__), 'interface', 'rails23'))
-    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'))
+    autoload(:Email,    File.join(File.dirname(__FILE__), 'interface', 'email'))
+    autoload(:Merb,     File.join(File.dirname(__FILE__), 'interface', 'merb'))
+    autoload(:Rails20,  File.join(File.dirname(__FILE__), 'interface', 'rails20'))
+    autoload(:Rails22,  File.join(File.dirname(__FILE__), 'interface', 'rails22'))
+    autoload(:Rails23,  File.join(File.dirname(__FILE__), 'interface', 'rails23'))
+    autoload(:Rack,     File.join(File.dirname(__FILE__), 'interface', 'rack'))
+    autoload(:Rails3,   File.join(File.dirname(__FILE__), 'interface', 'rails3'))
+    autoload(:Text,     File.join(File.dirname(__FILE__), 'interface', 'text'))
+    autoload(:Sinatra,  File.join(File.dirname(__FILE__), 'interface', 'sinatra'))
 
     def self.class_for(name)
-      name = name.to_sym
-      if InterfaceRegistry[name]
-        require InterfaceRegistry[name]
-        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
+      Usher::Interface.const_get(name.to_s.split(/_/).map{|e| e.capitalize}.join) or
+        raise ArgumentError, "Interface #{name.inspect} doesn't exist."
     end
 
     # Usher::Interface.for(:rack, &block)

data/lib/usher/node/response.rb

@@ -1,7 +1,9 @@
 class Usher
   class Node
-    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)
 
+      attr_accessor :only_trailing_delimiters
+      
       def params
         @params ||= path.convert_params_array(params_as_array)
       end

data/lib/usher/node.rb

@@ -9,44 +9,12 @@ class Usher
 
     def initialize(parent, value)
       @parent, @value = parent, value
-      @request = nil
-      @normal = nil
-      @greedy = nil
-      @request_method_type = nil
-    end
-
-    def activate_normal!
-      @normal ||= Hash.new
-    end
-
-    def activate_greedy!
-      @greedy ||= Hash.new
-    end
-
-    def activate_request!
-      @request ||= Hash.new
-    end
-
-    def upgrade_normal!
-      @normal = FuzzyHash.new(@normal)
-    end
-
-    def upgrade_greedy!
-      @greedy = FuzzyHash.new(@greedy)
-    end
-
-    def upgrade_request!
-      @request = FuzzyHash.new(@request)
     end
 
     def depth
       @depth ||= parent.is_a?(Node) ? parent.depth + 1 : 0
     end
 
-    def greedy?
-      @greedy
-    end
-
     def terminates?
       @terminates && @terminates.route.recognizable?
     end
@@ -66,68 +34,57 @@ class Usher
     def root
       @root ||= ancestors.last
     end
-    
+
     def route_set
       @route_set ||= root.route_set
     end
 
-    def pp
-      $stdout << " " * depth
-      $stdout << "#{terminates? ? '* ' : ''}#{depth}: #{value.inspect}\n"
-      normal.each do |k,v|
-        $stdout << " " * (depth + 1)
-        $stdout << ". #{k.inspect} ==> \n"
-        v.pp
-      end if normal
-      greedy.each do |k,v|
-        $stdout << " " * (depth + 1)
-        $stdout << "g #{k.inspect} ==> \n"
-        v.pp
-      end if greedy
-      request.each do |k,v|
-        $stdout << " " * (depth + 1)
-        $stdout << "r #{k.inspect} ==> \n"
-        v.pp
-      end if request
+    def inspect
+      out = ''
+      out << " " * depth
+      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
+        end if send(node_type)
+      end
+      out
     end
 
     def find(request_object, original_path, path, params = [])
       # terminates or is partial
-      if terminates? && (path.nil? || path.empty? || terminates.route.partial_match? || (route_set.ignore_trailing_delimiters? and only_trailing_delimiters = path.all?{|p| route_set.delimiters.include?(p)}))
-        terminates.route.partial_match? ?
-          Response.new(terminates, params, path.join, original_path[0, original_path.size - path.join.size], only_trailing_delimiters) :
-          Response.new(terminates, params, nil, original_path, only_trailing_delimiters)
+
+      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)
       # terminates or is partial
-      elsif greedy && !path.empty? and match_with_result_output = greedy.match_with_result(whole_path = path.join)
-        next_path, matched_part = match_with_result_output
+      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 next_path.value.is_a?(Route::Variable)
-        next_path.find(request_object, original_path, whole_path.empty? ? whole_path : route_set.splitter.split(whole_path), params)
-      elsif normal && !path.empty? and next_part = normal[path.first] || normal[nil]
+        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)
+      elsif !path.empty? and normal and child_node = normal[path.first] || normal[nil]
         part = path.shift
-        case next_part.value
+        case child_node.value
         when String
         when Route::Variable::Single
-          variable = next_part.value                                  # get the variable
-          variable.valid!(part)                                       # do a validity check
-          if variable.look_ahead
-            until (variable.look_ahead === path.first) || path.empty? # variables have a look ahead notion,
-              next_path_part = path.shift                             # and until they are satified,
-              part << next_path_part
-            end
-          end
+          variable = child_node.value                                # get the variable
+          variable.valid!(part)                                     # do a validity check
+          until path.empty? || (variable.look_ahead === path.first) # variables have a look ahead notion,
+            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
         when Route::Variable::Glob
           params << []
           loop do
-            if (next_part.value.look_ahead === part || (!route_set.delimiters.unescaped.include?(part) && next_part.value.regex_matcher && !next_part.value.regex_matcher.match(part)))
+            if (child_node.value.look_ahead === part || (!route_set.delimiters.unescaped.include?(part) && child_node.value.regex_matcher && !child_node.value.regex_matcher.match(part)))
               path.unshift(part)
-              if route_set.delimiters.unescaped.include?(next_part.parent.value)
-                path.unshift(next_part.parent.value)
-              end
+              path.unshift(child_node.parent.value) if route_set.delimiters.unescaped.include?(child_node.parent.value)
               break
             elsif !route_set.delimiters.unescaped.include?(part)
-              next_part.value.valid!(part)
+              child_node.value.valid!(part)
               params.last << part
             end
             unless part = path.shift
@@ -135,7 +92,7 @@ class Usher
             end
           end
         end
-        next_part.find(request_object, original_path, path, params)
+        child_node.find(request_object, original_path, path, params)
       elsif request_method_type
         if route_set.priority_lookups?
           route_candidates = []
@@ -159,5 +116,29 @@ class Usher
       end
     end
 
+    def activate_normal!
+      @normal ||= {}
+    end
+
+    def activate_greedy!
+      @greedy ||= {}
+    end
+
+    def activate_request!
+      @request ||= {}
+    end
+
+    def upgrade_normal!
+      @normal = FuzzyHash.new(@normal)
+    end
+
+    def upgrade_greedy!
+      @greedy = FuzzyHash.new(@greedy)
+    end
+
+    def upgrade_request!
+      @request = FuzzyHash.new(@request)
+    end
+
   end
 end

data/lib/usher/route/static.rb

@@ -3,6 +3,8 @@ class Usher
     class Static
       class Greedy < Regexp
         
+        attr_accessor :generate_with
+        
       end
     end
   end

data/lib/usher/route/variable.rb

@@ -14,7 +14,7 @@ class Usher
 
       module CaseEqualsValidator
         def valid!(val)
-          @validator === val or raise(ValidationException.new("#{val} does not conform to #{@validator}"))
+          @validator === val.to_s or raise(ValidationException.new("#{val} does not conform to #{@validator}"))
         end
       end
       

data/lib/usher/route.rb

@@ -50,12 +50,12 @@ class Usher
     end
 
     def unrecognizable!
-      self.recognizable = false
+      @recognizable = false
       self
     end
 
     def recognizable!
-      self.recognizable = true
+      @recognizable = true
       self
     end
 
@@ -93,17 +93,18 @@ class Usher
 
     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'}
+    # Sets destination on a route.
+    # @return [self]
+    # @param [Object] args 
+    #   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 {CompoundDestination#options}
+    #   Otherwise, if you use send a single variable, or call it with a block, these will be returned to you by {CompoundDestination#destination}
+    # @example
+    #     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'}
     #
     #
     #
@@ -126,11 +127,13 @@ class Usher
       self
     end
 
-    # Sets route as referenceable from +name+. Returns +self+.
-    #
-    #   set = Usher.new
-    #   route = set.add_route('/test').name(:route)
-    #   set.generate_url(:route) => '/test'
+    # Sets route as referenceable from `name`
+    # @param [Symbol] name The name of the route
+    # @return [self] The route named
+    # @example
+    #     set = Usher.new
+    #     route = set.add_route('/test').name(:route)
+    #     set.generate_url(:route) => '/test'
     def name(name)
       @named = name
       @router.name(name, self)

data/lib/usher/splitter.rb

@@ -3,21 +3,19 @@ class Usher
 
     def self.for_delimiters(delimiters_array)
       delimiters = Delimiters.new(delimiters_array)
-      delimiters_array.any?{|d| d.size > 1} ?
+      delimiters.any?{|d| d.size > 1} ?
         MultiCharacterSplitterInstance.new(delimiters) :
         SingleCharacterSplitterInstance.new(delimiters)
     end
 
     class SingleCharacterSplitterInstance
     
-      attr_reader :url_split_regex
-    
       def initialize(delimiters)
-        @url_split_regex = Regexp.new("[^#{delimiters.collect{|d| Regexp.quote(d)}.join}]+|[#{delimiters.collect{|d| Regexp.quote(d)}.join}]")
+        @url_split_regex = Regexp.new("[^#{delimiters.regexp_char_class}]+|[#{delimiters.regexp_char_class}]")
       end
       
       def split(path)
-        path.scan(url_split_regex)
+        path.scan(@url_split_regex)
       end
     end
     
@@ -36,7 +34,7 @@ class Usher
       protected
 
       def delimiters_regexp
-        Regexp.new("(#{@delimiters.unescaped.collect{|d| Regexp.quote(d)}.join('|')})")
+        @delimiters.regexp
       end
       
     end    

data/lib/usher/util/generate.rb

@@ -12,45 +12,61 @@ class Usher
 
         def generate_path_for_base_params(path, params)
           raise UnrecognizedException.new unless path
-          result = ''
-
           case params
           when nil, Hash
-            path.parts.each do |part|
-              case part
-              when String
-                result << part
-              when Route::Variable::Glob
-                value = (params && params.delete(part.name)) || part.default_value || raise(MissingParameterException.new("expected a value for #{part.name}"))
-                value.each_with_index do |current_value, index|
-                  part.valid!(current_value)
-                  result << current_value.to_s
-                  result << usher.delimiters.first if index != value.size - 1
-                end
-              when Route::Variable
-                value = (params && params.delete(part.name)) || part.default_value || raise(MissingParameterException.new("expected a value for #{part.name}"))
-                part.valid!(value)
-                result << value.to_s
+            generate_path_for_base_params_with_hash(path, params)
+          else
+            generate_path_for_base_params_with_array(path, Array(params))
+          end
+        end
+
+        def generate_path_for_base_params_with_hash(path, params)
+          result = ''
+          path.parts.each do |part|
+            case part
+            when String
+              result << part
+            when Route::Variable::Glob
+              value = (params && params.delete(part.name)) || part.default_value || raise(MissingParameterException.new("expected a value for #{part.name}"))
+              value.each_with_index do |current_value, index|
+                part.valid!(current_value)
+                result << current_value.to_s
+                result << usher.delimiters.first if index != value.size - 1
               end
+            when Route::Variable
+              value = (params && params.delete(part.name)) || part.default_value || raise(MissingParameterException.new("expected a value for #{part.name}"))
+              part.valid!(value)
+              result << value.to_s
+            when Route::Static::Greedy
+              result << part.generate_with
+            else
+              raise
             end
-          else
-            params = Array(params)
-            path.parts.each do |part|
-              case part
-              when String
-                result << part
-              when Route::Variable::Glob
-                value = (params && params.shift) || part.default_value || raise(MissingParameterException.new)
-                value.each_with_index do |current_value, index|
-                  part.valid!(current_value)
-                  result << current_value.to_s
-                  result << usher.delimiters.first if index != value.size - 1
-                end
-              when Route::Variable
-                value = (params && params.shift) || part.default_value || raise(MissingParameterException.new)
-                part.valid!(value)
-                result << value.to_s
+          end
+          result
+        end
+        
+        def generate_path_for_base_params_with_array(path, params)
+          result = ''
+          path.parts.each do |part|
+            case part
+            when String
+              result << part
+            when Route::Variable::Glob
+              value = (params && params.shift) || part.default_value || raise(MissingParameterException.new)
+              value.each_with_index do |current_value, index|
+                part.valid!(current_value)
+                result << current_value.to_s
+                result << usher.delimiters.first if index != value.size - 1
               end
+            when Route::Variable
+              value = (params && params.shift) || part.default_value || raise(MissingParameterException.new)
+              part.valid!(value)
+              result << value.to_s
+            when Route::Static::Greedy
+              result << value.generate_with
+            else
+              raise
             end
           end
           result