usher 0.4.8 → 0.5.1

data/spec/private/path_spec.rb

@@ -36,18 +36,27 @@ describe "Usher route adding" do
     route_set.add_named_route(:route, '/bad/route', :controller => 'sample').should == route_set.named_routes[:route]
   end
 
+  it "should allow named routes to be added" do
+    route_set.add_named_route(:route, '/bad/route', :controller => 'sample').should == route_set.named_routes[:route]
+    route_set.route_count.should == 1
+    route_set.named_routes.size == 1
+    route_set.delete_named_route(:route, '/bad/route', :controller => 'sample')
+    route_set.route_count.should == 0
+    route_set.named_routes.size == 0
+  end
+
   it "should calculate depths for nodes" do
     route_set.add_named_route(:route, '/bad/route/three/four')
-    route_set.tree.depth.should == 0
-    route_set.tree.lookup['/'].depth.should == 1
+    route_set.root.depth.should == 0
+    route_set.root.lookup['/'].depth.should == 1
   end
 
   it "should pp for nodes" do
     route_set.add_named_route(:route, '/bad/route/three/four')
-    route_set.tree.depth.should == 0
+    route_set.root.depth.should == 0
     old_out = $stdout
     $stdout = (output = StringIO.new)
-    route_set.tree.lookup['/'].lookup['bad'].lookup['/'].pp
+    route_set.root.lookup['/'].lookup['bad'].lookup['/'].pp
     $stdout = old_out
     output.rewind
     output.read.should == <<-HEREDOC
@@ -64,5 +73,27 @@ describe "Usher route adding" do
         8: "four" true
     HEREDOC
   end
+  
+  describe "merging paths" do
+    before do
+      @r1 = route_set.add_route("/foo/bar")
+      @r2 = route_set.add_route("/other(/:baz)")
+      @p1 = @r1.paths.first
+      @p2 = @r2.paths.first
+    end
+    
+    it "should craete a new path object" do
+      @p1.merge(@p2).should_not eql(@p1)
+    end
+    
+    it "should mash the parts together" do
+      @p1.merge(@p2).parts.should == (@p1.parts + @p2.parts).flatten
+    end
+    
+    it "should maintain the route owner" do
+      @p1.merge(@p2).route.should == @p1.route
+    end
+    
+  end
 
 end

data/spec/private/rack/dispatch_spec.rb

@@ -1,29 +1,114 @@
 require 'lib/usher'
-
 require 'rack'
 
+require File.join(File.dirname(__FILE__), "..", "..", "spec_helper")
 route_set = Usher::Interface.for(:rack)
+route_set.extend(CallWithMockRequestMixin)
 
 describe "Usher (for rack) route dispatching" do
-
   before(:each) do
     route_set.reset!
+    @app = MockApp.new("Hello World!")
+    route_set.add('/sample').to(@app)
   end
 
-  it "should dispatch a simple request" do
-    app = mock 'app'
-    app.should_receive(:call).once.with {|v| v['usher.params'].should == {} }
-    route_set.add('/sample').to(app)
-    route_set.call(Rack::MockRequest.env_for("/sample", :method => 'GET'))
+  describe "HTTP GET" do
+    it "should dispatch a request" do
+      response = route_set.call_with_mock_request
+      response.body.should eql("Hello World!")
+    end
+
+    it "should write usher.params" do
+      response = route_set.call_with_mock_request
+      @app.env["usher.params"].should == {}
+    end
   end
-  
-  it "should dispatch a POST request" do
-    bad_app = mock 'bad_app'
-    app = mock 'app'
-    app.should_receive(:call).once.with {|v| v['usher.params'].should == {} }
-    route_set.add('/sample').to(bad_app)
-    route_set.add('/sample', :requirements => {:request_method => 'POST'}).to(app)
-    route_set.call(Rack::MockRequest.env_for("/sample", :request_method => 'POST'))
+
+  describe "HTTP POST" do
+    before(:each) do
+      bad_app = MockApp.new("You shouldn't get here if you are using POST")
+      route_set.add('/sample').to(bad_app)
+      route_set.add('/sample', :requirements => {:request_method => 'POST'}).to(@app)
+    end
+
+    it "should dispatch a request" do
+      response = route_set.call_with_mock_request
+      response.body.should eql("Hello World!")
+    end
+
+    it "should write usher.params" do
+      response = route_set.call_with_mock_request("/sample", :request_method => 'POST')
+      @app.env["usher.params"].should == {}
+    end
+  end
+
+  it "should returns HTTP 404 if route doesn't exist" do
+    response = route_set.call_with_mock_request("/not-existing-url")
+    response.status.should eql(404)
   end
   
+  describe "mounted rack instances" do
+    before do
+      @bad_app = mock("bad_app")
+      
+      @usher2 = Usher::Interface.for(:rack)
+      @usher2.add("/good" ).to(@app)
+      @usher2.add("/bad"  ).match_partially!.to(@bad_app)
+      @usher2.add("/some(/:foo)").to(@app)
+      
+      route_set.add("/foo/:bar", :default_values => {:foo => "foo"}).match_partially!.to(@usher2)
+      route_set.add("/foo", :default_values => {:controller => :foo}).to(@app)
+    end
+    
+    it "should match the route without nesting" do
+      @app.should_receive(:call).once.with{ |e| e['usher.params'].should == {:controller => :foo}}
+      route_set.call(Rack::MockRequest.env_for("/foo"))
+    end
+    
+    it "should route through the first route, and the second to the app" do
+      @app.should_receive(:call).once.with{|e| e['usher.params'].should == {:bar => "bar", :foo => "foo"}}
+      result = route_set.call(Rack::MockRequest.env_for("/foo/bar/good"))
+    end
+    
+    it "should go through to the bad app" do
+      @bad_app.should_receive(:call).once.with{|e| e['usher.params'].should == {:bar => "some_bar", :foo => "foo"}}
+      result = route_set.call(Rack::MockRequest.env_for("/foo/some_bar/bad"))
+    end
+    
+    it "should match optional routes paramters" do
+      @app.should_receive(:call).once.with{|e| e['usher.params'].should == {:bar => "bar", :foo => "a_different_foo"}}
+      route_set.call(Rack::MockRequest.env_for("/foo/bar/some/a_different_foo"))
+    end
+    
+    describe "SCRIPT_NAME & PATH_INFO" do
+      it "should update the script name for a fully consumed route" do
+        @app.should_receive(:call).once.with do |e|
+          e['SCRIPT_NAME'].should == "/foo"
+          e['PATH_INFO'].should   == ""
+        end
+        route_set.call(Rack::MockRequest.env_for("/foo"))
+      end
+      
+      it "should update the script name and path info for a partially consumed route" do
+        @app.should_receive(:call).once.with do |e|
+          e['SCRIPT_NAME'].should == "/partial"
+          e['PATH_INFO'].should   == "/bar/baz"
+        end
+        
+        route_set.add("/partial").match_partially!.to(@app)
+        route_set.call(Rack::MockRequest.env_for("/partial/bar/baz"))
+      end
+      
+      it "should consume the path through a mounted usher" do
+        @bad_app.should_receive(:call).once.with do |e|
+          e['SCRIPT_NAME'].should == "/foo/bar/bad"
+          e['PATH_INFO'].should   == "/leftovers"
+        end
+        
+        route_set.call(Rack::MockRequest.env_for("/foo/bar/bad/leftovers"))
+      end
+      
+    end
+    
+  end
 end

data/spec/private/recognize_spec.rb

@@ -16,21 +16,60 @@ describe "Usher route recognition" do
     route_set.reset!
   end
   
-  it "should recognize a specific domain name" do
-    target_route = route_set.add_route('/sample', :controller => 'sample', :action => 'action', :conditions => {:protocol => 'http'})
-    route_set.add_route('/sample', :controller => 'sample', :action => 'action2', :conditions => {:protocol => 'https'})
-    route_set.recognize(build_request({:method => 'get', :path => '/sample', :protocol => 'http'})).path.route.should == target_route
-  end
-  
-  it "should recognize a regex domain name" do
-    target_route = route_set.add_route('/sample', :controller => 'sample', :action => 'action', :conditions => {:domain => /^admin.*$/})
-    route_set.add_route('/sample', :controller => 'sample', :action => 'action2', :conditions => {:domain => 'www.host.com'})
-    route_set.recognize(build_request({:method => 'get', :path => '/sample', :domain => 'admin.host.com'})).path.route.should == target_route
+  describe 'request conditions' do
+  
+    it "should recognize a specific domain name" do
+      target_route = route_set.add_route('/sample', :controller => 'sample', :action => 'action', :conditions => {:protocol => 'http'})
+      route_set.add_route('/sample', :controller => 'sample', :action => 'action2', :conditions => {:protocol => 'https'})
+      route_set.recognize(build_request({:method => 'get', :path => '/sample', :protocol => 'http'})).path.route.should == target_route
+    end
+  
+    it "should recognize a regex domain name" do
+      target_route = route_set.add_route('/sample', :controller => 'sample', :action => 'action', :conditions => {:domain => /^admin.*$/})
+      route_set.add_route('/sample', :controller => 'sample', :action => 'action2', :conditions => {:domain => 'www.host.com'})
+      route_set.recognize(build_request({:method => 'get', :path => '/sample', :domain => 'admin.host.com'})).path.route.should == target_route
+    end
+
+    it "should recognize a specific route when several http-style restrictions are used" do
+      target_route_http_admin = route_set.add_route('/sample', :controller => 'sample', :action => 'action', :conditions => {:protocol => 'http', :domain => 'admin.spec.com'})
+      target_route_http_www = route_set.add_route('/sample', :controller => 'sample', :action => 'action', :conditions => {:protocol => 'http', :domain => 'www.spec.com'})
+      target_route_https_msie = route_set.add_route('/sample', :controller => 'sample', :action => 'action2', :conditions => {:protocol => 'https', :user_agent => 'MSIE 6.0'})
+      target_route_https_admin = route_set.add_route('/sample', :controller => 'sample', :action => 'action2', :conditions => {:protocol => 'https', :domain => 'admin.spec.com'})
+      route_set.recognize(build_request({:method => 'get', :path => '/sample', :protocol => 'http', :domain => 'admin.spec.com', :user_agent => nil})).path.route.should == target_route_http_admin
+      route_set.recognize(build_request({:method => 'get', :path => '/sample', :protocol => 'http', :domain => 'www.spec.com', :user_agent => nil})).path.route.should == target_route_http_www
+      route_set.recognize(build_request({:method => 'get', :path => '/sample', :protocol => 'https', :domain => 'admin.spec.com', :user_agent => 'MSIE 6.0'})).path.route.should == target_route_https_msie
+      route_set.recognize(build_request({:method => 'get', :path => '/sample', :protocol => 'https', :domain => 'admin.spec.com', :user_agent => nil})).path.route.should == target_route_https_admin
+    end
+
+    it "should correctly fix that tree if conditionals are used later" do
+      noop_route = route_set.add_route('/noop', :controller => 'products', :action => 'noop')
+      product_show_route = route_set.add_route('/products/show/:id', :id => /\d+/, :conditions => {:method => 'get'})
+      route_set.recognize(build_request({:method => 'get', :path => '/noop', :domain => 'admin.host.com'})).path.route.should == noop_route
+      route_set.recognize(build_request({:method => 'get', :path => '/products/show/123', :domain => 'admin.host.com'})).path.route.should == product_show_route
+    end
+
+    it "should use conditionals that are boolean" do
+      # hijacking user_agent
+      insecure_product_show_route = route_set.add_route('/products/show/:id', :id => /\d+/, :conditions => {:user_agent => false, :method => 'get'})
+      secure_product_show_route = route_set.add_route('/products/show/:id', :id => /\d+/, :conditions => {:user_agent => true, :method => 'get'})
+
+      secure_product_show_route.should == route_set.recognize(build_request({:method => 'get', :path => '/products/show/123', :domain => 'admin.host.com', :user_agent => true})).path.route
+      insecure_product_show_route.should == route_set.recognize(build_request({:method => 'get', :path => '/products/show/123', :domain => 'admin.host.com', :user_agent => false})).path.route
+    end
+
+    it "should use conditionals that are arrays" do
+      # hijacking user_agent
+      www_product_show_route = route_set.add_route('/products/show/:id', :id => /\d+/, :conditions => {:subdomains => ['www'], :method => 'get'})
+      admin_product_show_route = route_set.add_route('/products/show/:id', :id => /\d+/, :conditions => {:subdomains => ['admin'], :method => 'get'})
+
+      admin_product_show_route.should == route_set.recognize(build_request({:method => 'get', :path => '/products/show/123', :subdomains => ['admin'], :user_agent => true})).path.route
+      www_product_show_route.should == route_set.recognize(build_request({:method => 'get', :path => '/products/show/123', :subdomains => ['www'], :user_agent => false})).path.route
+    end
   end
   
   it "should recognize a format-style variable" do
     target_route = route_set.add_route('/sample.:format', :controller => 'sample', :action => 'action')
-    route_set.recognize(build_request({:method => 'get', :path => '/sample.html', :domain => 'admin.host.com'})).should == Usher::Node::Response.new(target_route.paths.first, [[:format , 'html']])
+    route_set.recognize(build_request({:method => 'get', :path => '/sample.html', :domain => 'admin.host.com'})).should == Usher::Node::Response.new(target_route.paths.first, [[:format , 'html']], nil, "/sample.html")
   end
   
   it "should recognize a glob-style variable" do
@@ -93,6 +132,26 @@ describe "Usher route recognition" do
     route_set.recognize(build_request({:method => 'get', :path => '/test/part/hello/again/123/hello/again/onemore'})).params.should == [[:test, ['hello', 'again', '123', 'hello', 'again']], [:party, 'onemore']]
   end
 
+  it "should recgonize a greedy regex single variable" do
+    target_route = route_set.add_route('/test/part/{!test,one/more/time}')
+    route_set.recognize(build_request({:method => 'get', :path => '/test/part/one/more/time'})).path.route.should == target_route
+    route_set.recognize(build_request({:method => 'get', :path => '/test/part/one/more/time'})).params.should == [[:test, 'one/more/time']]
+  end
+
+  it "should recgonize a greedy regex that matches across / and not" do
+    target_route = route_set.add_route('/test/part/{!test,one/more|one}')
+    route_set.recognize(build_request({:method => 'get', :path => '/test/part/one/more'})).path.route.should == target_route
+    route_set.recognize(build_request({:method => 'get', :path => '/test/part/one/more'})).params.should == [[:test, 'one/more']]
+    route_set.recognize(build_request({:method => 'get', :path => '/test/part/one'})).path.route.should == target_route
+    route_set.recognize(build_request({:method => 'get', :path => '/test/part/one'})).params.should == [[:test, 'one']]
+  end
+
+  it "should recgonize a greedy regex single variable with static parts after" do
+    target_route = route_set.add_route('/test/part/{!test,one/more/time}/help')
+    route_set.recognize(build_request({:method => 'get', :path => '/test/part/one/more/time/help'})).path.route.should == target_route
+    route_set.recognize(build_request({:method => 'get', :path => '/test/part/one/more/time/help'})).params.should == [[:test, 'one/more/time']]
+  end
+
   it "should recgonize two glob-style variables separated by a static part" do
     target_route = route_set.add_route('/*format/innovate/*onemore')
     response = route_set.recognize(build_request({:method => 'get', :path => '/sample/html/innovate/apple'}))
@@ -109,48 +168,12 @@ describe "Usher route recognition" do
   
   it "should recognize a format-style literal" do
     target_route = route_set.add_route('/:action.html', :controller => 'sample', :action => 'action')
-    route_set.recognize(build_request({:method => 'get', :path => '/sample.html', :domain => 'admin.host.com'})).should == Usher::Node::Response.new(target_route.paths.first, [[:action , 'sample']])
+    route_set.recognize(build_request({:method => 'get', :path => '/sample.html', :domain => 'admin.host.com'})).should == Usher::Node::Response.new(target_route.paths.first, [[:action , 'sample']], nil, "/sample.html")
   end
   
   it "should recognize a format-style variable along side another variable" do
     target_route = route_set.add_route('/:action.:format', :controller => 'sample', :action => 'action')
-    route_set.recognize(build_request({:method => 'get', :path => '/sample.html', :domain => 'admin.host.com'})).should == Usher::Node::Response.new(target_route.paths.first, [[:action , 'sample'], [:format, 'html']])
-  end
-  
-  it "should recognize a specific route when several http-style restrictions are used" do
-    target_route_http_admin = route_set.add_route('/sample', :controller => 'sample', :action => 'action', :conditions => {:protocol => 'http', :domain => 'admin.spec.com'})
-    target_route_http_www = route_set.add_route('/sample', :controller => 'sample', :action => 'action', :conditions => {:protocol => 'http', :domain => 'www.spec.com'})
-    target_route_https_msie = route_set.add_route('/sample', :controller => 'sample', :action => 'action2', :conditions => {:protocol => 'https', :user_agent => 'MSIE 6.0'})
-    target_route_https_admin = route_set.add_route('/sample', :controller => 'sample', :action => 'action2', :conditions => {:protocol => 'https', :domain => 'admin.spec.com'})
-    route_set.recognize(build_request({:method => 'get', :path => '/sample', :protocol => 'http', :domain => 'admin.spec.com', :user_agent => nil})).path.route.should == target_route_http_admin
-    route_set.recognize(build_request({:method => 'get', :path => '/sample', :protocol => 'http', :domain => 'www.spec.com', :user_agent => nil})).path.route.should == target_route_http_www
-    route_set.recognize(build_request({:method => 'get', :path => '/sample', :protocol => 'https', :domain => 'admin.spec.com', :user_agent => 'MSIE 6.0'})).path.route.should == target_route_https_msie
-    route_set.recognize(build_request({:method => 'get', :path => '/sample', :protocol => 'https', :domain => 'admin.spec.com', :user_agent => nil})).path.route.should == target_route_https_admin
-  end
-  
-  it "should correctly fix that tree if conditionals are used later" do
-    noop_route = route_set.add_route('/noop', :controller => 'products', :action => 'noop')
-    product_show_route = route_set.add_route('/products/show/:id', :id => /\d+/, :conditions => {:method => 'get'})
-    route_set.recognize(build_request({:method => 'get', :path => '/noop', :domain => 'admin.host.com'})).path.route.should == noop_route
-    route_set.recognize(build_request({:method => 'get', :path => '/products/show/123', :domain => 'admin.host.com'})).path.route.should == product_show_route
-  end
-  
-  it "should use conditionals that are boolean" do
-    # hijacking user_agent
-    insecure_product_show_route = route_set.add_route('/products/show/:id', :id => /\d+/, :conditions => {:user_agent => false, :method => 'get'})
-    secure_product_show_route = route_set.add_route('/products/show/:id', :id => /\d+/, :conditions => {:user_agent => true, :method => 'get'})
-    
-    secure_product_show_route.should == route_set.recognize(build_request({:method => 'get', :path => '/products/show/123', :domain => 'admin.host.com', :user_agent => true})).path.route
-    insecure_product_show_route.should == route_set.recognize(build_request({:method => 'get', :path => '/products/show/123', :domain => 'admin.host.com', :user_agent => false})).path.route
-  end
-  
-  it "should use conditionals that are arrays" do
-    # hijacking user_agent
-    www_product_show_route = route_set.add_route('/products/show/:id', :id => /\d+/, :conditions => {:subdomains => ['www'], :method => 'get'})
-    admin_product_show_route = route_set.add_route('/products/show/:id', :id => /\d+/, :conditions => {:subdomains => ['admin'], :method => 'get'})
-    
-    admin_product_show_route.should == route_set.recognize(build_request({:method => 'get', :path => '/products/show/123', :subdomains => ['admin'], :user_agent => true})).path.route
-    www_product_show_route.should == route_set.recognize(build_request({:method => 'get', :path => '/products/show/123', :subdomains => ['www'], :user_agent => false})).path.route
+    route_set.recognize(build_request({:method => 'get', :path => '/sample.html', :domain => 'admin.host.com'})).should == Usher::Node::Response.new(target_route.paths.first, [[:action , 'sample'], [:format, 'html']], nil, '/sample.html')
   end
   
   it "should use a requirement (proc) on incoming variables" do
@@ -174,5 +197,20 @@ describe "Usher route recognition" do
     proc {route_set.recognize(build_request({:method => 'get', :path => '/products/show/qweasd', :domain => 'admin.host.com'}))}.should raise_error
   end
   
-  
+  describe "partial recognition" do
+    it "should partially match a route" do
+      route = route_set.add_route("/foo")
+      route.match_partially!
+      route_set.recognize(build_request(:method => "get", :path => "/foo/bar")).should == Usher::Node::Response.new(route.paths.first, [], "/bar", '/foo')
+    end
+
+    it "should partially match a route and use request conditions" do
+      route = route_set.add_route("/foo", :conditions => {:method => 'get'})
+      route.match_partially!
+
+      route_set.recognize(build_request({:method => 'get', :path => '/foo/bar'})).path.route.should == route
+      route_set.recognize(build_request({:method => 'post', :path => '/foo/bar'})).should.nil?
+    end
+
+  end
 end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+module CallWithMockRequestMixin
+  def call_with_mock_request(url = "/sample", method = "GET", params = Hash.new)
+    params.merge!(:method => method)
+    request = Rack::MockRequest.new(self)
+    request.request(method, url, params)
+  end
+end
+
+class MockApp
+  attr_accessor :status, :headers, :body, :env
+  def initialize(body)
+    @status  = 200
+    @headers = {"Content-Type" => "text/html"}
+    @body    = body
+  end
+
+  def call(env)
+    @env = env
+    @headers.merge("Content-Length" => @body.length.to_s)
+    [@status, @headers, [@body]]
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: usher
 version: !ruby/object:Gem::Version 
-  version: 0.4.8
+  version: 0.5.1
 platform: ruby
 authors: 
 - Joshua Hull
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-16 00:00:00 -04:00
+date: 2009-08-26 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -20,7 +20,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.0.3
+        version: 0.0.6
     version: 
 description: A general purpose routing library
 email: joshbuddy@gmail.com
@@ -38,7 +38,6 @@ files:
 - VERSION.yml
 - lib/usher.rb
 - lib/usher/exceptions.rb
-- lib/usher/generate.rb
 - lib/usher/grapher.rb
 - lib/usher/interface.rb
 - lib/usher/interface/email_interface.rb
@@ -49,16 +48,22 @@ files:
 - lib/usher/interface/rails2_2_interface.rb
 - lib/usher/interface/rails2_2_interface/mapper.rb
 - lib/usher/interface/rails2_3_interface.rb
+- lib/usher/interface/rails3_interface.rb
 - lib/usher/node.rb
 - lib/usher/route.rb
 - lib/usher/route/path.rb
 - lib/usher/route/request_method.rb
+- lib/usher/route/util.rb
 - lib/usher/route/variable.rb
 - lib/usher/splitter.rb
+- lib/usher/util.rb
+- lib/usher/util/generate.rb
+- lib/usher/util/parser.rb
 - rails/init.rb
 - spec/private/email/recognize_spec.rb
 - spec/private/generate_spec.rb
 - spec/private/grapher_spec.rb
+- spec/private/parser_spec.rb
 - spec/private/path_spec.rb
 - spec/private/rack/dispatch_spec.rb
 - spec/private/rails2_2/compat.rb
@@ -71,8 +76,8 @@ files:
 - spec/private/rails2_3/recognize_spec.rb
 - spec/private/recognize_spec.rb
 - spec/private/request_method_spec.rb
-- spec/private/split_spec.rb
 - spec/spec.opts
+- spec/spec_helper.rb
 has_rdoc: true
 homepage: http://github.com/joshbuddy/usher
 licenses: []
@@ -97,7 +102,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: joshbuddy-usher
-rubygems_version: 1.3.4
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: A general purpose routing library
@@ -105,6 +110,7 @@ test_files:
 - spec/private/email/recognize_spec.rb
 - spec/private/generate_spec.rb
 - spec/private/grapher_spec.rb
+- spec/private/parser_spec.rb
 - spec/private/path_spec.rb
 - spec/private/rack/dispatch_spec.rb
 - spec/private/rails2_2/compat.rb
@@ -117,4 +123,4 @@ test_files:
 - spec/private/rails2_3/recognize_spec.rb
 - spec/private/recognize_spec.rb
 - spec/private/request_method_spec.rb
-- spec/private/split_spec.rb
+- spec/spec_helper.rb