http_router 0.1.1 → 0.1.2

data/.gitignore

@@ -0,0 +1,2 @@
+benchmarks
+pkg

data/Rakefile

@@ -1,18 +1,3 @@
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |s|
-    s.name = "http_router"
-    s.description = s.summary = "A kick-ass HTTP router for use in Rack & Sinatra"
-    s.email = "joshbuddy@gmail.com"
-    s.homepage = "http://github.com/joshbuddy/http_router"
-    s.authors = ["Joshua Hull"]
-    s.files = FileList["[A-Z]*", "{lib,spec}/**/*"]
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler not available. Install it with: gem install jeweler"
-end
-
 require 'spec'
 require 'spec/rake/spectask'
 Spec::Rake::SpecTask.new(:spec) do |t|

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.1.2

data/http_router.gemspec

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{http_router}
+  s.version = File.read(File.join(File.dirname(__FILE__), 'VERSION')).strip
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Joshua Hull"]
+  s.date = %q{2010-05-30}
+  s.description = %q{A kick-ass HTTP router for use in Rack & Sinatra}
+  s.email = %q{joshbuddy@gmail.com}
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = `git ls-files`.split("\n")
+  s.homepage = %q{http://github.com/joshbuddy/http_router}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{A kick-ass HTTP router for use in Rack & Sinatra}
+  s.test_files = `git ls-files spec`.split("\n")
+
+  # dependencies
+  s.add_dependency "rack", ">= 1.0.0"
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/lib/http_router/glob.rb

@@ -6,7 +6,6 @@ class HttpRouter
         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/node.rb

@@ -1,7 +1,7 @@
 class HttpRouter
   class Node
     attr_accessor :value, :variable, :catchall
-    attr_reader :linear, :lookup, :request_node, :extension_node
+    attr_reader :linear, :lookup, :request_node, :arbitrary_node
 
     def initialize(base)
       @router = base
@@ -36,11 +36,6 @@ class HttpRouter
       end
     end
     
-    def add_extension(ext)
-      @extension_node ||= router.node
-      @extension_node.add(ext)
-    end
-    
     def add_request_methods(options)
       if !options.empty?
         generate_request_method_tree(options)
@@ -55,6 +50,24 @@ class HttpRouter
       end
     end
     
+    def add_arbitrary(procs)
+      target = self
+      if procs && !procs.empty?
+        @arbitrary_node ||= router.arbitrary_node
+        @arbitrary_node.create_linear
+        target = router.node
+        @arbitrary_node.linear << [procs, target]
+        if @value
+          @arbitrary_node.catchall = router.node
+          @arbitrary_node.catchall.value = @value
+          @value = nil
+        end
+      elsif @arbitrary_node
+        target = @arbitrary_node.catchall = router.node
+      end
+      target
+    end
+    
     protected
     
     attr_reader :router
@@ -120,45 +133,44 @@ class HttpRouter
       current_nodes
     end
 
-    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
+    def find_on_parts(request, parts, params)
+      if @linear && !@linear.empty?
+        whole_path = parts.join('/')
+        next_node = @linear.find do |(tester, node)|
+          if tester.is_a?(Regexp) and match = tester.match(whole_path) #and match.index == 0 TODO
+            whole_path.slice!(0,match[0].size)
+            parts.replace(router.split(whole_path))
+            node
+          elsif tester.respond_to?(:matches) and new_params = tester.matches(request.env, parts, whole_path)
+            params << new_params
+            node
+          else
+            nil
           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
+        if next_node and match = next_node.last.find_on_parts(request, parts, params)
+          return match
         end
       end
+      if match = @lookup && @lookup[parts.first]
+        parts.shift
+        match.find_on_parts(request, parts, params)
+      elsif @catchall
+        params << @catchall.variable.matches(request.env, parts, whole_path)
+        parts.shift
+        @catchall.find_on_parts(request, parts, params)
+      elsif parts.size == 1 && parts.first == '' && (value && value.route.trailing_slash_ignore? || router.ignore_trailing_slash?)
+        parts.shift
+        find_on_parts(request, parts, params)
+      elsif request_node
+        request_node.find_on_request_methods(request)
+      elsif arbitrary_node
+        arbitrary_node.find_on_arbitrary(request)
+      elsif @value
+        self
+      else
+        nil
+      end
     end
 
     def create_linear
@@ -169,6 +181,18 @@ class HttpRouter
       @lookup ||= {}
     end
   end
+
+  class ArbitraryNode < Node
+    def find_on_arbitrary(request)
+      if @linear && !@linear.empty?
+        next_node = @linear.find do |(procs, node)|
+          procs.all?{|p| p.call(request)}
+        end
+        return next_node.last if next_node
+      end
+      @catchall
+    end
+  end
   
   class RequestNode < Node
     RequestMethods =  [:request_method, :host, :port, :scheme]
@@ -191,7 +215,9 @@ class HttpRouter
         end
       end
       
-      if @value
+      if @arbitrary_node
+        @arbitrary_node.find_on_arbitrary(request)
+      elsif @value
         self
       else
         current_node = request_method == :request_method ? Response.unmatched(405, {"Allow" => @lookup.keys.join(", ")}) : nil

data/lib/http_router/path.rb

@@ -1,10 +1,10 @@
 require 'cgi'
 class HttpRouter
   class Path
-    attr_reader :parts, :extension
+    attr_reader :parts
     attr_accessor :route
-    def initialize(path, parts, extension)
-      @path, @parts, @extension = path, parts, extension
+    def initialize(path, parts)
+      @path, @parts = path, parts
       if duplicate_variable_names = variable_names.dup.uniq!
         raise AmbiguousVariableException.new("You have duplicate variable name present: #{duplicate_variable_names.join(', ')}")
       end
@@ -22,7 +22,7 @@ class HttpRouter
       @parts.each_with_index {|p,i| 
         return unless compare_parts(p, other_path.parts[i])
       }
-      compare_parts(@extension, other_path.extension)
+      true
     end
 
     def compare_parts(p1, p2)
@@ -60,7 +60,6 @@ class HttpRouter
     def variables
       unless @variables
         @variables = @parts.select{|p| p.is_a?(Variable)}
-        @variables << @extension if @extension.is_a?(Variable)
       end
       @variables
     end
@@ -68,9 +67,5 @@ class HttpRouter
     def variable_names
       @variable_names ||= variables.map{|v| v.name}
     end
-
-    def matches_extension?(extension)
-      @extension.nil? || @extension === (extension)
-    end
   end
 end

data/lib/http_router/response.rb

@@ -15,14 +15,13 @@ class HttpRouter
       end
     end
 
-    class Matched < Struct.new(:path, :params, :extension, :matched_path, :remaining_path)
+    class Matched < Struct.new(:path, :params, :matched_path, :remaining_path)
       attr_reader :params_as_hash, :route
 
-      def initialize(path, params, extension, matched_path, remaining_path)
+      def initialize(path, params, matched_path, remaining_path = nil)
         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?

data/lib/http_router/root.rb

@@ -2,38 +2,32 @@ class HttpRouter
   class Root < Node
     def add_path(path)
       node = path.parts.inject(self) { |node, part| node.add(part) }
-      if path.extension
-        node = node.add_extension(path.extension)
-      end
       node
     end
 
     def find(request)
       path = request.path_info.dup
-      path.slice!(-1) if router.ignore_trailing_slash? && path[-1] == ?/
-      extension = extract_extension(path)
       parts = router.split(path)
       parts << '' if path[path.size - 1] == ?/
       params = []
       process_response(
-        find_on_parts(request, parts, extension, params),
+        find_on_parts(request, parts, params),
         parts,
-        extension,
         params, 
         request
       )
     end
     
     private
-    def process_response(node, parts, extension, params, request)
+    def process_response(node, parts, params, request)
       if node.respond_to?(:matched?) && !node.matched?
         node
       elsif node && node.value
         if parts.empty?
-          post_match(node.value, params, extension, request.path_info)
+          Response.matched(node.value, params, request.path_info)
         elsif node.value.route.partially_match?
-          rest = '/' << parts.join('/') << (extension ? ".#{extension}" : '')
-          post_match(node.value, params, nil, request.path_info[0, request.path_info.size - rest.size], rest)
+          rest = '/' << parts.join('/')
+          Response.matched(node.value, params, request.path_info[0, request.path_info.size - rest.size], rest)
         else
           nil
         end
@@ -41,21 +35,5 @@ class HttpRouter
         nil
       end
     end
-
-    def extract_extension(path)
-      if path.gsub!(/\.([^\/\.]+)$/, '')
-        extension = $1
-      else
-        nil
-      end
-    end
-
-    def post_match(path, params, extension, matched_path, remaining_path = nil)
-      if path.route.partially_match? || path.matches_extension?(extension)
-        Response.matched(path, params, extension, matched_path, remaining_path)
-      else
-        nil
-      end
-    end
   end
 end

data/lib/http_router/route.rb

@@ -9,9 +9,8 @@ class HttpRouter
       @original_path = path.dup
       @partially_match = extract_partial_match(path)
       @trailing_slash_ignore = extract_trailing_slash(path)
-      @variable_store = {}
       @matches_with = {}
-      @additional_matchers = {}
+      @arbitrary = []
       @conditions =  {}
       @default_values = {}
     end
@@ -96,13 +95,9 @@ class HttpRouter
       match.each do |var_name, matchers|
         matchers = Array(matchers)
         matchers.each do |m|
-          if m.respond_to?(:call)
-            (@additional_matchers[var_name] ||= []) << m
-          else
-            @matches_with.key?(var_name) ?
-              raise :
-              @matches_with[var_name] = m
-          end    
+          @matches_with.key?(var_name) ?
+            raise :
+            @matches_with[var_name] = m
         end
       end
       self
@@ -122,6 +117,11 @@ class HttpRouter
       @partially_match = match
       self
     end
+
+    def arbitrary(proc = nil, &block)
+      @arbitrary << (proc || block)
+      self
+    end
   
     def compiled?
       !@paths.nil?
@@ -139,6 +139,7 @@ class HttpRouter
           path.route = self
           current_node = router.root.add_path(path)
           working_set = current_node.add_request_methods(@conditions)
+          working_set.map!{|node| node.add_arbitrary(@arbitrary)}
           working_set.each do |current_node|
             current_node.value = path
           end
@@ -226,18 +227,6 @@ class HttpRouter
       path[-2, 2] == '/?' && path.slice!(-2, 2)
     end
 
-    def extract_extension(path)
-      if match = path.match(/^(.*)(\.:([a-zA-Z_]+))$/)
-        path.replace(match[1])
-        v_name = match[3].to_sym
-        router.variable(match[3].to_sym, @matches_with[v_name], @additional_matchers && @additional_matchers[v_name])
-      elsif match = path.match(/^(.*)(\.([a-zA-Z_]+))$/)
-        path.replace(match[1])
-        match[3]
-      end
-    end
-
-
     def compile_optionals(path)
       start_index = 0
       end_index = 1
@@ -269,26 +258,28 @@ class HttpRouter
       paths = compile_optionals(@path)
       paths.map do |path|
         original_path = path.dup
-        extension = extract_extension(path)
-        new_path = router.split(path).map do |part|
-          case part[0]
-          when ?:
-            v_name = part[1, part.size].to_sym
-            @variable_store[v_name] ||= router.variable(v_name, @matches_with[v_name], @additional_matchers && @additional_matchers[v_name])
-          when ?*
-            v_name = part[1, part.size].to_sym
-            @variable_store[v_name] ||= router.glob(v_name, @matches_with[v_name], @additional_matchers && @additional_matchers[v_name])
+        index = -1
+        split_path = router.split(path)
+        new_path = split_path.map do |part|
+          index += 1
+          case part
+          when /^:([a-zA-Z_0-9]+)$/
+            v_name = $1.to_sym
+            router.variable(v_name, @matches_with[v_name])
+          when /^\*([a-zA-Z_0-9]+)$/
+            v_name = $1.to_sym
+            router.glob(v_name, @matches_with[v_name])
           else
             generate_interstitial_parts(part)
           end
         end
         new_path.flatten!
-        Path.new(original_path, new_path, extension)
+        Path.new(original_path, new_path)
       end
     end
 
     def generate_interstitial_parts(part)
-      part_segments = part.split(/(:[a-zA-Z_]+)/)
+      part_segments = part.scan(/:[a-zA-Z_0-9]+|[^:]+/)
       if part_segments.size > 1
         index = 0
         part_segments.map do |seg|
@@ -301,7 +292,7 @@ class HttpRouter
             else
               /^#{matcher || '.*?'}(?=#{Regexp.quote(part_segments[next_index])})/
             end
-            @variable_store[v_name] ||= router.variable(v_name, scan_regex, @additional_matchers && @additional_matchers[v_name])
+            router.variable(v_name, scan_regex)
           else
             /^#{Regexp.quote(seg)}/
           end

data/lib/http_router/variable.rb

@@ -2,27 +2,22 @@ class HttpRouter
   class Variable
     attr_reader :name, :matches_with
 
-    def initialize(base, name, matches_with = nil, additional_matchers = nil)
+    def initialize(base, name, matches_with = nil)
       @router = base
       @name = name
       @matches_with = matches_with
-      @additional_matchers = additional_matchers
     end
 
     def matches(env, parts, whole_path)
       if @matches_with.nil?
-        additional_matchers(env, parts.first) ? parts.first : nil
-      elsif @matches_with and match = @matches_with.match(whole_path) and additional_matchers(env, parts.first)
+        parts.first
+      elsif @matches_with and match = @matches_with.match(whole_path)
         whole_path.slice!(0, match[0].size)
         parts.replace(router.split(whole_path))
         match[0]
       end
     end
 
-    def additional_matchers(env, test)
-      @additional_matchers.nil? || @additional_matchers.all?{|m| m.call(env, test)}
-    end
-
     def ===(part)
       @matches_with.nil?
     end

data/lib/http_router.rb

@@ -127,6 +127,10 @@ class HttpRouter
     RequestNode.new(self, *args)
   end
 
+  def arbitrary_node(*args)
+    ArbitraryNode.new(self, *args)
+  end
+
   # Returns a new variable
   def variable(*args)
     Variable.new(self, *args)

data/spec/misc_spec.rb

@@ -15,12 +15,11 @@ describe "HttpRouter" do
   end
 
   context "instance_eval block" do
-    HttpRouter.new {
-      add('/test').to :test
-    }.recognize(Rack::MockRequest.env_for('/test', :method => 'GET')).dest.should == :test
-  
+    #HttpRouter.new {
+    #  add('/test').to :test
+    #}.recognize(Rack::MockRequest.env_for('/test', :method => 'GET')).dest.should == :test
   end
-  
+
   context "exceptions" do
     it "should be smart about multiple optionals" do
       proc {@router.add("/:var1(/:var2)(/:var3)").compile}.should raise_error(HttpRouter::AmbiguousRouteException)

data/spec/recognize_spec.rb

@@ -31,11 +31,37 @@ describe "HttpRouter#recognize" do
 
     context("proc acceptance") do
       it "should match optionally with a proc" do
-        route = @router.add("/:test").matching(:test => /^\d+/).matching(:test => proc{|env, val| val == '123' or raise}).to(:test)
-        response = @router.recognize(Rack::MockRequest.env_for('/123'))
-        response.route.should == route
-        response.params_as_hash[:test].should == '123'
+        @router.add("/test").arbitrary(Proc.new{|req| req.host == 'hellodooly' }).to(:test1)
+        @router.add("/test").arbitrary(Proc.new{|req| req.host == 'lovelove' }).arbitrary{|req| req.port == 80}.to(:test2)
+        @router.add("/test").arbitrary(Proc.new{|req| req.host == 'lovelove' }).arbitrary{|req| req.port == 8080}.to(:test3)
+        response = @router.recognize(Rack::MockRequest.env_for('http://lovelove:8080/test'))
+        response.dest.should == :test3
+      end
+
+      it "should still use an existing less specific node if possible" do
+        @router.add("/test").to(:test4)
+        @router.add("/test").arbitrary(Proc.new{|req| req.host == 'hellodooly' }).to(:test1)
+        @router.add("/test").arbitrary(Proc.new{|req| req.host == 'lovelove' }).arbitrary{|req| req.port == 80}.to(:test2)
+        @router.add("/test").arbitrary(Proc.new{|req| req.host == 'lovelove' }).arbitrary{|req| req.port == 8080}.to(:test3)
+        response = @router.recognize(Rack::MockRequest.env_for('http://lovelove:8081/test'))
+        response.dest.should == :test4
+      end
+
+      it "should match optionally with a proc and request conditions" do
+        @router.add("/test").get.arbitrary(Proc.new{|req| req.host == 'lovelove' }).arbitrary{|req| req.port == 80}.to(:test1)
+        @router.add("/test").get.arbitrary(Proc.new{|req| req.host == 'lovelove' }).arbitrary{|req| req.port == 8080}.to(:test2)
+        response = @router.recognize(Rack::MockRequest.env_for('http://lovelove:8080/test'))
+        response.dest.should == :test2
       end
+
+      it "should still use an existing less specific node if possible with request conditions" do
+        @router.add("/test").get.arbitrary(Proc.new{|req| req.host == 'lovelove' }).arbitrary{|req| req.port == 80}.to(:test1)
+        @router.add("/test").get.arbitrary(Proc.new{|req| req.host == 'lovelove' }).arbitrary{|req| req.port == 8080}.to(:test2)
+        @router.add("/test").get.to(:test3)
+        response = @router.recognize(Rack::MockRequest.env_for('http://lovelove:8081/test'))
+        response.dest.should == :test3
+      end
+
     end
 
     context("trailing slashes") do
@@ -55,6 +81,10 @@ describe "HttpRouter#recognize" do
         route = @router.add("/test").to(:test)
         @router.recognize(Rack::MockRequest.env_for('/test/')).should be_nil
       end
+      it "should not capture the trailing slash in a variable normally" do
+        route = @router.add("/:test").to(:test)
+        @router.recognize(Rack::MockRequest.env_for('/test/')).params.first.should == 'test'
+      end
     end
 
   end
@@ -110,7 +140,6 @@ describe "HttpRouter#recognize" do
       route = @router.add('/test.:format').to(:test)
       response = @router.recognize(Rack::MockRequest.env_for('/test.html'))
       response.route.should == route
-      response.extension.should == 'html'
       response.params_as_hash[:format].should == 'html'
       @router.recognize(Rack::MockRequest.env_for('/test')).should be_nil
     end
@@ -119,11 +148,9 @@ describe "HttpRouter#recognize" do
       route = @router.add('/test(.:format)').to(:test)
       response = @router.recognize(Rack::MockRequest.env_for('/test.html'))
       response.route.should == route
-      response.extension.should == 'html'
       response.params_as_hash[:format].should == 'html'
       response = @router.recognize(Rack::MockRequest.env_for('/test'))
       response.route.should == route
-      response.extension.should be_nil
       response.params_as_hash[:format].should be_nil
     end
 
@@ -131,7 +158,6 @@ describe "HttpRouter#recognize" do
       route = @router.add('/:test.:format').to(:test)
       response = @router.recognize(Rack::MockRequest.env_for('/hey.html'))
       response.route.should == route
-      response.extension.should == 'html'
       response.params_as_hash[:format].should == 'html'
       response.params_as_hash[:test].should == 'hey'
     end
@@ -140,12 +166,10 @@ describe "HttpRouter#recognize" do
       route = @router.add('/:test(.:format)').to(:test)
       response = @router.recognize(Rack::MockRequest.env_for('/hey.html'))
       response.route.should == route
-      response.extension.should == 'html'
       response.params_as_hash[:format].should == 'html'
       response.params_as_hash[:test].should == 'hey'
       response = @router.recognize(Rack::MockRequest.env_for('/hey'))
       response.route.should == route
-      response.extension.should be_nil
       response.params_as_hash[:format].should be_nil
       response.params_as_hash[:test].should == 'hey'
     end
@@ -184,6 +208,14 @@ describe "HttpRouter#recognize" do
       response.route.should == route
       response.params_as_hash[:variable].should == '123'
     end
+    
+    it "should recognize interstitial variable when there is an extension" do
+      route = @router.add('/hey.:greed.html').to(:test)
+      response = @router.recognize(Rack::MockRequest.env_for('/hey.greedyboy.html'))
+      response.route.should == route
+      response.params_as_hash[:greed].should == 'greedyboy'
+    end
+    
   end
 
   context("dynamic greedy paths") do
@@ -196,5 +228,16 @@ describe "HttpRouter#recognize" do
       response = @router.recognize(Rack::MockRequest.env_for('/asd'))
       response.should be_nil
     end
+
+    it "should capture the trailing slash in a greedy variable" do
+      route = @router.add("/:test").matching(:test => /.*/).to(:test)
+      @router.recognize(Rack::MockRequest.env_for('/test/')).params.first.should == 'test/'
+    end
+
+    it "should capture the extension in a greedy variable" do
+      route = @router.add("/:test").matching(:test => /.*/).to(:test)
+      @router.recognize(Rack::MockRequest.env_for('/test.html')).params.first.should == 'test.html'
+    end
+
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: http_router
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 31
   prerelease: false
   segments: 
   - 0
   - 1
-  - 1
-  version: 0.1.1
+  - 2
+  version: 0.1.2
 platform: ruby
 authors: 
 - Joshua Hull
@@ -17,8 +17,23 @@ cert_chain: []
 
 date: 2010-05-30 00:00:00 -04:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  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
+  type: :runtime
+  version_requirements: *id001
 description: A kick-ass HTTP router for use in Rack & Sinatra
 email: joshbuddy@gmail.com
 executables: []
@@ -28,9 +43,11 @@ extensions: []
 extra_rdoc_files: 
 - README.rdoc
 files: 
+- .gitignore
 - README.rdoc
 - Rakefile
 - VERSION
+- http_router.gemspec
 - lib/ext/rack/rack_mapper.rb
 - lib/ext/rack/uri_escape.rb
 - lib/http_router.rb
@@ -93,4 +110,5 @@ test_files:
 - spec/rack/route_spec.rb
 - spec/recognize_spec.rb
 - spec/sinatra/recognize_spec.rb
+- spec/spec.opts
 - spec/spec_helper.rb