roda 1.1.0 → 1.2.0

data/lib/roda/plugins/slash_path_empty.rb

@@ -0,0 +1,25 @@
+class Roda
+  module RodaPlugins
+    # The slash_path_empty plugin considers "/" as an empty path,
+    # in addition to the default of "" being considered an empty
+    # path.  This makes it so +r.is+ without an argument will match
+    # a path of "/", and +r.is+ and verb methods such as +r.get+ and
+    # +r.post+ will match if the path is "/" after the arguments
+    # are processed.  This can make it easier to handle applications
+    # where a trailing "/" in the path should be ignored.
+    module SlashPathEmpty
+      SLASH = "/".freeze
+
+      module RequestMethods
+        private
+
+        # Consider the path empty if it is "/".
+        def empty_path?
+          super || remaining_path == SLASH
+        end
+      end
+    end
+
+    register_plugin(:slash_path_empty, SlashPathEmpty)
+  end
+end

data/lib/roda/plugins/static_path_info.rb

@@ -0,0 +1,64 @@
+class Roda
+  module RodaPlugins
+    # The static_path_info plugin changes Roda's behavior so that the
+    # SCRIPT_NAME/PATH_INFO environment settings are not modified
+    # while the request is beind routed, improving performance.  If
+    # you have any helpers that operate on PATH_INFO or SCRIPT_NAME,
+    # their behavior will not change depending on where they are
+    # called in the routing tree.
+    #
+    # This still updates SCRIPT_NAME/PATH_INFO before dispatching to
+    # another rack app via +r.run+.
+    module StaticPathInfo
+      module RequestMethods
+        PATH_INFO = "PATH_INFO".freeze
+        SCRIPT_NAME = "SCRIPT_NAME".freeze
+
+        # The current path to match requests against.  This is initialized
+        # to PATH_INFO when the request is created.
+        attr_reader :remaining_path
+
+        # Set remaining_path when initializing.
+        def initialize(*)
+          super
+          @remaining_path = @env[PATH_INFO]
+        end
+
+        # The already matched part of the path, including the original SCRIPT_NAME.
+        def matched_path
+          e = @env
+          e[SCRIPT_NAME] + e[PATH_INFO].chomp(@remaining_path)
+        end
+
+        # Update SCRIPT_NAME/PATH_INFO based on the current remaining_path
+        # before dispatching to another rack app, so the app still works as
+        # a URL mapper.
+        def run(_)
+          e = @env
+          path = @remaining_path
+          e[SCRIPT_NAME] += e[PATH_INFO].chomp(path)
+          e[PATH_INFO] = path
+          super
+        end
+
+        private
+
+        # Update remaining_path with the remaining characters
+        def update_remaining_path(remaining)
+          @remaining_path = remaining
+        end
+
+        # Yield to the block, restoring the remaining_path before
+        # the method returns.
+        def keep_remaining_path
+          path = @remaining_path
+          yield
+        ensure
+          @remaining_path = path
+        end
+      end
+    end
+
+    register_plugin(:static_path_info, StaticPathInfo)
+  end
+end

data/lib/roda/plugins/streaming.rb

@@ -154,7 +154,7 @@ class Roda
             end
           end
 
-          throw :halt, response.finish_with_body(Stream.new(opts, &block))
+          throw :halt, @_response.finish_with_body(Stream.new(opts, &block))
         end
       end
     end

data/lib/roda/plugins/view_subdirs.rb

@@ -23,15 +23,18 @@ class Roda
     #     end
     #   end
     #
-    # This plugin should be loaded after the render plugin, since
-    # it works by overriding parts of the render plugin.
-    # 
     # Note that when a view subdirectory is set, the layout will
     # also be looked up in the subdirectory unless it contains
     # a slash.  So if you want to use a view subdirectory for
     # templates but have a shared layout, you should make sure your
     # layout contains a slash, similar to the example above.
     module ViewSubdirs
+      # Load the render plugin before this plugin, since this plugin
+      # works by overriding a method in the render plugin.
+      def self.load_dependencies(app)
+        app.plugin :render
+      end
+
       module InstanceMethods
         # Set the view subdirectory to use.  This can be set to nil
         # to not use a view subdirectory.
@@ -44,12 +47,13 @@ class Roda
         # Override the template name to use the view subdirectory if the
         # there is a view subdirectory and the template name does not
         # contain a slash.
-        def template_path(template, opts)
-          t = template.to_s
-          if (v = @_view_subdir) && t !~ /\//
-            template = "#{v}/#{t}"
+        def template_name(opts)
+          name = super
+          if (v = @_view_subdir) && name !~ /\//
+            "#{v}/#{name}"
+          else
+            name
           end
-          super
         end
       end
     end

data/lib/roda/version.rb

@@ -1,3 +1,3 @@
 class Roda
-  RodaVersion = '1.1.0'.freeze
+  RodaVersion = '1.2.0'.freeze
 end

data/spec/integration_spec.rb

@@ -35,6 +35,25 @@ describe "integration" do
     body('/hello').should == 'D First Second Block'
   end
 
+  it "should clear middleware when clear_middleware! is called" do
+    c = @c
+    app(:bare) do 
+      use c, "First", "Second" do
+        "Block"
+      end
+
+      route do |r|
+        r.get "hello" do
+          "D #{r.env['m.first']} #{r.env['m.second']} #{r.env['m.block']}"
+        end
+      end
+
+      clear_middleware!
+    end
+
+    body('/hello').should == 'D   '
+  end
+
   it "should support adding middleware using use after route block setup" do
     c = @c
     app(:bare) do 
@@ -64,6 +83,20 @@ describe "integration" do
     body('/hello').should == 'D 1 2 3'
   end
 
+  it "should not inherit middleware in subclass if inhert_middleware = false" do
+    c = @c
+    app(:bare){use(c, '1', '2'){"3"}}
+    @app.inherit_middleware = false
+    @app = Class.new(@app)
+    @app.route do  |r|
+      r.get "hello" do
+        "D #{r.env['m.first']} #{r.env['m.second']} #{r.env['m.block']}"
+      end
+    end
+
+    body('/hello').should == 'D   '
+  end
+
   it "should inherit route in subclass" do
     c = @c
     app(:bare) do

data/spec/plugin/backtracking_array_spec.rb

@@ -16,23 +16,29 @@ describe "backtracking_array plugin" do
       end
     end
 
-    status.should == 404
-
-    body("/a").should == 'a'
-    body("/a/b").should == 'a/b'
-    status("/a/b/").should == 404
-
-    body("/c/d").should == 'c-d'
-    body("/c/e").should == 'c-e'
-    body("/c/d/d").should == 'c/d-d'
-    body("/c/d/e").should == 'c/d-e'
-    status("/c/d/").should == 404
-
-    body("/f").should == 'f'
-    body("/f/g").should == 'f/g'
-    body("/g").should == 'g'
-    body("/g/h").should == 'g/h'
-    status("/f/g/").should == 404
-    status("/g/h/").should == 404
+    tests = lambda do
+      status.should == 404
+
+      body("/a").should == 'a'
+      body("/a/b").should == 'a/b'
+      status("/a/b/").should == 404
+
+      body("/c/d").should == 'c-d'
+      body("/c/e").should == 'c-e'
+      body("/c/d/d").should == 'c/d-d'
+      body("/c/d/e").should == 'c/d-e'
+      status("/c/d/").should == 404
+
+      body("/f").should == 'f'
+      body("/f/g").should == 'f/g'
+      body("/g").should == 'g'
+      body("/g/h").should == 'g/h'
+      status("/f/g/").should == 404
+      status("/g/h/").should == 404
+    end
+
+    tests.call
+    app.plugin(:static_path_info)
+    tests.call
   end
 end

data/spec/plugin/class_level_routing_spec.rb

@@ -0,0 +1,138 @@
+require File.expand_path("spec_helper", File.dirname(File.dirname(__FILE__)))
+
+describe "class_level_routing plugin" do 
+  before do
+    app(:bare) do 
+      plugin :class_level_routing
+      plugin :all_verbs
+
+      root do
+        'root'
+      end
+
+      on "foo" do
+        request.get "bar" do
+          "foobar"
+        end
+
+        "foo"
+      end
+
+      is "d:d" do |x|
+        request.get do
+          "bazget#{x}"
+        end
+
+        request.post do
+          "bazpost#{x}"
+        end
+      end
+
+      meths = %w'get post delete head options patch put trace'
+      meths.concat(%w'link unlink') if ::Rack::Request.method_defined?("link?")
+      meths.each do |meth|
+        send(meth, :d) do |m|
+          "x-#{meth}-#{m}"
+        end
+      end
+    end
+  end
+
+  it "adds class methods for setting up routes" do
+    body.should == 'root'
+    body('/foo').should == 'foo'
+    body('/foo/bar').should == 'foobar'
+    body('/dgo').should == 'bazgetgo'
+    body('/dgo', 'REQUEST_METHOD'=>'POST').should == 'bazpostgo'
+    body('/bar').should == "x-get-bar"
+    body('/bar', 'REQUEST_METHOD'=>'POST').should == "x-post-bar"
+    body('/bar', 'REQUEST_METHOD'=>'DELETE').should == "x-delete-bar"
+    body('/bar', 'REQUEST_METHOD'=>'HEAD').should == "x-head-bar"
+    body('/bar', 'REQUEST_METHOD'=>'OPTIONS').should == "x-options-bar"
+    body('/bar', 'REQUEST_METHOD'=>'PATCH').should == "x-patch-bar"
+    body('/bar', 'REQUEST_METHOD'=>'PUT').should == "x-put-bar"
+    body('/bar', 'REQUEST_METHOD'=>'TRACE').should == "x-trace-bar"
+    if ::Rack::Request.method_defined?("link?")
+      body('/bar', 'REQUEST_METHOD'=>'LINK').should == "x-link-bar"
+      body('/bar', 'REQUEST_METHOD'=>'UNLINK').should == "x-unlink-bar"
+    end
+
+    status.should == 200
+    status("/asdfa/asdf").should == 404
+
+    @app = Class.new(app)
+    body.should == 'root'
+    body('/foo').should == 'foo'
+    body('/foo/bar').should == 'foobar'
+    body('/dgo').should == 'bazgetgo'
+    body('/dgo', 'REQUEST_METHOD'=>'POST').should == 'bazpostgo'
+    body('/bar').should == "x-get-bar"
+    body('/bar', 'REQUEST_METHOD'=>'POST').should == "x-post-bar"
+    body('/bar', 'REQUEST_METHOD'=>'DELETE').should == "x-delete-bar"
+    body('/bar', 'REQUEST_METHOD'=>'HEAD').should == "x-head-bar"
+    body('/bar', 'REQUEST_METHOD'=>'OPTIONS').should == "x-options-bar"
+    body('/bar', 'REQUEST_METHOD'=>'PATCH').should == "x-patch-bar"
+    body('/bar', 'REQUEST_METHOD'=>'PUT').should == "x-put-bar"
+    body('/bar', 'REQUEST_METHOD'=>'TRACE').should == "x-trace-bar"
+  end
+
+  it "only calls class level routes if routing tree doesn't handle request" do
+    app.route do |r|
+      r.root do
+        'iroot'
+      end
+
+      r.get 'foo' do
+        'ifoo'
+      end
+
+      r.on 'bar' do
+        r.get true do
+          response.status = 404
+          ''
+        end
+        r.post true do
+          'ibar'
+        end
+      end
+    end
+
+    body.should == 'iroot'
+    body('/foo').should == 'ifoo'
+    body('/foo/bar').should == 'foobar'
+    body('/dgo').should == 'bazgetgo'
+    body('/dgo', 'REQUEST_METHOD'=>'POST').should == 'bazpostgo'
+    body('/bar').should == ""
+    body('/bar', 'REQUEST_METHOD'=>'POST').should == "ibar"
+    body('/bar', 'REQUEST_METHOD'=>'DELETE').should == "x-delete-bar"
+    body('/bar', 'REQUEST_METHOD'=>'HEAD').should == "x-head-bar"
+    body('/bar', 'REQUEST_METHOD'=>'OPTIONS').should == "x-options-bar"
+    body('/bar', 'REQUEST_METHOD'=>'PATCH').should == "x-patch-bar"
+    body('/bar', 'REQUEST_METHOD'=>'PUT').should == "x-put-bar"
+    body('/bar', 'REQUEST_METHOD'=>'TRACE').should == "x-trace-bar"
+  end
+
+  it "works with the not_found plugin if loaded before" do
+    app.plugin :not_found do
+      "nf"
+    end
+
+    body.should == 'root'
+    body('/foo').should == 'foo'
+    body('/foo/bar').should == 'foobar'
+    body('/dgo').should == 'bazgetgo'
+    body('/dgo', 'REQUEST_METHOD'=>'POST').should == 'bazpostgo'
+    body('/bar').should == "x-get-bar"
+    body('/bar', 'REQUEST_METHOD'=>'POST').should == "x-post-bar"
+    body('/bar', 'REQUEST_METHOD'=>'DELETE').should == "x-delete-bar"
+    body('/bar', 'REQUEST_METHOD'=>'HEAD').should == "x-head-bar"
+    body('/bar', 'REQUEST_METHOD'=>'OPTIONS').should == "x-options-bar"
+    body('/bar', 'REQUEST_METHOD'=>'PATCH').should == "x-patch-bar"
+    body('/bar', 'REQUEST_METHOD'=>'PUT').should == "x-put-bar"
+    body('/bar', 'REQUEST_METHOD'=>'TRACE').should == "x-trace-bar"
+
+    status.should == 200
+    status("/asdfa/asdf").should == 404
+    body("/asdfa/asdf").should == "nf"
+  end
+end

data/spec/plugin/delay_build_spec.rb

@@ -0,0 +1,23 @@
+require File.expand_path("spec_helper", File.dirname(File.dirname(__FILE__)))
+
+describe "delay_build plugin" do 
+  it "does not build rack app until app is called" do
+    app(:delay_build){"a"}
+    app.instance_variable_get(:@app).should == nil
+    body.should == "a"
+    app.instance_variable_get(:@app).should_not == nil
+  end
+
+  it "only rebuilds the app if build! is called" do
+    app(:delay_build){"a"}
+    body.should == "a"
+    c = Class.new do
+      def initialize(_) end
+      def call(_) [200, {}, ["b"]] end
+    end
+    app.use c
+    body.should == "a"
+    app.build!
+    body.should == "b"
+  end
+end

data/spec/plugin/delegate_spec.rb

@@ -0,0 +1,20 @@
+require File.expand_path("spec_helper", File.dirname(File.dirname(__FILE__)))
+
+describe "delegate plugin" do 
+  it "adds request_delegate and response_delegate class methods for delegating" do
+    app(:bare) do 
+      plugin :delegate
+      request_delegate :root
+      response_delegate :headers
+
+      route do
+        root do
+          headers['Content-Type'] = 'foo'
+        end
+      end
+    end
+    
+    header('Content-Type').should == 'foo'
+    status('/foo').should == 404
+  end
+end

data/spec/plugin/drop_body_spec.rb

@@ -0,0 +1,20 @@
+require File.expand_path("spec_helper", File.dirname(File.dirname(__FILE__)))
+
+describe "drop_body plugin" do 
+  it "automatically drops body and Content-Type/Content-Length headers for responses without a body" do
+    app(:drop_body) do |r|
+      response.status = r.path.to_i
+      response.write('a')
+    end
+
+    [101, 102, 204, 205, 304].each do  |i|
+      body(i.to_s).should == ''
+      header('Content-Type', i.to_s).should == nil
+      header('Content-Length', i.to_s).should == nil
+    end
+
+    body('200').should == 'a'
+    header('Content-Type', '200').should == 'text/html'
+    header('Content-Length', '200').should == '1'
+  end
+end