roda 1.1.0 → 1.2.0

data/lib/roda/plugins/all_verbs.rb

@@ -6,10 +6,9 @@ class Roda
     # trace, unlink.
     #
     # These methods operate just like Roda's default get and post
-    # methods other that the http verb used, so using them without
-    # any arguments just checks for the request method, while
-    # using them with any arguments also checks that the arguments
-    # match the full path.
+    # methods, so using them without any arguments just checks for
+    # the request method, while using them with any arguments also
+    # checks that the arguments match the full path.
     #
     # Example:
     #
@@ -30,12 +29,14 @@ class Roda
     # The verb methods are defined via metaprogramming, so there
     # isn't documentation for the individual methods created.
     module AllVerbs
-      def self.configure(app)
-        %w'delete head options link patch put trace unlink'.each do |v|
-          if ::Rack::Request.method_defined?("#{v}?")
-            app.request_module do
-              app::RodaRequest.def_verb_method(self, v)
-            end
+      module RequestMethods
+        %w'delete head options link patch put trace unlink'.each do |verb|
+          if ::Rack::Request.method_defined?("#{verb}?")
+            class_eval(<<-END, __FILE__, __LINE__+1)
+              def #{verb}(*args, &block)
+                _verb(args, &block) if #{verb}?
+              end
+            END
           end
         end
       end

data/lib/roda/plugins/assets.rb

@@ -197,7 +197,7 @@ class Roda
     #                 and compressing files (default: false)
     # :css_dir :: Directory name containing your css source, inside :path (default: 'css')
     # :css_headers :: A hash of additional headers for your rendered css files
-    # :css_opts :: Options to pass to the render plugin when rendering css assets
+    # :css_opts :: Template options to pass to the render plugin (via :opts) when rendering css assets
     # :css_route :: Route under :prefix for css assets (default: :css_dir)
     # :dependencies :: A hash of dependencies for your asset files.  Keys should be paths to asset files,
     #                  values should be arrays of paths your asset files depends on.  This is used to
@@ -207,7 +207,7 @@ class Roda
     # :headers :: A hash of additional headers for both js and css rendered files
     # :js_dir :: Directory name containing your javascript source, inside :path (default: 'js')
     # :js_headers :: A hash of additional headers for your rendered javascript files
-    # :js_opts :: Options to pass to the render plugin when rendering javascript assets
+    # :js_opts :: Template options to pass to the render plugin (via :opts) when rendering javascript assets
     # :js_route :: Route under :prefix for javascript assets (default: :js_dir)
     # :path :: Path to your asset source directory (default: 'assets')
     # :prefix :: Prefix for assets path in your URL/routes (default: 'assets')
@@ -520,7 +520,7 @@ class Roda
           if file.end_with?(".#{type}")
             ::File.read(file)
           else
-            render_asset_file(file, self.class.assets_opts[:"#{type}_opts"])
+            render_asset_file(file, :opts=>self.class.assets_opts[:"#{type}_opts"])
           end
         end
 
@@ -541,8 +541,8 @@ class Roda
         # a 304 response immediately.  Otherwise, add the appropriate
         # type-specific headers.
         def check_asset_request(file, type, mtime)
-          request.last_modified(mtime)
-          response.headers.merge!(self.class.assets_opts[:"#{type}_headers"])
+          @_request.last_modified(mtime)
+          @_response.headers.merge!(self.class.assets_opts[:"#{type}_headers"])
         end
 
         # Render the given asset file using the render plugin, with the given options.

data/lib/roda/plugins/backtracking_array.rb

@@ -35,10 +35,13 @@ class Roda
         # entry in the array.
         def _match_array(arg, rest=nil)
           return super unless rest
-          env = @env
 
-          script = env[SCRIPT_NAME]
-          path = env[PATH_INFO]
+          unless path = @remaining_path
+            e = @env
+            script = e[SCRIPT_NAME]
+            path = e[PATH_INFO]
+          end
+          captures = @captures
           caps = captures.dup
           arg.each do |v|
             if match(v, rest)
@@ -52,8 +55,12 @@ class Roda
 
               # Matching all remaining elements failed, reset state
               captures.replace(caps)
-              env[SCRIPT_NAME] = script
-              env[PATH_INFO] = path
+              if @remaining_path
+                @remaining_path = path
+              else
+                e[SCRIPT_NAME] = script
+                e[PATH_INFO] = path
+              end
             end
           end
           false

data/lib/roda/plugins/caching.rb

@@ -87,18 +87,19 @@ class Roda
         # with a 412 status.
         def last_modified(time)
           return unless time
-          response[LAST_MODIFIED] = time.httpdate
+          res = response
           e = env
+          res[LAST_MODIFIED] = time.httpdate
           return if e[HTTP_IF_NONE_MATCH]
-          status = response.status
+          status = res.status
 
           if (!status || status == 200) && (ims = time_from_header(e[HTTP_IF_MODIFIED_SINCE])) && ims >= time.to_i
-            response.status = 304
+            res.status = 304
             halt
           end
 
           if (!status || (status >= 200 && status < 300) || status == 412) && (ius = time_from_header(e[HTTP_IF_UNMODIFIED_SINCE])) && ius < time.to_i
-            response.status = 412
+            res.status = 412
             halt
           end
         end
@@ -122,19 +123,20 @@ class Roda
           weak = opts[:weak]
           new_resource = opts.fetch(:new_resource){post?}
 
-          response[ETAG] = etag = "#{'W/' if weak}\"#{value}\""
-          status = response.status
+          res = response
           e = env
+          res[ETAG] = etag = "#{'W/' if weak}\"#{value}\""
+          status = res.status
 
           if (!status || (status >= 200 && status < 300) || status == 304)
             if etag_matches?(e[HTTP_IF_NONE_MATCH], etag, new_resource)
-              response.status = (request_method =~ /\AGET|HEAD|OPTIONS|TRACE\z/i ? 304 : 412)
+              res.status = (request_method =~ /\AGET|HEAD|OPTIONS|TRACE\z/i ? 304 : 412)
               halt
             end
 
             if ifm = e[HTTP_IF_MATCH]
               unless etag_matches?(ifm, etag, new_resource)
-                response.status = 412
+                res.status = 412
                 halt
               end
             end

data/lib/roda/plugins/class_level_routing.rb

@@ -0,0 +1,94 @@
+class Roda
+  module RodaPlugins
+    # The class_level_routing plugin adds routing methods at the class level, which can
+    # be used instead of or in addition to using the normal +route+ method to start the
+    # routing tree.  If a request is not matched by the normal routing tree, the class
+    # level routes will be tried.  This offers a more Sinatra-like API, while
+    # still allowing you to use a routing tree inside individual actions.
+    #
+    # Here's the first example from the README, modified to use the class_level_routing
+    # plugin:
+    #
+    #   class App < Roda
+    #     plugin :class_level_routing
+    #
+    #     # GET / request
+    #     root do
+    #       request.redirect "/hello"
+    #     end
+    #
+    #     # GET /hello/world request
+    #     get "hello/world" do
+    #       "Hello world!"
+    #     end
+    #
+    #     # /hello request
+    #     is "hello" do
+    #       # GET /hello request
+    #       request.get do
+    #         "Hello!"
+    #       end
+    #
+    #       # POST /hello request
+    #       request.post do
+    #         puts "Someone said hello!"
+    #         request.redirect
+    #       end
+    #     end
+    #   end
+    #
+    # When using the the class_level_routing plugin with nested routes, you may also want to use the
+    # delegate plugin to delegate certain instance methods to the request object, so you don't have
+    # to continually use +request.+ in your routing blocks.
+    #
+    # Note that class level routing is implemented via a simple array of routes, so routing performance
+    # will degrade linearly as the number of routes increases.  For best performance, you should use
+    # the normal +route+ class method to define your routing tree.  This plugin does make it simpler to
+    # add additional routes after the routing tree has already been defined, though.
+    module ClassLevelRouting
+      # Initialize the class_routes array when the plugin is loaded.  Also, if the application doesn't
+      # currently have a routing block, setup an empty routing block so that things will still work if
+      # a routing block isn't added.
+      def self.configure(app)
+        app.route{} unless app.route_block
+        app.opts[:class_level_routes] ||= []
+      end
+
+      module ClassMethods
+        # Define routing methods that will store class level routes.
+        [:root, :on, :is, :get, :post, :delete, :head, :options, :link, :patch, :put, :trace, :unlink].each do |meth|
+          define_method(meth) do |*args, &block|
+            opts[:class_level_routes] << [meth, args, block]
+          end
+        end
+      end
+
+      module InstanceMethods
+        private
+
+        # If the normal routing tree doesn't handle an action, try each class level route
+        # to see if it matches.
+        def _route(&block)
+          result = super
+
+          if result[0] == 404 && (v = result[2]).is_a?(Array) && v.empty?
+            # Reset the response so it doesn't inherit the status or any headers from
+            # the original response.
+            @_response = self.class::RodaResponse.new
+            super do |r|
+              opts[:class_level_routes].each do |meth, args, blk|
+                r.send(meth, *args) do |*a|
+                  instance_exec(*a, &blk)
+                end
+              end
+            end
+          else
+            result
+          end
+        end
+      end
+    end
+
+    register_plugin(:class_level_routing, ClassLevelRouting)
+  end
+end

data/lib/roda/plugins/content_for.rb

@@ -21,6 +21,12 @@ class Roda
     #
     #   <%= content_for :foo %>
     module ContentFor
+      # Depend on the render plugin, since this plugin only makes
+      # sense when the render plugin is used.
+      def self.load_dependencies(app)
+        app.plugin :render
+      end
+
       module InstanceMethods
         # If called with a block, store content enclosed by block
         # under the given key.  If called without a block, retrieve

data/lib/roda/plugins/default_headers.rb

@@ -20,27 +20,20 @@ class Roda
     module DefaultHeaders
       # Merge the given headers into the existing default headers, if any.
       def self.configure(app, headers={})
-        app.instance_eval do
-          @default_headers ||= {}
-          @default_headers.merge!(headers)
-        end
+        (app.opts[:default_headers] ||= {}).merge!(headers)
       end 
 
       module ClassMethods
         # The default response headers to use for the current class.
-        attr_reader :default_headers
-
-        # Copy the default headers into the subclass when inheriting.
-        def inherited(subclass)
-          super
-          subclass.instance_variable_set(:@default_headers, default_headers.dup)
+        def default_headers
+          opts[:default_headers]
         end
       end
 
       module ResponseMethods
         # Get the default headers from the related roda class.
         def default_headers
-          self.class.roda_class.default_headers.dup
+          roda_class.default_headers.dup
         end
       end
     end

data/lib/roda/plugins/delay_build.rb

@@ -0,0 +1,42 @@
+class Roda
+  module RodaPlugins
+    # The delay_build plugin does not build the rack app until
+    # Roda.app is called, and only rebuilds the rack app if Roda.build!
+    # is called.  This differs from Roda's default behavior, which
+    # rebuilds the rack app every time the route block changes and
+    # every time middleware is added if a route block has already
+    # been defined.
+    #
+    # If you are loading hundreds of middleware after a
+    # route block has already been defined, this can fix a possible
+    # performance issue, turning an O(n^2) calculation into an
+    # O(n) calculation, where n is the number of middleware used.
+    module DelayBuild
+      module ClassMethods
+        # If the app is not been defined yet, build the app.
+        def app
+          @app || build!
+        end
+
+        # Rebuild the application.
+        def build!
+          @build_app = true
+          build_rack_app
+          @app
+        ensure
+          @build_app = false
+        end
+
+        private
+
+        # Do not build the rack app automatically, wait for an
+        # explicit call to build!.
+        def build_rack_app
+          super if @build_app
+        end
+      end
+    end
+
+    register_plugin(:delay_build, DelayBuild)
+  end
+end

data/lib/roda/plugins/delegate.rb

@@ -0,0 +1,64 @@
+class Roda
+  module RodaPlugins
+    # The delegate plugin allows you to easily setup instance methods in
+    # the scope of the route block that call methods on the related
+    # request or response, which may offer a simpler API in some cases.
+    # Roda doesn't automatically setup such delegate methods because
+    # it pollutes the application's method namespace, but this plugin
+    # allows the user to do so.
+    #
+    # Here's an example based on the README's initial example, using the
+    # request_delegate method to simplify the DSL:
+    #
+    #   plugin :delegate
+    #   request_delegate :root, :on, :is, :get, :post, :redirect
+    #
+    #   route do |r|
+    #     # GET / request
+    #     root do
+    #       redirect "/hello"
+    #     end
+    #
+    #     # /hello branch
+    #     on "hello" do
+    #       # GET /hello/world request
+    #       get "world" do
+    #         "Hello world!"
+    #       end
+    #
+    #       # /hello request
+    #       is do
+    #         # GET /hello request
+    #         get do
+    #           "Hello!"
+    #         end
+    #
+    #         # POST /hello request
+    #         post do
+    #           puts "Someone said hello!"
+    #           redirect
+    #         end
+    #       end
+    #     end
+    #   end
+    module Delegate
+      module ClassMethods
+        # Delegate the given methods to the request
+        def request_delegate(*meths)
+          meths.each do |meth|
+            define_method(meth){|*a, &block| @_request.send(meth, *a, &block)}
+          end
+        end
+
+        # Delegate the given methods to the response
+        def response_delegate(*meths)
+          meths.each do |meth|
+            define_method(meth){|*a, &block| @_response.send(meth, *a, &block)}
+          end
+        end
+      end
+    end
+
+    register_plugin(:delegate, Delegate)
+  end
+end

data/lib/roda/plugins/drop_body.rb

@@ -0,0 +1,33 @@
+class Roda
+  module RodaPlugins
+    # The drop_body plugin automatically drops the body and
+    # Content-Type/Content-Length headers from the response if
+    # the response status indicates that the response should
+    # not include a body (response statuses 100, 101, 102, 204, 205,
+    # and 304).
+    module DropBody
+      module ResponseMethods
+        DROP_BODY_STATUSES = [100, 101, 102, 204, 205, 304].freeze
+        EMPTY_BODY = [].freeze
+        CONTENT_LENGTH = "Content-Length".freeze
+        CONTENT_TYPE = "Content-Type".freeze
+
+        # If the response status indicates a body should not be
+        # returned, use an empty body and remove the Content-Length
+        # and Content-Type headers.
+        def finish
+          r = super
+          if DROP_BODY_STATUSES.include?(r[0])
+            r[2] = EMPTY_BODY
+            h = r[1]
+            h.delete(CONTENT_LENGTH)
+            h.delete(CONTENT_TYPE)
+          end
+          r
+        end
+      end
+    end
+
+    register_plugin(:drop_body, DropBody)
+  end
+end

data/lib/roda/plugins/empty_root.rb

@@ -0,0 +1,48 @@
+class Roda
+  module RodaPlugins
+    # The empty_root plugin makes +r.root+ match both on +/+ and
+    # on the empty string.  This is mostly useful when using multiple
+    # rack applications, where the initial PATH_INFO has been moved
+    # to SCRIPT_NAME.  For example, if you have the following
+    # applications:
+    #
+    #   class App1 < Roda
+    #     on "albums" do
+    #       run App2
+    #     end
+    #   end
+    #
+    #   class App2 < Roda
+    #     plugin :empty_root
+    #
+    #     route do |r|
+    #       r.root do
+    #         "root"
+    #       end
+    #     end
+    #   end
+    #
+    # Then requests for both +/albums/+ and +/albums+ will return
+    # "root".  Without this plugin loaded into App2, only requests
+    # for +/albums/+ will return "root", since by default, +r.root+
+    # matches only when the current PATH_INFO is +/+ and not when
+    # it is empty.
+    module EmptyRoot
+      EMPTY_STRING = ''.freeze
+
+      module RequestMethods
+        # Match when the remaining path is the empty string,
+        # in addition to the default behavior of matching when
+        # the remaining path is +/+.
+        def root(&block)
+          super
+          if remaining_path == EMPTY_STRING && is_get?
+            always(&block)
+          end
+        end
+      end
+    end
+
+    register_plugin(:empty_root, EmptyRoot)
+  end
+end