http_router 0.8.0 → 0.8.1

data/lib/http_router/node/arbitrary.rb

@@ -3,26 +3,25 @@ class HttpRouter
     class Arbitrary < Node
       attr_reader :allow_partial, :blk, :param_names
 
-      def initialize(router, allow_partial, blk, param_names)
+      def initialize(router, parent, sallow_partial, blk, param_names)
         @allow_partial, @blk, @param_names = allow_partial, blk, param_names
         @node_position = router.register_node(blk)
-        super(router)
+        super(router, parent)
       end
 
-      def usuable?(other)
+      def usable?(other)
         other.class == self.class && other.allow_partial == allow_partial && other.blk == blk && other.param_names == param_names
       end
 
-      def to_code(pos)
-        indented_code pos, "
-        #{"if r#{pos}.path_finished?" unless @allow_partial}
-          r#{pos.next} = r#{pos}.dup
-          r#{pos.next}.continue = proc { |state|
+      def to_code
+        "#{"if request.path_finished?" unless @allow_partial}
+          request.continue = proc { |state|
             if state
-              #{super(pos.next)}
+              #{super}
             end
           }
-          router.nodes.at(#{node_position})[r#{pos.next}, #{@param_names.nil? || @param_names.empty? ? '{}' : "Hash[#{@param_names.inspect}.zip(r#{pos.next}.params)]"}]
+          router.nodes.at(#{node_position})[request, #{@param_names.nil? || @param_names.empty? ? '{}' : "Hash[#{@param_names.inspect}.zip(request.params)]"}]
+          request.continue = nil
         #{"end" unless @allow_partial}"
       end
     end

data/lib/http_router/node/destination.rb

@@ -3,21 +3,20 @@ class HttpRouter
     class Destination < Node
       attr_reader :blk, :allow_partial, :param_names
       
-      def initialize(router, blk, allow_partial)
+      def initialize(router, parent, blk, allow_partial)
         @blk, @allow_partial = blk, allow_partial
         @node_position = router.register_node(blk)
-        super(router)
+        super(router, parent)
       end
 
-      def usuable?(other)
+      def usable?(other)
         other.class == self.class && other.allow_partial == allow_partial && other.blk == blk
       end
 
-      def to_code(pos)
-        indented_code pos, "
-        #{"if r#{pos}.path_finished?" unless @allow_partial}
-          r0.passed_with = catch(:pass) do
-            router.nodes.at(#{node_position})[r#{pos}, #{@param_names.nil? || @param_names.empty? ? 'nil' : "Hash[#{@param_names.inspect}.zip(r#{pos.next}.params)]"}]
+      def to_code
+        "#{"if request.path_finished?" unless @allow_partial}
+          request.passed_with = catch(:pass) do
+            router.nodes.at(#{node_position})[request, #{@param_names.nil? || @param_names.empty? ? 'nil' : "Hash[#{@param_names.inspect}.zip(request.params)]"}]
           end
         #{"end" unless @allow_partial}"
       end

data/lib/http_router/node/free_regex.rb

@@ -2,25 +2,29 @@ class HttpRouter
   class Node
     class FreeRegex < Node
       attr_reader :matcher
-      def initialize(router, matcher)
+      def initialize(router, parent, matcher)
         @matcher = matcher
-        super(router)
+        super(router, parent)
       end
 
-      def to_code(pos)
-        indented_code pos, "
-        whole_path = \"/\#{r#{pos}.joined_path}\"
+      def to_code
+        "whole_path = \"/\#{request.joined_path}\"
         if match = #{matcher.inspect}.match(whole_path) and match[0].size == whole_path.size
-          r#{pos.next} = r#{pos}.dup
-          r#{pos.next}.extra_env['router.regex_match'] = match
-          r#{pos.next}.path = ['']
+          request.extra_env['router.regex_match'] = match
+          old_path = request.path
+          request.path = ['']
           " << (//.respond_to?(:names) ?
-          "match.names.size.times{|i| r#{pos.next}.params << match[i + 1]} if match.respond_to?(:names) && match.names" : "") << "
-          #{super(pos.next)}
+          "match.names.size.times{|i| request.params << match[i + 1]} if match.respond_to?(:names) && match.names" : "") << "
+          #{super}
+          request.path = old_path
+          request.extra_env.delete('router.regex_match')
+          " << (//.respond_to?(:names) ?
+          "params.slice!(-match.names.size, match.names.size)" : ""
+          ) << "
         end"
       end
 
-      def usuable?(other)
+      def usable?(other)
         other.class == self.class && other.matcher == matcher
       end
     end

data/lib/http_router/node/glob.rb

@@ -1,20 +1,20 @@
 class HttpRouter
   class Node
     class Glob < Node
-      def usuable?(other)
+      def usable?(other)
         other.class == self.class
       end
 
-      def to_code(pos)
-        indented_code pos, "
-          r#{pos.next} = r#{pos}.dup
-          r#{pos.next}.params << []
-          remaining_parts = r#{pos.next}.path.dup
+      def to_code
+        "request.params << (globbed_params#{depth} = [])
+          remaining_parts = request.path.dup
           until remaining_parts.empty?
-            r#{pos.next}.params[-1] << URI.unescape(remaining_parts.shift)
-            r#{pos.next}.path = remaining_parts
-            #{super(pos.next)}
-          end"
+            globbed_params#{depth} << URI.unescape(remaining_parts.shift)
+            request.path = remaining_parts
+            #{super}
+          end
+          request.path[0,0] = request.params.pop
+          "
       end
     end
   end

data/lib/http_router/node/glob_regex.rb

@@ -1,15 +1,16 @@
 class HttpRouter
   class Node
     class GlobRegex < SpanningRegex
-      def to_code(pos)
-        indented_code pos, "
-          whole_path = r#{pos}.joined_path
+      def to_code
+        "whole_path = request.joined_path
           if match = #{@matcher.inspect}.match(whole_path) and match.begin(0).zero?
-            r#{pos.next} = r#{pos}.dup\n" << 
-          @capturing_indicies.map { |c| "r#{pos.next}.params << URI.unescape(match[#{c}].split(/\\//))\n" }.join << "
+            original_path = request.path.dup\n" << 
+          @capturing_indicies.map { |c| "request.params << URI.unescape(match[#{c}].split(/\\//))\n" }.join << "
           remaining_path = whole_path[match[0].size + (whole_path[match[0].size] == ?/ ? 1 : 0), whole_path.size]
-          r#{pos.next}.path = remaining_path.split('/')
-          #{super(pos.next)}
+          request.path = remaining_path.split('/')
+          #{super}
+          request.path = original_path
+          #{@capturing_indicies.size == 1 ? "request.params.pop" : "request.params.slice!(#{-@capturing_indicies.size}, #{@capturing_indicies.size})"}
         end
           "
       end

data/lib/http_router/node/lookup.rb

@@ -1,29 +1,29 @@
 class HttpRouter
   class Node
     class Lookup < Node
-      def initialize(router)
+      def initialize(router, parent)
         @map = {}
-        super(router)
+        super(router, parent)
       end
 
       def add(part)
-        Node.new(@router, @map[part] ||= [])
+        Node.new(@router, self, @map[part] ||= [])
       end
 
-      def usuable?(other)
+      def usable?(other)
         other.class == self.class
       end
 
-      def to_code(pos)
-        code = "case r#{pos}.path.first\n"
+      def to_code
+        code = "\ncase request.path.first\n"
         @map.keys.each do |k|
           code << "when #{k.inspect}\n
-  r#{pos.next} = r#{pos}.dup
-  r#{pos.next}.path.shift
-  #{@map[k].map{|n| n.to_code(pos.next)} * "\n"}"
+  part#{depth} = request.path.shift
+  #{@map[k].map{|n| n.to_code} * "\n"}
+  request.path.unshift part#{depth}
+  "
         end
         code << "\nend"
-        indented_code pos, code
       end
     end
   end

data/lib/http_router/node/regex.rb

@@ -4,24 +4,25 @@ class HttpRouter
       alias_method :node_to_code, :to_code
       attr_reader :matcher, :splitting_indicies, :capturing_indicies
 
-      def initialize(router, matcher, capturing_indicies, splitting_indicies = nil)
+      def initialize(router, parent, matcher, capturing_indicies, splitting_indicies = nil)
         @matcher, @capturing_indicies, @splitting_indicies = matcher, capturing_indicies, splitting_indicies
-        super(router)
+        super(router, parent)
       end
 
-      def usuable?(other)
+      def usable?(other)
         other.class == self.class && other.matcher == matcher && other.splitting_indicies == splitting_indicies && other.capturing_indicies == capturing_indicies
       end
 
-      def to_code(pos)
-          indented_code pos, "
-          if match = #{@matcher.inspect}.match(r#{pos}.path.first) and match.begin(0).zero?
-            r#{pos.next} = r#{pos}.dup
-            r#{pos.next}.path.shift\n" <<
-            @splitting_indicies.map { |s| "r#{pos.next}.params << URI.unescape(match[#{s}]).split(/\\//)\n" }.join <<
-            @capturing_indicies.map { |c| "r#{pos.next}.params << URI.unescape(match[#{c}])\n" }.join << "
-            #{super(pos.next)}
-          end"
+      def to_code
+        params_size = @splitting_indicies.size + @capturing_indicies.size
+        "if match = #{@matcher.inspect}.match(request.path.first) and match.begin(0).zero?
+          part = request.path.shift\n" <<
+          @splitting_indicies.map { |s| "request.params << URI.unescape(match[#{s}]).split(/\\//)\n" }.join <<
+          @capturing_indicies.map { |c| "request.params << URI.unescape(match[#{c}])\n" }.join << "
+          #{super}
+          request.path.unshift part
+          #{params_size == 1 ? "request.params.pop" : "request.params.slice!(#{-params_size}, #{params_size})"}
+        end"
       end
     end
   end

data/lib/http_router/node/request.rb

@@ -3,26 +3,25 @@ class HttpRouter
     class Request < Node
       attr_reader :request_method, :opts
 
-      def initialize(router, opts)
+      def initialize(router, parent, opts)
         @opts = opts
         Array(@opts[:request_method]).each { |m| router.known_methods << m } if @opts.key?(:request_method)
-        super(router)
+        super(router, parent)
       end
 
-      def usuable?(other)
+      def usable?(other)
         other.class == self.class && other.opts == opts
       end
 
-      def to_code(pos)
+      def to_code
         code = "if "
         code << @opts.map do |k,v|
           case v
-          when Array then "(#{v.map{|vv| "#{vv.inspect} === r#{pos}.rack_request.#{k}"}.join(' or ')})"
-          else            "#{v.inspect} === r#{pos}.rack_request.#{k.inspect}"
+          when Array then "(#{v.map{|vv| "#{vv.inspect} === request.rack_request.#{k}"}.join(' or ')})"
+          else            "#{v.inspect} === request.rack_request.#{k.inspect}"
           end           
         end * ' and '
         code << "\n  #{super}\nend"
-        indented_code pos, code
       end
     end
   end

data/lib/http_router/node/spanning_regex.rb

@@ -1,18 +1,21 @@
 class HttpRouter
   class Node
     class SpanningRegex < Regex
-      def to_code(pos)
-        indented_code(pos, "
-          whole_path = r#{pos}.joined_path
+      def to_code
+        params_count = (@splitting_indicies || []).size + @capturing_indicies.size
+        "whole_path = request.joined_path
           if match = #{@matcher.inspect}.match(whole_path) and match.begin(0).zero?
-            r#{pos.next} = r#{pos}.dup\n" <<
-            (@splitting_indicies || []).map { |s| "r#{pos.next}.params << URI.unescape(match[#{s}]).split(/\\//)\n" }.join <<
-            @capturing_indicies.map { |c| "r#{pos.next}.params << URI.unescape(match[#{c}])\n" }.join << "
+            original_path#{depth} = request.path.dup
+            " <<
+            (@splitting_indicies || []).map { |s| "request.params << URI.unescape(match[#{s}]).split(/\\//)\n" }.join <<
+            @capturing_indicies.map { |c| "request.params << URI.unescape(match[#{c}])\n" }.join << "
             remaining_path = whole_path[match[0].size + (whole_path[match[0].size] == ?/ ? 1 : 0), whole_path.size]
-            r#{pos.next}.path = remaining_path.split('/')
-            #{node_to_code(pos.next)}
+            request.path = remaining_path.split('/')
+            #{node_to_code}
+            request.path = original_path#{depth}
+            request.params.slice!(#{-params_count.size}, #{params_count})
           end
-        ")
+        "
       end
     end
   end

data/lib/http_router/node/variable.rb

@@ -1,17 +1,16 @@
 class HttpRouter
   class Node
     class Variable < Node
-      def usuable?(other)
+      def usable?(other)
         other.class == self.class
       end
 
-      def to_code(pos)
-        indented_code(pos, "
-          unless r#{pos}.path_finished?
-            r#{pos.next} = r#{pos}.dup
-            r#{pos.next}.params << URI.unescape(r#{pos.next}.path.shift)
-            #{super(pos.next)}
-          end")
+      def to_code
+        "unless request.path_finished?
+          request.params << URI.unescape(request.path.shift)
+          #{super}
+          request.path.unshift URI.escape(request.params.pop)
+        end"
       end
     end
   end

data/lib/http_router/node.rb

@@ -11,46 +11,46 @@ class HttpRouter
     autoload :Lookup,        'http_router/node/lookup'
     autoload :Destination,   'http_router/node/destination'
 
-    attr_reader :priority, :router, :node_position
+    attr_reader :priority, :router, :node_position, :parent
 
-    def initialize(router, matchers = [])
-      @router, @matchers = router, matchers
+    def initialize(router, parent, matchers = [])
+      @router, @parent, @matchers = router, parent, matchers
     end
 
     def add_variable
-      add(Variable.new(@router))
+      add(Variable.new(@router, self))
     end
 
     def add_glob
-      add(Glob.new(@router))
+      add(Glob.new(@router, self))
     end
 
     def add_request(opts)
-      add(Request.new(@router, opts))
+      add(Request.new(@router, self, opts))
     end
 
     def add_arbitrary(blk, allow_partial, param_names)
-      add(Arbitrary.new(@router, allow_partial, blk, param_names))
+      add(Arbitrary.new(@router, self, allow_partial, blk, param_names))
     end
 
     def add_match(regexp, matching_indicies = [0], splitting_indicies = nil)
-      add(Regex.new(@router, regexp, matching_indicies, splitting_indicies))
+      add(Regex.new(@router, self, regexp, matching_indicies, splitting_indicies))
     end
 
     def add_spanning_match(regexp, matching_indicies = [0], splitting_indicies = nil)
-      add(SpanningRegex.new(@router, regexp, matching_indicies, splitting_indicies))
+      add(SpanningRegex.new(@router, self, regexp, matching_indicies, splitting_indicies))
     end
 
     def add_free_match(regexp)
-      add(FreeRegex.new(@router, regexp))
+      add(FreeRegex.new(@router, self, regexp))
     end
 
     def add_destination(blk, partial)
-      add(Destination.new(@router, blk, partial))
+      add(Destination.new(@router, self, blk, partial))
     end
 
     def add_lookup(part)
-      add(Lookup.new(@router)).add(part)
+      add(Lookup.new(@router, self)).add(part)
     end
 
     def usable?(other)
@@ -67,7 +67,7 @@ class HttpRouter
     end
 
     def compile
-      instance_eval "def [](r0)\n#{to_code(0)}\nnil\nend", __FILE__, __LINE__
+      instance_eval "def [](request)\n#{to_code}\nnil\nend", __FILE__, __LINE__
     end
 
     private
@@ -76,18 +76,18 @@ class HttpRouter
       @matchers.last
     end
 
-    def to_code(pos)
-      @matchers.map{ |m| m.to_code(pos) }.join("\n") << "\n"
+    def to_code
+      @matchers.map{ |m| "# #{m.class}\n" << m.to_code }.join("\n") << "\n"
     end
 
-    def indented_code(pos, code)
-      lines = code.
-        strip.
-        split(/\n/).
-        select{|l| !l.strip.size.zero?}
-      indent_size = lines.first[/ */].size
-      lines.map! {|l| "#{'  ' * pos.next}#{l[indent_size, l.size]}"}
-      "\n" << lines.join("\n") << "\n"
+    def depth
+      p = @parent
+      d = 0
+      until p.nil?
+        d += 1
+        p = p.parent
+      end
+      d
     end
   end
 end

data/lib/http_router/request.rb

@@ -27,14 +27,6 @@ class HttpRouter
       "request path, #{path.inspect}"
     end
 
-    def dup
-      dup_obj = super
-      dup_obj.path = path.dup
-      dup_obj.params = params.dup
-      dup_obj.extra_env = extra_env.dup
-      dup_obj
-    end
-
     def path_finished?
       @path.size == 0 or @path.size == 1 && @path.first == ''
     end

data/lib/http_router/version.rb

@@ -1,4 +1,4 @@
 # encoding: utf-8
 class HttpRouter #:nodoc
-  VERSION = '0.8.0'
+  VERSION = '0.8.1'
 end

data/lib/http_router.rb

@@ -138,7 +138,7 @@ class HttpRouter
 
   # Resets the router to a clean state.
   def reset!
-    @routes, @named_routes, @root = [], {}, Node.new(self)
+    @routes, @named_routes, @root = [], {}, Node.new(self, nil)
     @default_app = Proc.new{ |env| ::Rack::Response.new("Your request couldn't be found", 404).finish }
   end
 

metadata

@@ -1,13 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: http_router
 version: !ruby/object:Gem::Version 
-  hash: 63
   prerelease: 
-  segments: 
-  - 0
-  - 8
-  - 0
-  version: 0.8.0
+  version: 0.8.1
 platform: ruby
 authors: 
 - Joshua Hull
@@ -19,143 +14,104 @@ date: 2011-06-01 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  version_requirements: &id001 !ruby/object:Gem::Requirement 
+  name: rack
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 23
-        segments: 
-        - 1
-        - 0
-        - 0
         version: 1.0.0
-  requirement: *id001
-  prerelease: false
   type: :runtime
-  name: rack
+  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  version_requirements: &id002 !ruby/object:Gem::Requirement 
+  name: url_mount
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 21
-        segments: 
-        - 0
-        - 2
-        - 1
         version: 0.2.1
-  requirement: *id002
-  prerelease: false
   type: :runtime
-  name: url_mount
+  version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  version_requirements: &id003 !ruby/object:Gem::Requirement 
+  name: minitest
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 15
-        segments: 
-        - 2
-        - 0
-        - 0
         version: 2.0.0
-  requirement: *id003
-  prerelease: false
   type: :development
-  name: minitest
+  version_requirements: *id003
 - !ruby/object:Gem::Dependency 
-  version_requirements: &id004 !ruby/object:Gem::Requirement 
+  name: code_stats
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
         version: "0"
-  requirement: *id004
-  prerelease: false
   type: :development
-  name: code_stats
+  version_requirements: *id004
 - !ruby/object:Gem::Dependency 
-  version_requirements: &id005 !ruby/object:Gem::Requirement 
+  name: rake
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 49
-        segments: 
-        - 0
-        - 8
-        - 7
         version: 0.8.7
-  requirement: *id005
-  prerelease: false
   type: :development
-  name: rake
+  version_requirements: *id005
 - !ruby/object:Gem::Dependency 
-  version_requirements: &id006 !ruby/object:Gem::Requirement 
+  name: rbench
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
         version: "0"
-  requirement: *id006
-  prerelease: false
   type: :development
-  name: rbench
+  version_requirements: *id006
 - !ruby/object:Gem::Dependency 
-  version_requirements: &id007 !ruby/object:Gem::Requirement 
+  name: phocus
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
         version: "0"
-  requirement: *id007
-  prerelease: false
   type: :development
-  name: phocus
+  version_requirements: *id007
 - !ruby/object:Gem::Dependency 
-  version_requirements: &id008 !ruby/object:Gem::Requirement 
+  name: bundler
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 23
-        segments: 
-        - 1
-        - 0
-        - 0
         version: 1.0.0
-  requirement: *id008
-  prerelease: false
   type: :development
-  name: bundler
+  version_requirements: *id008
 - !ruby/object:Gem::Dependency 
-  version_requirements: &id009 !ruby/object:Gem::Requirement 
+  name: thin
+  prerelease: false
+  requirement: &id009 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        hash: 15
-        segments: 
-        - 1
-        - 2
-        - 8
         version: 1.2.8
-  requirement: *id009
-  prerelease: false
   type: :development
-  name: thin
+  version_requirements: *id009
 description: This library allows you to recognize and build URLs in a Rack application.
 email: joshbuddy@gmail.com
 executables: []
@@ -239,18 +195,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 requirements: []