http_router 0.8.11 → 0.9.3

data/js/test/test.coffee

@@ -0,0 +1,136 @@
+require.paths.push("#{__dirname}/../lib")
+fs = require('fs')
+util = require('util')
+sys = require('sys')
+http_router = require('http_router')
+assert = require('assert')
+
+class Example
+  constructor: (@routes, @tests) ->
+
+class Test
+  constructor: (file)->
+    @examples = []
+    contents = fs.readFileSync(file, 'utf8')
+    lines = contents.split(/\n/m)
+    currentTest = null
+    routes = []
+    tests = []
+    for line in lines
+      if line.match(/^#/)
+        # this is a comment, skip
+      else if line.match(/^\s*$/)
+        # empty line, skip
+      else if line.match(/^(  |\t)/)
+        # this is a test
+        tests.push(JSON.parse(line))
+      else
+        # this is a route
+        if tests.length != 0
+          @examples.push new Example(routes, tests)
+          routes = []
+          tests = []
+        parsedRoutes = JSON.parse(line)
+        if parsedRoutes instanceof Array
+          for r in parsedRoutes
+            routes.push(r)
+        else
+          routes.push(parsedRoutes)
+    @examples.push new Example(routes, tests)
+  interpretValue: (v) ->
+    if v.regex? then new RegExp(v.regex) else v
+  invoke: -> throw("need to implement")
+  constructRouter: (example) ->
+    router = new Sherpa()
+    for route in example.routes
+      for name, vals of route
+        path = null
+        opts = {name: name}
+        if vals.path?
+          path = @interpretValue(vals.path)
+          delete vals.path
+          if vals.conditions?
+            conditions = {}
+            for k, v of vals.conditions
+              switch k
+                when 'request_method' then conditions.method = @interpretValue(v)
+                else                       conditions[k]     = @interpretValue(v)
+            opts.conditions = conditions
+            delete vals.conditions
+          if vals.default?
+            opts.default = vals.default
+            delete vals.default
+          matchesWith = {}
+          for k, v of vals
+            matchesWith[k] = @interpretValue(v)
+            delete vals.k
+          opts.matchesWith = matchesWith
+        else
+          path = @interpretValue(vals)
+        name = "" + name
+        router.add(path, opts).to (req, response) ->
+          response.params = req.params
+          response.end(req.route.name)
+    router
+
+class GenerationTest extends Test
+  constructor: -> super
+  invoke: ->
+    console.log("Running #{@examples.length} generation tests")
+    for example in @examples
+      process.stdout.write "*"
+      router = @constructRouter(example)
+      for test in example.tests
+        process.stdout.write "."
+        [expectedResult, name, params] = test
+        continue if params? && params instanceof Array
+        continue if name instanceof Object
+        actualResult = router.url(name, params)
+        assert.equal(expectedResult, actualResult)
+    console.log("\nDone!")
+
+class RecognitionTest extends Test
+  constructor: -> super
+  invoke: ->
+    console.log("Running #{@examples.length} recognition tests")
+    for example in @examples
+      process.stdout.write "*"
+      router = @constructRouter(example)
+      for test in example.tests
+        mockResponse = end: (part) -> @val = part
+        process.stdout.write "."
+        [expectedRouteName, requestingPath, expectedParams] = test
+        mockRequest = {}
+        complex = false
+        if requestingPath.path?
+          complex = true
+          mockRequest.url = requestingPath.path
+          delete requestingPath.path
+          for k, v of requestingPath
+            mockRequest[k] = v
+        else
+          mockRequest.url = requestingPath
+        mockRequest.url = "http://host#{mockRequest.url}" unless mockRequest.url.match(/^http/)
+        router.match(mockRequest, mockResponse)
+        assert.equal(expectedRouteName, mockResponse.val)
+        expectedParams ||= {}
+        mockResponse.params ||= {}
+        pathInfoExcpectation = null
+        if expectedParams.PATH_INFO?
+          pathInfoExcpectation = expectedParams.PATH_INFO
+          delete expectedParams.PATH_INFO
+        assert.equal(pathInfoExcpectation, mockRequest.pathInfo) if pathInfoExcpectation
+        assert.deepEqual(expectedParams, mockResponse.params)
+        unless complex
+          mockResponse = end: (part) -> @val = part
+          router.match(requestingPath, mockResponse)
+          assert.equal(expectedRouteName, mockResponse.val)
+          expectedParams ||= {}
+          mockResponse.params ||= {}
+          assert.equal(pathInfoExcpectation, mockRequest.pathInfo) if pathInfoExcpectation
+          assert.deepEqual(expectedParams, mockResponse.params)
+    console.log("\nDone!")
+
+new GenerationTest("#{__dirname}/../../test/common/generate.txt").invoke()
+new RecognitionTest("#{__dirname}/../../test/common/recognize.txt").invoke()
+

data/js/test/test.js

@@ -0,0 +1,229 @@
+(function() {
+  var Example, GenerationTest, RecognitionTest, Test, assert, fs, http_router, sys, util;
+  var __hasProp = Object.prototype.hasOwnProperty, __extends = function(child, parent) {
+    for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; }
+    function ctor() { this.constructor = child; }
+    ctor.prototype = parent.prototype;
+    child.prototype = new ctor;
+    child.__super__ = parent.prototype;
+    return child;
+  };
+  require.paths.push("" + __dirname + "/../lib");
+  fs = require('fs');
+  util = require('util');
+  sys = require('sys');
+  http_router = require('http_router');
+  assert = require('assert');
+  Example = (function() {
+    function Example(routes, tests) {
+      this.routes = routes;
+      this.tests = tests;
+    }
+    return Example;
+  })();
+  Test = (function() {
+    function Test(file) {
+      var contents, currentTest, line, lines, parsedRoutes, r, routes, tests, _i, _j, _len, _len2;
+      this.examples = [];
+      contents = fs.readFileSync(file, 'utf8');
+      lines = contents.split(/\n/m);
+      currentTest = null;
+      routes = [];
+      tests = [];
+      for (_i = 0, _len = lines.length; _i < _len; _i++) {
+        line = lines[_i];
+        if (line.match(/^#/)) {} else if (line.match(/^\s*$/)) {} else if (line.match(/^(  |\t)/)) {
+          tests.push(JSON.parse(line));
+        } else {
+          if (tests.length !== 0) {
+            this.examples.push(new Example(routes, tests));
+            routes = [];
+            tests = [];
+          }
+          parsedRoutes = JSON.parse(line);
+          if (parsedRoutes instanceof Array) {
+            for (_j = 0, _len2 = parsedRoutes.length; _j < _len2; _j++) {
+              r = parsedRoutes[_j];
+              routes.push(r);
+            }
+          } else {
+            routes.push(parsedRoutes);
+          }
+        }
+      }
+      this.examples.push(new Example(routes, tests));
+    }
+    Test.prototype.interpretValue = function(v) {
+      if (v.regex != null) {
+        return new RegExp(v.regex);
+      } else {
+        return v;
+      }
+    };
+    Test.prototype.invoke = function() {
+      throw "need to implement";
+    };
+    Test.prototype.constructRouter = function(example) {
+      var conditions, k, matchesWith, name, opts, path, route, router, v, vals, _i, _len, _ref, _ref2;
+      router = new Sherpa();
+      _ref = example.routes;
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        route = _ref[_i];
+        for (name in route) {
+          vals = route[name];
+          path = null;
+          opts = {
+            name: name
+          };
+          if (vals.path != null) {
+            path = this.interpretValue(vals.path);
+            delete vals.path;
+            if (vals.conditions != null) {
+              conditions = {};
+              _ref2 = vals.conditions;
+              for (k in _ref2) {
+                v = _ref2[k];
+                switch (k) {
+                  case 'request_method':
+                    conditions.method = this.interpretValue(v);
+                    break;
+                  default:
+                    conditions[k] = this.interpretValue(v);
+                }
+              }
+              opts.conditions = conditions;
+              delete vals.conditions;
+            }
+            if (vals["default"] != null) {
+              opts["default"] = vals["default"];
+              delete vals["default"];
+            }
+            matchesWith = {};
+            for (k in vals) {
+              v = vals[k];
+              matchesWith[k] = this.interpretValue(v);
+              delete vals.k;
+            }
+            opts.matchesWith = matchesWith;
+          } else {
+            path = this.interpretValue(vals);
+          }
+          name = "" + name;
+          router.add(path, opts).to(function(req, response) {
+            response.params = req.params;
+            return response.end(req.route.name);
+          });
+        }
+      }
+      return router;
+    };
+    return Test;
+  })();
+  GenerationTest = (function() {
+    __extends(GenerationTest, Test);
+    function GenerationTest() {
+      GenerationTest.__super__.constructor.apply(this, arguments);
+    }
+    GenerationTest.prototype.invoke = function() {
+      var actualResult, example, expectedResult, name, params, router, test, _i, _j, _len, _len2, _ref, _ref2;
+      console.log("Running " + this.examples.length + " generation tests");
+      _ref = this.examples;
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        example = _ref[_i];
+        process.stdout.write("*");
+        router = this.constructRouter(example);
+        _ref2 = example.tests;
+        for (_j = 0, _len2 = _ref2.length; _j < _len2; _j++) {
+          test = _ref2[_j];
+          process.stdout.write(".");
+          expectedResult = test[0], name = test[1], params = test[2];
+          if ((params != null) && params instanceof Array) {
+            continue;
+          }
+          if (name instanceof Object) {
+            continue;
+          }
+          actualResult = router.url(name, params);
+          assert.equal(expectedResult, actualResult);
+        }
+      }
+      return console.log("\nDone!");
+    };
+    return GenerationTest;
+  })();
+  RecognitionTest = (function() {
+    __extends(RecognitionTest, Test);
+    function RecognitionTest() {
+      RecognitionTest.__super__.constructor.apply(this, arguments);
+    }
+    RecognitionTest.prototype.invoke = function() {
+      var complex, example, expectedParams, expectedRouteName, k, mockRequest, mockResponse, pathInfoExcpectation, requestingPath, router, test, v, _i, _j, _len, _len2, _ref, _ref2;
+      console.log("Running " + this.examples.length + " recognition tests");
+      _ref = this.examples;
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        example = _ref[_i];
+        process.stdout.write("*");
+        router = this.constructRouter(example);
+        _ref2 = example.tests;
+        for (_j = 0, _len2 = _ref2.length; _j < _len2; _j++) {
+          test = _ref2[_j];
+          mockResponse = {
+            end: function(part) {
+              return this.val = part;
+            }
+          };
+          process.stdout.write(".");
+          expectedRouteName = test[0], requestingPath = test[1], expectedParams = test[2];
+          mockRequest = {};
+          complex = false;
+          if (requestingPath.path != null) {
+            complex = true;
+            mockRequest.url = requestingPath.path;
+            delete requestingPath.path;
+            for (k in requestingPath) {
+              v = requestingPath[k];
+              mockRequest[k] = v;
+            }
+          } else {
+            mockRequest.url = requestingPath;
+          }
+          if (!mockRequest.url.match(/^http/)) {
+            mockRequest.url = "http://host" + mockRequest.url;
+          }
+          router.match(mockRequest, mockResponse);
+          assert.equal(expectedRouteName, mockResponse.val);
+          expectedParams || (expectedParams = {});
+          mockResponse.params || (mockResponse.params = {});
+          pathInfoExcpectation = null;
+          if (expectedParams.PATH_INFO != null) {
+            pathInfoExcpectation = expectedParams.PATH_INFO;
+            delete expectedParams.PATH_INFO;
+          }
+          if (pathInfoExcpectation) {
+            assert.equal(pathInfoExcpectation, mockRequest.pathInfo);
+          }
+          assert.deepEqual(expectedParams, mockResponse.params);
+          if (!complex) {
+            mockResponse = {
+              end: function(part) {
+                return this.val = part;
+              }
+            };
+            router.match(requestingPath, mockResponse);
+            assert.equal(expectedRouteName, mockResponse.val);
+            expectedParams || (expectedParams = {});
+            mockResponse.params || (mockResponse.params = {});
+            if (pathInfoExcpectation) {
+              assert.equal(pathInfoExcpectation, mockRequest.pathInfo);
+            }
+            assert.deepEqual(expectedParams, mockResponse.params);
+          }
+        }
+      }
+      return console.log("\nDone!");
+    };
+    return RecognitionTest;
+  })();
+  new GenerationTest("" + __dirname + "/../../test/common/generate.txt").invoke();
+  new RecognitionTest("" + __dirname + "/../../test/common/recognize.txt").invoke();
+}).call(this);

data/lib/http_router/node/arbitrary.rb

@@ -13,7 +13,7 @@ class HttpRouter
       end
 
       def to_code
-        b, method_name = @blk, :"blk_#{router.next_counter}"
+        b, method_name = @blk, :"blk_#{root.next_counter}"
         inject_root_methods { define_method(method_name) { b } }
         "#{"if request.path_finished?" unless @allow_partial}
           request.continue = proc { |state|

data/lib/http_router/node/free_regex.rb

@@ -8,8 +8,9 @@ class HttpRouter
       end
 
       def to_code
-        "whole_path#{depth} = \"/\#{request.joined_path}\"
-        if match = #{matcher.inspect}.match(whole_path#{depth}) and match[0].size == whole_path#{depth}.size
+        id = root.next_counter
+        "whole_path#{id} = \"/\#{request.joined_path}\"
+        if match = #{matcher.inspect}.match(whole_path#{id}) and match[0].size == whole_path#{id}.size
           request.extra_env['router.regex_match'] = match
           old_path = request.path
           request.path = ['']

data/lib/http_router/node/glob.rb

@@ -7,12 +7,13 @@ class HttpRouter
       end
 
       def to_code
-        "request.params << (globbed_params#{depth} = [])
+        id = root.next_counter
+        "request.params << (globbed_params#{id} = [])
           until request.path.empty?
-            globbed_params#{depth} << request.path.shift
+            globbed_params#{id} << request.path.shift
             #{super}
           end
-          request.path[0,0] = globbed_params#{depth}"
+          request.path[0,0] = globbed_params#{id}"
       end
     end
   end

data/lib/http_router/node/glob_regex.rb

@@ -12,10 +12,11 @@ class HttpRouter
       end
 
       def to_code
-        "request.params << (globbed_params#{depth} = [])
+        id = root.next_counter
+        "request.params << (globbed_params#{id} = [])
           remaining_parts = request.path.dup
           while !remaining_parts.empty? and match = remaining_parts.first.match(#{@matcher.inspect}) and match[0] == remaining_parts.first
-            globbed_params#{depth} << remaining_parts.shift
+            globbed_params#{id} << remaining_parts.shift
             request.path = remaining_parts
             #{node_to_code}
           end

data/lib/http_router/node/lookup.rb

@@ -15,9 +15,8 @@ class HttpRouter
       end
 
       def to_code
-        lookup_ivar = :"@lookup_#{router.next_counter}"
-        inject_root_ivar(lookup_ivar, @map)
-        method_prefix = "lookup_#{router.next_counter} "
+        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|

data/lib/http_router/node/path.rb

@@ -0,0 +1,62 @@
+class HttpRouter
+  class Node
+    class Path < Node
+      attr_reader :route, :param_names, :dynamic, :original_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?
+        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
+      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 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?}
+                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
+                throw :success, Response.new(request, #{path_ivar})
+              end
+            #{"end" unless route.match_partially?}
+          end
+        #{"end" unless route.match_partially?}"
+      end
+
+      def usable?(other)
+        other == self
+      end
+
+      private
+      def raw_url(args, options)
+        raise InvalidRouteException
+      end
+    end
+  end
+end

data/lib/http_router/node/request.rb

@@ -1,11 +1,23 @@
 class HttpRouter
   class Node
     class Request < Node
+      VALID_HTTP_VERBS = %w[HEAD GET DELETE POST PUT OPTIONS PATCH TRACE CONNECT]
+
       attr_reader :request_method, :opts
 
       def initialize(router, parent, opts)
+        opts.each do |k, v|
+          v = [v] unless v.is_a?(Array)
+          case k
+          when :request_method
+            v.map!{|val| val.to_s.upcase}
+            v.all?{|m| VALID_HTTP_VERBS.include?(m)} or raise InvalidRequestValueError, "Invalid value for request_method #{v.inspect}"
+            v.each{|val| router.known_methods << val}
+          end
+          opts[k] = v
+        end
         @opts = opts
-        Array(@opts[:request_method]).each { |m| router.known_methods << m } if @opts.key?(:request_method)
+        @opts[:request_method].each { |m| router.known_methods << m } if @opts.key?(:request_method)
         super(router, parent)
       end
 
@@ -16,7 +28,6 @@ class HttpRouter
       def to_code
         code = "if "
         code << @opts.map do |k,v|
-          v = [v] unless v.is_a?(Array)
           case v.size
           when 1 then to_code_condition(k, v.first)
           else        "(#{v.map{|vv| to_code_condition(k, vv)}.join(' or ')})"

data/lib/http_router/node/root.rb

@@ -1,21 +1,48 @@
 class HttpRouter
   class Node
     class Root < Node
-      attr_reader :methods_module
+      attr_reader :methods_module, :compiled
+      alias_method :compiled?, :compiled
       def initialize(router)
         super(router, nil)
-        @methods_module = Module.new
+        @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?
+      end
+
+      def next_counter
+        @counter += 1
+      end
+
+      def inject_root_ivar(obj)
+        name = :"@ivar_#{@counter += 1}"
+        root.instance_variable_set(name, obj)
+        name
+      end
 
       private
+      def rewrite_partial_path_info(env, request)
+        env['PATH_INFO'] = "/#{request.path.join('/')}"
+        env['SCRIPT_NAME'] += request.rack_request.path_info[0, request.rack_request.path_info.size - env['PATH_INFO'].size]
+      end
+
+      def rewrite_path_info(env, request)
+        env['SCRIPT_NAME'] += request.rack_request.path_info
+        env['PATH_INFO'] = ''
+      end
+
       def compile
         root.extend(root.methods_module)
         instance_eval "def [](request)\n#{to_code}\nnil\nend", __FILE__, __LINE__
+        @compiled = true
       end
     end
   end

data/lib/http_router/node/spanning_regex.rb

@@ -3,14 +3,15 @@ class HttpRouter
     class SpanningRegex < Regex
       def to_code
         params_count = @ordered_indicies.size
-        "whole_path#{depth} = request.joined_path
-        if match = #{@matcher.inspect}.match(whole_path#{depth}) and match.begin(0).zero?
-          original_path#{depth} = request.path.dup
+        whole_path_var = "whole_path#{root.next_counter}"
+        "#{whole_path_var} = request.joined_path
+        if match = #{@matcher.inspect}.match(#{whole_path_var}) and match.begin(0).zero?
+          _#{whole_path_var} = request.path.dup
           " << param_capturing_code << "
-          remaining_path = whole_path#{depth}[match[0].size + (whole_path#{depth}[match[0].size] == ?/ ? 1 : 0), whole_path#{depth}.size]
+          remaining_path = #{whole_path_var}[match[0].size + (#{whole_path_var}[match[0].size] == ?/ ? 1 : 0), #{whole_path_var}.size]
           request.path = remaining_path.split('/')
           #{node_to_code}
-          request.path = original_path#{depth}
+          request.path = _#{whole_path_var}
           request.params.slice!(#{-params_count.size}, #{params_count})
         end
         "

data/lib/http_router/node.rb

@@ -11,9 +11,9 @@ class HttpRouter
     autoload :Arbitrary,     'http_router/node/arbitrary'
     autoload :Request,       'http_router/node/request'
     autoload :Lookup,        'http_router/node/lookup'
-    autoload :Destination,   'http_router/node/destination'
+    autoload :Path,          'http_router/node/path'
 
-    attr_reader :priority, :router, :node_position, :parent
+    attr_reader :router
 
     def initialize(router, parent, matchers = [])
       @router, @parent, @matchers = router, parent, matchers
@@ -32,6 +32,7 @@ class HttpRouter
     end
 
     def add_request(opts)
+      raise unless opts
       add(Request.new(@router, self, opts))
     end
 
@@ -51,8 +52,8 @@ class HttpRouter
       add(FreeRegex.new(@router, self, regexp))
     end
 
-    def add_destination(blk, partial)
-      add(Destination.new(@router, self, blk, partial))
+    def add_destination(route, path, param_names = [])
+      add(Path.new(@router, self, route, path, param_names))
     end
 
     def add_lookup(part)
@@ -68,8 +69,8 @@ class HttpRouter
       code ? root.methods_module.module_eval(code) : root.methods_module.module_eval(&blk)
     end
 
-    def inject_root_ivar(name, val)
-      root.instance_variable_set(name, val)
+    def inject_root_ivar(obj)
+      root.inject_root_ivar(obj)
     end
 
     def add(matcher)
@@ -85,12 +86,6 @@ class HttpRouter
       @router.root
     end
 
-    def depth
-      d, p = 0, @parent
-      d, p = d + 1, p.parent until p.nil?
-      d
-    end
-
     def use_named_captures?
       //.respond_to?(:names)
     end

data/lib/http_router/rack/builder.rb

@@ -51,14 +51,6 @@ module HttpRouter::Rack::BuilderMixin
     map(path, options, :delete, &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 = {}, &block)
-    map(path, options, :head, &block)
-  end
-
   def options(path, options = {}, &block)
     map(path, options, :options, &block)
   end