http_router 0.10.2 → 0.11.0

data/lib/http_router/generation_helper.rb

@@ -0,0 +1,29 @@
+class HttpRouter
+  module GenerationHelper
+    def max_param_count
+      @generator.max_param_count
+    end
+
+    def url(*args)
+      @generator.url(*args)
+    rescue InvalidRouteException
+      nil
+    end
+
+    def url_ns(*args)
+      @generator.url_ns(*args)
+    rescue InvalidRouteException
+      nil
+    end
+
+    def path(*args)
+      @generator.path(*args)
+    rescue InvalidRouteException
+      nil
+    end
+
+    def param_names
+      @generator.param_names
+    end
+  end
+end

data/lib/http_router/generator.rb

@@ -0,0 +1,150 @@
+class HttpRouter
+  class Generator
+    SCHEME_PORTS = {'http' => 80, 'https' => 443}
+
+    class PathGenerator
+      attr_reader :path
+      attr_accessor :param_names
+      def initialize(route, path, validation_regex = nil)
+        @route = route
+        @path = path.dup
+        @param_names = []
+        if path.is_a?(String)
+          path[0, 0] = '/' unless path[0] == ?/
+          regex_parts = path.split(/([:\*][a-zA-Z0-9_]+)/)
+          regex, code = '', ''
+          dynamic = false
+          regex_parts.each_with_index do |part, index|
+            case part[0]
+            when ?:, ?*
+              if index != 0 && regex_parts[index - 1][-1] == ?\\
+                regex << Regexp.quote(part) unless validation_regex
+                code << part
+                dynamic = true
+              else
+                regex << (@route.matches_with(part[1, part.size].to_sym) || '.*?').to_s unless validation_regex
+                code << "\#{args.shift || (options && options.delete(:#{part[1, part.size]})) || return}"
+                dynamic = true
+              end
+            else
+              regex << Regexp.quote(part) unless validation_regex
+              code << part
+            end
+          end
+          validation_regex ||= Regexp.new("^#{regex}$") if dynamic
+          if validation_regex
+            instance_eval <<-EOT, __FILE__, __LINE__ + 1
+            def generate(args, options)
+              generated_path = \"#{code}\"
+              #{validation_regex.inspect}.match(generated_path) ? URI.escape(generated_path) : nil
+            end
+            EOT
+          else
+            instance_eval <<-EOT, __FILE__, __LINE__ + 1
+            def generate(args, options)
+              URI.escape(\"#{code}\")
+            end
+            EOT
+          end
+        end
+      end
+    end
+
+    def initialize(route, paths)
+      @route, @paths = route, paths
+      @router = @route.router
+      @route.generator = self
+      @path_generators = @paths.map do |p|
+        generator = PathGenerator.new(route, p.is_a?(String) ? p : route.path_for_generation, p.is_a?(Regexp) ? p : nil)
+      end
+    end
+
+    def param_names
+      @param_names ||= @path_generators.map{|path| path.param_names}.flatten.uniq
+    end
+
+    def max_param_count
+      @max_param_count ||= @path_generators.map{|p| p.param_names.size}.max
+    end
+
+    def each_path
+      @path_generators.each {|p| yield p }
+      @path_generators.sort! do |p1, p2|
+        p2.param_names.size <=> p1.param_names.size
+      end
+    end
+
+    def url(*args)
+      "#{scheme_port.first}#{url_ns(*args)}"
+    end
+
+    def url_ns(*args)
+      "://#{@route.host || @router.default_host}#{scheme_port.last}#{path(*args)}"
+    end
+
+    def path(*args)
+      result, extra_params = path_with_params(*args)
+      append_querystring(result, extra_params)
+    end
+
+    private
+    def scheme_port
+      @scheme_port ||= begin
+        scheme = @route.scheme || @router.default_scheme
+        port = @router.default_port
+        port_part = SCHEME_PORTS.key?(scheme) && SCHEME_PORTS[scheme] == port ? '' : ":#{port}"
+        [scheme, port_part]
+      end
+    end
+
+    def path_with_params(*a)
+      path_args_processing(a) do |args, options|
+        path = args.empty? ? matching_path(options) : matching_path(args, options)
+        path &&= path.generate(args, options)
+        raise TooManyParametersException unless args.empty?
+        raise InvalidRouteException.new("Error generating #{@route.path_for_generation}") unless path
+        path ? [path, options] : nil
+      end
+    end
+
+    def path_args_processing(args)
+      options = args.last.is_a?(Hash) ? args.pop : nil
+      options = options.nil? ? @route.default_values.dup : @route.default_values.merge(options) if @route.default_values
+      options.delete_if{ |k,v| v.nil? } if options
+      result, params = yield args, options
+      mount_point = @router.url_mount && (options ? @router.url_mount.url(options) : @router.url_mount.url)
+      mount_point ? [File.join(mount_point, result), params] : [result, params]
+    end
+
+    def matching_path(params, other_hash = nil)
+      return @path_generators.first if @path_generators.size == 1
+      case params
+      when Array, nil
+        @path_generators.find do |path|
+          significant_key_count = params ? params.size : 0
+          significant_key_count += (path.param_names & other_hash.keys).size if other_hash
+          significant_key_count >= path.param_names.size
+        end
+      when Hash
+        @path_generators.find { |path| (params && !params.empty? && (path.param_names & params.keys).size == path.param_names.size) || path.param_names.empty? }
+      end
+    end
+
+    def append_querystring_value(uri, key, value)
+      case value
+      when Array then value.each{ |v|    append_querystring_value(uri, "#{key}[]",     v) }
+      when Hash  then value.each{ |k, v| append_querystring_value(uri, "#{key}[#{k}]", v) }
+      else            uri << "&#{CGI.escape(key.to_s)}=#{CGI.escape(value.to_s)}"
+      end
+    end
+
+    def append_querystring(uri, params)
+      if params && !params.empty?
+        uri_size = uri.size
+        params.each{ |k,v|  append_querystring_value(uri, k, v) }
+        uri[uri_size] = ??
+      end
+      uri
+    end
+  end
+end

data/lib/http_router/node.rb

@@ -1,17 +1,20 @@
 class HttpRouter
   class Node
-    autoload :Root,          'http_router/node/root'
-    autoload :Glob,          'http_router/node/glob'
-    autoload :GlobRegex,     'http_router/node/glob_regex'
-    autoload :Variable,      'http_router/node/variable'
-    autoload :Regex,         'http_router/node/regex'
-    autoload :SpanningRegex, 'http_router/node/spanning_regex'
-    autoload :GlobRegex,     'http_router/node/glob_regex'
-    autoload :FreeRegex,     'http_router/node/free_regex'
-    autoload :Arbitrary,     'http_router/node/arbitrary'
-    autoload :Request,       'http_router/node/request'
-    autoload :Lookup,        'http_router/node/lookup'
-    autoload :Path,          'http_router/node/path'
+    autoload :Root,                'http_router/node/root'
+    autoload :Glob,                'http_router/node/glob'
+    autoload :GlobRegex,           'http_router/node/glob_regex'
+    autoload :Variable,            'http_router/node/variable'
+    autoload :Regex,               'http_router/node/regex'
+    autoload :SpanningRegex,       'http_router/node/spanning_regex'
+    autoload :GlobRegex,           'http_router/node/glob_regex'
+    autoload :FreeRegex,           'http_router/node/free_regex'
+    autoload :AbstractRequestNode, 'http_router/node/abstract_request_node'
+    autoload :Host,                'http_router/node/host'
+    autoload :UserAgent,           'http_router/node/user_agent'
+    autoload :RequestMethod,       'http_router/node/request_method'
+    autoload :Scheme,              'http_router/node/scheme'
+    autoload :Lookup,              'http_router/node/lookup'
+    autoload :Path,                'http_router/node/path'
 
     attr_reader :router
 
@@ -31,13 +34,20 @@ class HttpRouter
       add(GlobRegex.new(@router, self, matcher))
     end
 
-    def add_request(opts)
-      raise unless opts
-      add(Request.new(@router, self, opts))
+    def add_host(hosts)
+      add(Host.new(@router, self, hosts))
     end
 
-    def add_arbitrary(blk, allow_partial, param_names)
-      add(Arbitrary.new(@router, self, allow_partial, blk, param_names))
+    def add_user_agent(uas)
+      add(UserAgent.new(@router, self, uas))
+    end
+
+    def add_request_method(rm)
+      add(RequestMethod.new(@router, self, rm))
+    end
+
+    def add_scheme(scheme)
+      add(Scheme.new(@router, self, scheme))
     end
 
     def add_match(regexp, matching_indicies = [0], splitting_indicies = nil)

data/lib/http_router/node/abstract_request_node.rb

@@ -0,0 +1,31 @@
+class HttpRouter
+  class Node
+    class AbstractRequestNode < Node
+      attr_reader :request_method, :tests
+
+      def initialize(route, parent, tests, request_method)
+        @request_method = request_method
+        @tests = case tests
+        when Array then tests
+        when Set   then tests.to_a
+        else            [tests]
+        end
+        super(route, parent)
+      end
+
+      def usable?(other)
+        other.class == self.class && other.tests == tests && other.request_method == request_method
+      end
+
+      def to_code
+        "if #{@tests.map { |test| "#{test.inspect} === request.rack_request.#{request_method}" } * ' or '}
+          #{super}
+        end"
+      end
+
+      def inspect_label
+        "#{self.class.name.split("::").last} #{tests.inspect} (#{@matchers.size} matchers)"
+      end
+     end
+  end
+end

data/lib/http_router/node/host.rb

@@ -0,0 +1,9 @@
+class HttpRouter
+  class Node
+    class Host < AbstractRequestNode
+      def initialize(router, parent, hosts)
+        super(router, parent, hosts, :host)
+      end
+    end
+  end
+end

data/lib/http_router/node/lookup.rb

@@ -25,16 +25,14 @@ class HttpRouter
       end
 
       def to_code
-        lookup_ivar = inject_root_ivar(@map)
-        method_prefix = "lookup_#{root.next_counter} "
-        inject_root_methods @map.keys.map {|k| 
-          method = :"#{method_prefix}#{k}"
-          "define_method(#{method.inspect}) do |request|
-            part = request.path.shift
-            #{@map[k].map{|n| n.to_code} * "\n"}
-            request.path.unshift part
-          end"}.join("\n")
-        "send(\"#{method_prefix}\#{request.path.first}\", request) if !request.path_finished? && #{lookup_ivar}.key?(request.path.first)"
+        part_name = "part#{root.next_counter}"
+        "unless request.path_finished?
+          #{part_name} = request.path.shift
+          case #{part_name}
+            #{@map.map{|k, v| "when #{k.inspect}; #{v.map(&:to_code) * "\n"};"} * "\n"}
+          end
+          request.path.unshift #{part_name}
+        end"
       end
     end
   end

data/lib/http_router/node/path.rb

@@ -1,52 +1,42 @@
 class HttpRouter
   class Node
     class Path < Node
-      attr_reader :route, :param_names, :dynamic, :original_path
+      attr_reader :route, :param_names, :dynamic, :path
       alias_method :dynamic?, :dynamic
       def initialize(router, parent, route, path, param_names = [])
-        @route, @original_path, @param_names, @dynamic = route, path, param_names, !param_names.empty?
+        @route, @path, @param_names, @dynamic = route, path, param_names, !param_names.empty?
+        @route.add_path(self)
         raise AmbiguousVariableException, "You have duplicate variable name present: #{param_names.join(', ')}" if param_names.uniq.size != param_names.size
-        Util.add_path_generation(self, route, @original_path) if @original_path.respond_to?(:split)
         super router, parent
-        root.uncompile
+        router.uncompile
       end
 
       def hashify_params(params)
         @dynamic && params ? Hash[param_names.zip(params)] : {}
       end
 
-      def url(args, options)
-        if path = raw_url(args, options)
-          raise TooManyParametersException unless args.empty?
-          [URI.escape(path), options]
-        end
-      end
-
       def to_code
         path_ivar = inject_root_ivar(self)
-        "#{"if request.path_finished?" unless route.match_partially?}
-          catch(:pass) do
-            #{"if request.path.size == 1 && request.path.first == '' && (request.rack_request.head? || request.rack_request.get?) && request.rack_request.path_info[-1] == ?/
-              response = ::Rack::Response.new
-              response.redirect(request.rack_request.path_info[0, request.rack_request.path_info.size - 1], 302)
-              throw :success, response.finish
-            end" if router.redirect_trailing_slash?}
+        "#{"if !callback && request.path.size == 1 && request.path.first == '' && (request.rack_request.head? || request.rack_request.get?) && request.rack_request.path_info[-1] == ?/
+          response = ::Rack::Response.new
+          response.redirect(request.rack_request.path_info[0, request.rack_request.path_info.size - 1], 302)
+          return response.finish
+        end" if router.redirect_trailing_slash?}
 
-            #{"if request.path.empty?#{" or (request.path.size == 1 and request.path.first == '')" if router.ignore_trailing_slash?}" unless route.match_partially?}
-              if request.perform_call
-                env = request.rack_request.dup.env
-                env['router.request'] = request
-                env['router.params'] ||= {}
-                #{"env['router.params'].merge!(Hash[#{param_names.inspect}.zip(request.params)])" if dynamic?}
-                @router.rewrite#{"_partial" if route.match_partially?}_path_info(env, request)
-                response = @router.process_destination_path(#{path_ivar}, env)
-                router.pass_on_response(response) ? throw(:pass) : throw(:success, response)
-              else
-                request.matched_route(Response.new(request, #{path_ivar}))
-              end
-            #{"end" unless route.match_partially?}
+        #{"if request.#{router.ignore_trailing_slash? ? 'path_finished?' : 'path.empty?'}" unless route.match_partially}
+          if callback
+            request.called = true
+            callback.call(Response.new(request, #{path_ivar}))
+          else
+            env = request.rack_request.dup.env
+            env['router.request'] = request
+            env['router.params'] ||= {}
+            #{"env['router.params'].merge!(Hash[#{param_names.inspect}.zip(request.params)])" if dynamic?}
+            @router.rewrite#{"_partial" if route.match_partially}_path_info(env, request)
+            response = @router.process_destination_path(#{path_ivar}, env)
+            return response unless router.pass_on_response(response)
           end
-        #{"end" unless route.match_partially?}"
+        #{"end" unless route.match_partially}"
       end
 
       def usable?(other)
@@ -54,12 +44,7 @@ class HttpRouter
       end
 
       def inspect_label
-        "Path: #{original_path.inspect} for route #{route.named || 'unnamed route'} to #{route.dest.inspect}"
-      end
-
-      private
-      def raw_url(args, options)
-        raise InvalidRouteException
+        "Path: #{path.inspect} for route #{route.name || 'unnamed route'} to #{route.dest.inspect}"
       end
     end
   end

data/lib/http_router/node/request_method.rb

@@ -0,0 +1,16 @@
+class HttpRouter
+  class Node
+    class RequestMethod < AbstractRequestNode
+      def initialize(router, parent, request_methods)
+        super(router, parent, request_methods, :request_method)
+      end
+
+      def to_code
+        "if #{@tests.map { |test| "#{test.inspect} === request.rack_request.#{request_method}" } * ' or '}
+          #{super}
+        end
+        request.acceptable_methods.merge(#{@tests.inspect})"
+      end
+    end
+  end
+end

data/lib/http_router/node/root.rb

@@ -8,14 +8,8 @@ class HttpRouter
         @counter, @methods_module = 0, Module.new
       end
 
-      def [](request)
-        compile
-        self[request]
-      end
-      alias_method :compiling_lookup, :[]
-
       def uncompile
-        instance_eval "undef :[]; alias :[] :compiling_lookup", __FILE__, __LINE__ if compiled?
+        instance_eval "undef :call; def call(req); raise 'uncompiled root'; end", __FILE__, __LINE__ if compiled?
       end
 
       def next_counter
@@ -36,12 +30,112 @@ class HttpRouter
         "Root (#{@matchers.size} matchers)"
       end
 
-      private
-      def compile
+      def compile(routes)
+        routes.each {|route| add_route(route)}
         root.extend(root.methods_module)
-        instance_eval "def [](request)\n#{to_code}\nnil\nend", __FILE__, __LINE__
+        instance_eval "def call(request, &callback)\n#{to_code}\nnil\nend"
         @compiled = true
       end
+
+      private
+      def add_route(route)
+        paths = if route.path_for_generation.nil?
+          route.match_partially = true
+          []
+        elsif route.path_for_generation.is_a?(Regexp)
+          [route.path_for_generation]
+        else
+          path_for_generation = route.path_for_generation.dup
+          start_index, end_index = 0, 1
+          raw_paths, chars = [""], path_for_generation.split('')
+          until chars.empty?
+            case chars.first[0]
+            when ?(
+              chars.shift
+              (start_index...end_index).each { |path_index| raw_paths << raw_paths[path_index].dup }
+              start_index = end_index
+              end_index = raw_paths.size
+            when ?)
+              chars.shift
+              start_index -= end_index - start_index
+            else
+              c = if chars[0][0] == ?\\ && (chars[1][0] == ?( || chars[1][0] == ?)); chars.shift; chars.shift; else; chars.shift; end
+              (start_index...end_index).each { |path_index| raw_paths[path_index] << c } 
+            end
+          end
+          raw_paths
+        end
+        paths.reverse!
+        if paths.empty?
+          add_non_path_to_tree(route, @router.root, nil, [])
+        else
+          Generator.new(route, paths).each_path do |path_generator|
+            case path_generator.path
+            when Regexp
+              path_generator.param_names = path_generator.path.names.map(&:to_sym) if path_generator.path.respond_to?(:names)
+              add_non_path_to_tree(route, add_free_match(path_generator.path), path_generator.path, path_generator.param_names)
+            else
+              node = self
+              path_generator.path.split(/\//).each do |part|
+                next if part == ''
+                parts = part.scan(/\\.|[:*][a-z0-9_]+|[^:*\\]+/)
+                node = parts.size == 1 ? add_normal_part(route, node, part, path_generator) : add_complex_part(route, node, parts, path_generator)
+              end
+              add_non_path_to_tree(route, node, path_generator.path, path_generator.param_names)
+            end
+          end
+        end
+      end
+
+      def add_normal_part(route, node, part, path_generator)
+        name = part[1, part.size]
+        node = case part[0]
+        when ?\\
+          node.add_lookup(part[1].chr)
+        when ?:
+          path_generator.param_names << name.to_sym
+          route.matches_with(name) ? node.add_spanning_match(route.matches_with(name)) : node.add_variable
+        when ?*
+          path_generator.param_names << name.to_sym
+          route.matches_with(name) ? node.add_glob_regexp(route.matches_with(name)) : node.add_glob
+        else
+          node.add_lookup(part)
+        end
+      end
+
+      def add_complex_part(route, node, parts, path_generator)
+        capturing_indicies, splitting_indicies, captures, spans = [], [], 0, false
+        regex = parts.inject('') do |reg, part|
+          reg << case part[0]
+          when ?\\ then Regexp.quote(part[1].chr)
+          when ?:, ?*
+            spans = true if part[0] == ?*
+            captures += 1
+            (part[0] == ?* ? splitting_indicies : capturing_indicies) << captures
+            name = part[1, part.size].to_sym
+            path_generator.param_names << name.to_sym
+            if spans
+              route.matches_with(name) ? "((?:#{route.matches_with(name)}\\/?)+)" : '(.*?)'
+            else
+              "(#{(route.matches_with(name) || '[^/]*?')})"
+            end
+          else
+            Regexp.quote(part)
+          end
+        end
+        spans ? node.add_spanning_match(Regexp.new("#{regex}$"), capturing_indicies, splitting_indicies) :
+          node.add_match(Regexp.new("#{regex}$"), capturing_indicies, splitting_indicies)
+      end
+
+      def add_non_path_to_tree(route, node, path, param_names)
+        node = node.add_host([route.host, route.other_hosts].flatten.compact) if route.host or route.other_hosts
+        node = node.add_user_agent(route.user_agent) if route.user_agent
+        node = node.add_scheme(route.scheme) if route.scheme
+        node = node.add_request_method(route.request_methods) if route.request_methods
+        path_obj = node.add_destination(route, path, param_names)
+        path_obj
+      end
+
     end
   end
 end