http_router 0.1.0 → 0.1.1

data/Rakefile

@@ -10,7 +10,7 @@ begin
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError
-  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+  puts "Jeweler not available. Install it with: gem install jeweler"
 end
 
 require 'spec'

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.1.1

data/lib/ext/rack/rack_mapper.rb

@@ -0,0 +1,57 @@
+# Replacement for {Rack::Builder} which using HttpRouter to map requests instead of a simple Hash.
+# As well, add convenience methods for the request methods.
+class Rack::Builder
+  def initialize(&block)
+    @router = HttpRouter.new
+    super
+  end
+  
+  # Maps a path to a block.
+  # @param path [String] Path to map to.
+  # @param options [Hash] Options for added path.
+  # @see HttpRouter#add
+  def map(path, options = nil, &block)
+    @router.add(path).with_options(options).to(&block)
+    @ins << @router unless @ins.last == @router
+  end
+
+  # Maps a path with request methods `HEAD` and `GET` to a block.
+  # @param path [String] Path to map to.
+  # @param options [Hash] Options for added path.
+  # @see HttpRouter#add
+  def get(path, options = nil, &block)
+    @router.get(path).with_options(options).to(&block)
+  end
+
+  # Maps a path with request methods `POST` to a block.
+  # @param path [String] Path to map to.
+  # @param options [Hash] Options for added path.
+  # @see HttpRouter#add
+  def post(path, options = nil, &block)
+    @router.post(path).with_options(options).to(&block)
+  end
+
+  # Maps a path with request methods `PUT` to a block.
+  # @param path [String] Path to map to.
+  # @param options [Hash] Options for added path.
+  # @see HttpRouter#add
+  def put(path, options = nil, &block)
+    @router.put(path).with_options(options).to(&block)
+  end
+
+  # Maps a path with request methods `DELETE` to a block.
+  # @param path [String] Path to map to.
+  # @param options [Hash] Options for added path.
+  # @see HttpRouter#add
+  def delete(path, options = nil, &block)
+    @router.delete(path).with_options(options).to(&block)
+  end
+
+  # Maps a path with request methods `HEAD` to a block.
+  # @param path [String] Path to map to.
+  # @param options [Hash] Options for added path.
+  # @see HttpRouter#add
+  def head(path, options = nil, &block)
+    @router.head(path).with_options(options).to(&block)
+  end
+end

data/lib/ext/rack/uri_escape.rb

@@ -0,0 +1,26 @@
+module Rack::Utils
+  def uri_escape(s)
+    s.to_s.gsub(/([^:\/?\[\]\-_~\.!\$&'\(\)\*\+,;=@a-zA-Z0-9]+)/n) {
+      '%'<<$1.unpack('H2'*$1.size).join('%').upcase
+    }
+  end
+  module_function :uri_escape
+end unless Rack::Utils.respond_to?(:uri_escape)
+
+module Rack::Utils
+  def uri_escape!(s)
+    s.to_s.gsub!(/([^:\/?\[\]\-_~\.!\$&'\(\)\*\+,;=@a-zA-Z0-9]+)/n) {
+      '%'<<$1.unpack('H2'*$1.size).join('%').upcase
+    }
+  end
+  module_function :uri_escape!
+end unless Rack::Utils.respond_to?(:uri_escape!)
+
+module Rack::Utils
+  def uri_unescape(s)
+    gsub(/((?:%[0-9a-fA-F]{2})+)/n){
+      [$1.delete('%')].pack('H*')
+    }
+  end
+  module_function :uri_unescape
+end unless Rack::Utils.respond_to?(:uri_unescape)

data/lib/http_router/glob.rb

@@ -1,11 +1,12 @@
 class HttpRouter
   class Glob < Variable
-    def matches(parts, whole_path)
+    def matches(env, parts, whole_path)
       if @matches_with && match = @matches_with.match(parts.first)
         params = [parts.shift]
         while !parts.empty? and match = @matches_with.match(parts.first)
           params << parts.shift
         end
+        return unless additional_matchers(env, params)
         whole_path.replace(parts.join('/'))
         params
       else

data/lib/http_router/{sinatra.rb → interface/sinatra.rb}

@@ -1,4 +1,4 @@
-$LOAD_PATH << File.join(File.dirname(__FILE__), '..')
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', '..')
 require 'http_router'
 
 class HttpRouter
@@ -26,17 +26,17 @@ class HttpRouter
         private
           def route!(base=self.class, pass_block=nil)
             if base.router and match = base.router.recognize(@request)
-              if match.is_a?(RoutingError)
-                route_eval { 
-                  match.headers.each{|k,v| response[k] = v}
-                  status match.status
-                }
-              else
+              if match.matched?
                 @block_params = match.params
                 (@params ||= {}).merge!(match.params_as_hash)
                 pass_block = catch(:pass) do
                   route_eval(&match.route.dest)
                 end
+              else
+                route_eval { 
+                  match.headers.each{|k,v| response[k] = v}
+                  status match.status
+                }
               end
             end
 

data/lib/http_router/node.rb

@@ -3,37 +3,41 @@ class HttpRouter
     attr_accessor :value, :variable, :catchall
     attr_reader :linear, :lookup, :request_node, :extension_node
 
-    def initialize
+    def initialize(base)
+      @router = base
       reset!
     end
 
     def reset!
-      @linear = []
-      @lookup = {}
+      @linear = nil
+      @lookup = nil
       @catchall = nil
     end
 
     def add(val)
       if val.is_a?(Variable)
         if val.matches_with
-          new_node = Node.new
+          new_node = router.node
+          create_linear
           @linear << [val, new_node]
           new_node
         else
-          @catchall ||= Node.new
+          @catchall ||= router.node
           @catchall.variable = val
           @catchall
         end
       elsif val.is_a?(Regexp)
-        @linear << [val, Node.new]
+        create_linear
+        @linear << [val, router.node]
         @linear.last.last
       else
-        @lookup[val] ||= Node.new
+        create_lookup
+        @lookup[val] ||= router.node
       end
     end
     
     def add_extension(ext)
-      @extension_node ||= Node.new
+      @extension_node ||= router.node
       @extension_node.add(ext)
     end
     
@@ -43,7 +47,7 @@ class HttpRouter
       elsif @request_node
         current_node = @request_node
         while current_node.request_method
-          current_node = (current_node.catchall ||= RequestNode.new)
+          current_node = (current_node.catchall ||= router.request_node)
         end
         [current_node]
       else
@@ -52,12 +56,14 @@ class HttpRouter
     end
     
     protected
+    
+    attr_reader :router
 
     def transplant_value
       if @value
         target_node = @request_node
         while target_node.request_method
-          target_node = (target_node.catchall ||= RequestNode.new)
+          target_node = (target_node.catchall ||= router.request_node)
         end
         target_node.value = @value
         @value = nil
@@ -65,89 +71,133 @@ class HttpRouter
     end
     
     def generate_request_method_tree(request_options)
-      raise if (request_options.keys & RequestNode::RequestMethods).size != request_options.size
-      
-      
-      current_nodes = [@request_node ||= RequestNode.new]
+      raise(UnsupportedRequestConditionError.new) if (request_options.keys & RequestNode::RequestMethods).size != request_options.size
+      current_nodes = [self]
       RequestNode::RequestMethods.each do |method|
-        current_nodes.each_with_index do |current_node, current_node_index|
-          if request_options[method]  #we care about the method
-            if current_node  # and we have to pay attention to what currently is there.
+        if request_options.key?(method) # so, the request method we care about it ..
+          if current_nodes == [self]
+            current_nodes = [@request_node ||= router.request_node]
+          end
+          
+          for current_node_index in (0...current_nodes.size)
+            current_node = current_nodes.at(current_node_index)
+            if request_options.key?(method)  #we care about the method
               unless current_node.request_method
                 current_node.request_method = method
               end
-            
               case RequestNode::RequestMethods.index(method) <=> RequestNode::RequestMethods.index(current_node.request_method)
               when 0 #use this node
                 if request_options[method].is_a?(Regexp)
-                  current_node = RequestNode.new
-                  current_node.linear << [request_options[method], current_node]
+                  new_node = router.request_node
+                  current_nodes[current_node_index] = new_node
+                  current_node.create_linear
+                  current_node.linear << [request_options[method], new_node]
                 elsif request_options[method].is_a?(Array)
-                  current_nodes[current_node_index] = request_options[method].map{|val| current_node.lookup[val] ||= RequestNode.new}
+                  current_node.create_lookup
+                  current_nodes[current_node_index] = request_options[method].map{|val| current_node.lookup[val] ||= router.request_node}
                 else
-                  current_nodes[current_node_index] = (current_node.lookup[request_options[method]] ||= RequestNode.new)
+                  current_node.create_lookup
+                  current_nodes[current_node_index] = (current_node.lookup[request_options[method]] ||= router.request_node)
                 end
               when 1 #this node is farther ahead
-                current_nodes[current_node_index] = (current_node.catchall ||= RequestNode.new)
-                redo
+                current_nodes[current_node_index] = (current_node.catchall ||= router.request_node)
               when -1 #this method is more important than the current node
-                new_node = RequestNode.new
-                new_node.request_method = method
-                new_node.catchall = current_node
-                current_nodes[current_node_index] = new_node
+                next_node = current_node.dup
+                current_node.reset!
+                current_node.request_method = method
                 redo
               end
             else
-              current_nodes[current_node_index] = RequestNode.new
-              redo
+              current_node.catchall ||= router.request_node
             end
-          elsif !current_node
-            @request_node = RequestNode.new
-            current_nodes[current_node_index] = @request_node
-            redo
-          else
-            current_node.catchall ||= RequestNode.new
           end
+          current_nodes.flatten!
+        elsif current_nodes.first.is_a?(RequestNode) && !current_nodes.first.request_method.nil?
+          current_nodes.map!{|n| n.catchall ||= router.request_node}
         end
-        current_nodes.flatten!
       end
       transplant_value
       current_nodes
     end
 
-    def find_on_request_methods(request)
-      current_node = self
-      if current_node && current_node.request_node
-        current_node = current_node.request_node
-        while current_node
-          previous_node = current_node
-          break if current_node.nil? || current_node.is_a?(RoutingError) || current_node.value
-          request_value = request.send(current_node.request_method)
-          unless current_node.linear.empty?
-            next_node = current_node.linear.find do |(regexp, node)|
-              regexp === request_value
-            end
-            if next_node
-              current_node = next_node.last
-              next
+    def find_on_parts(request, parts, extension, params)
+      if parts.empty? && extension_node && extension
+        parts << extension
+        extension_node.find_on_parts(request, parts, extension, params)
+      else
+        if @linear && !@linear.empty?
+          whole_path = parts.join('/')
+          next_node = @linear.find do |(tester, node)|
+            if tester.is_a?(Regexp) and match = whole_path.match(tester) #and match.index == 0 TODO
+              whole_path.slice!(0,match[0].size)
+              parts.replace(router.split(whole_path))
+              node
+            elsif new_params = tester.matches(request.env, parts, whole_path)
+              params << new_params
+              node
+            else
+              nil
             end
           end
-          current_node = current_node.lookup[request_value] || current_node.catchall
-          if current_node.nil?
-            current_node = previous_node.request_method == :request_method ? RoutingError.new(405, {"Allow" => previous_node.lookup.keys.join(", ")}) : nil
-          else
-            current_node
-          end
+          return next_node.last.find_on_parts(request, parts, extension, params) if next_node
+        end
+        if match = @lookup && @lookup[parts.first]
+          parts.shift
+          match.find_on_parts(request, parts, extension, params)
+        elsif @catchall
+          params << @catchall.variable.matches(request.env, parts, whole_path)
+          parts.shift
+          @catchall.find_on_parts(request, parts, extension, params)
+        elsif parts.size == 1 && parts.first == '' && (value && value.route.trailing_slash_ignore?)
+          parts.shift
+          find_on_parts(request, parts, extension, params)
+        elsif request_node
+          request_node.find_on_request_methods(request)
+        elsif @value
+          self
+        else
+          nil
         end
       end
-      current_node
     end
 
+    def create_linear
+      @linear ||= []
+    end
+
+    def create_lookup
+      @lookup ||= {}
+    end
   end
   
   class RequestNode < Node
     RequestMethods =  [:request_method, :host, :port, :scheme]
     attr_accessor :request_method
+
+    def find_on_request_methods(request)
+      if @request_method
+        request_value = request.send(request_method)
+        if @linear && !@linear.empty?
+          next_node = @linear.find do |(regexp, node)|
+            regexp === request_value
+          end
+          next_node &&= next_node.find_on_request_methods(request)
+          return next_node if next_node
+        end
+        if @lookup and next_node = (@lookup[request_value] && @lookup[request_value].find_on_request_methods(request))
+          return next_node
+        elsif next_node = (@catchall && @catchall.find_on_request_methods(request))
+          return next_node
+        end
+      end
+      
+      if @value
+        self
+      else
+        current_node = request_method == :request_method ? Response.unmatched(405, {"Allow" => @lookup.keys.join(", ")}) : nil
+      end
+    end
+
   end
   
 end

data/lib/http_router/path.rb

@@ -5,14 +5,35 @@ class HttpRouter
     attr_accessor :route
     def initialize(path, parts, extension)
       @path, @parts, @extension = path, parts, extension
-      @eval_path = path.gsub(/[:\*]([a-zA-Z0-9_]+)/) {"\#{args.shift || (options && options.delete(:#{$1})) || raise(MissingParameterException.new(\"missing parameter #{$1}\"))}" }
+      if duplicate_variable_names = variable_names.dup.uniq!
+        raise AmbiguousVariableException.new("You have duplicate variable name present: #{duplicate_variable_names.join(', ')}")
+      end
+
+      eval_path = path.gsub(/[:\*]([a-zA-Z0-9_]+)/) {"\#{args.shift || (options && options.delete(:#{$1})) || raise(MissingParameterException.new(\"missing parameter #{$1}\"))}" }
       instance_eval "
       def raw_url(args,options)
-        \"#{@eval_path}\"
+        \"#{eval_path}\"
       end
       "
     end
 
+    def ===(other_path)
+      return false if @parts.size != other_path.parts.size
+      @parts.each_with_index {|p,i| 
+        return unless compare_parts(p, other_path.parts[i])
+      }
+      compare_parts(@extension, other_path.extension)
+    end
+
+    def compare_parts(p1, p2)
+      case p1
+      when Glob then p2.is_a?(Glob)
+      when Variable then p2.is_a?(Variable)
+      else
+        p1 == p2
+      end
+    end
+
     def url(args, options)
       path = raw_url(args, options)
       raise TooManyParametersException.new unless args.empty?

data/lib/http_router/response.rb

@@ -1,25 +1,46 @@
 class HttpRouter
-  class Response < Struct.new(:path, :params, :extension, :matched_path, :remaining_path)
-    attr_reader :params_as_hash, :route
+  module Response
+    def self.matched(*args)
+      Matched.new(*args)
+    end
 
-    def initialize(path, params, extension, matched_path, remaining_path)
-      raise if matched_path.nil?
-      super
-      @params_as_hash = path.variable_names.zip(params).inject({}) {|h, (k,v)| h[k] = v; h }
-      @params_as_hash[path.extension.name] = extension if path.extension && path.extension.is_a?(Variable)
+    def self.unmatched(*args)
+      Unmatched.new(*args)
     end
 
-    def route
-      path.route
+    private
+    class Unmatched < Struct.new(:status, :headers)
+      def matched?
+        false
+      end
     end
+
+    class Matched < Struct.new(:path, :params, :extension, :matched_path, :remaining_path)
+      attr_reader :params_as_hash, :route
+
+      def initialize(path, params, extension, matched_path, remaining_path)
+        raise if matched_path.nil?
+        super
+        @params_as_hash = path.variable_names.zip(params).inject({}) {|h, (k,v)| h[k] = v; h }
+        @params_as_hash[path.extension.name] = extension if path.extension && path.extension.is_a?(Variable)
+      end
+
+      def matched?
+        true
+      end
+
+      def route
+        path.route
+      end
     
-    def dest
-      route.dest
-    end
-    alias_method :destination, :dest
+      def dest
+        route.dest
+      end
+      alias_method :destination, :dest
     
-    def partial_match?
-      remaining_path
+      def partial_match?
+        remaining_path
+      end
     end
   end
 end

data/lib/http_router/root.rb

@@ -1,10 +1,5 @@
 class HttpRouter
   class Root < Node
-    def initialize(base)
-      @base = base
-      reset!
-    end
-
     def add_path(path)
       node = path.parts.inject(self) { |node, part| node.add(part) }
       if path.extension
@@ -15,69 +10,23 @@ class HttpRouter
 
     def find(request)
       path = request.path_info.dup
-      path.slice!(-1) if @base.ignore_trailing_slash? && path[-1] == ?/
+      path.slice!(-1) if router.ignore_trailing_slash? && path[-1] == ?/
       extension = extract_extension(path)
-      parts = @base.split(path)
+      parts = router.split(path)
       parts << '' if path[path.size - 1] == ?/
-
       params = []
-      if current_node = process_parts(parts, extension, params)
-        current_node = current_node.find_on_request_methods(request)
-      end
-      
-      process_response(current_node, parts, extension, params, request)
+      process_response(
+        find_on_parts(request, parts, extension, params),
+        parts,
+        extension,
+        params, 
+        request
+      )
     end
     
     private
-    
-    def process_parts(parts, extension, params)
-      current_node = self
-      loop do
-        if parts.empty? && current_node.extension_node && extension
-          parts << extension
-          current_node = current_node.extension_node
-        end
-        break if current_node.nil? || (current_node.value && current_node.value.route.partially_match?) || parts.empty?
-        unless current_node.linear.empty?
-          whole_path = parts.join('/')
-          next_node = current_node.linear.find do |(tester, node)|
-            if tester.is_a?(Regexp) and match = whole_path.match(tester)
-              whole_path.slice!(0,match[0].size)
-              parts.replace(@base.split(whole_path))
-              node
-            elsif new_params = tester.matches(parts, whole_path)
-              params << new_params
-              node
-            else
-              nil
-            end
-          end
-          if next_node
-            current_node = next_node.last
-            next
-          end
-        end
-        if match = current_node.lookup[parts.first]
-          parts.shift
-          current_node = match
-        elsif current_node.catchall
-          params << current_node.catchall.variable.matches(parts, whole_path)
-          parts.shift
-          current_node = current_node.catchall
-        elsif parts.size == 1 && parts.first == '' && current_node && (current_node.value && current_node.value.route.trailing_slash_ignore?)
-          parts.shift
-        elsif current_node.request_node
-          break
-        else
-          current_node = nil
-          break
-        end
-      end
-      current_node
-    end
-
     def process_response(node, parts, extension, params, request)
-      if node.is_a?(RoutingError)
+      if node.respond_to?(:matched?) && !node.matched?
         node
       elsif node && node.value
         if parts.empty?
@@ -103,10 +52,10 @@ class HttpRouter
 
     def post_match(path, params, extension, matched_path, remaining_path = nil)
       if path.route.partially_match? || path.matches_extension?(extension)
-        Response.new(path, params, extension, matched_path, remaining_path)
+        Response.matched(path, params, extension, matched_path, remaining_path)
       else
         nil
       end
     end
   end
-end
+end