roda 1.1.0 → 1.2.0

data/lib/roda/plugins/render.rb

@@ -25,18 +25,19 @@ class Roda
     # The following options are supported:
     #
     # :cache :: nil/false to not cache templates (useful for development), defaults
-    #           to true to automatically use the default template cache.
+    #           to true unless RACK_ENV is development to automatically use the
+    #           default template cache.
     # :engine :: The tilt engine to use for rendering, defaults to 'erb'.
     # :escape :: Use Roda's Erubis escaping support, which makes <%= %> escape output,
-    #            <%== %> not escape output, and handles postfix conditions inside
-    #            <%= %> tags.
+    #            <tt><%== %></tt> not escape output, and handles postfix conditions inside
+    #            <tt><%= %></tt> tags.
     # :ext :: The file extension to assume for view files, defaults to the :engine
     #         option.
     # :layout :: The base name of the layout file, defaults to 'layout'.
     # :layout_opts :: The options to use when rendering the layout, if different
     #                 from the default options.
     # :opts :: The tilt options used when rendering templates, defaults to
-    #          {:outvar=>'@_out_buf'}.
+    #          <tt>{:outvar=>'@_out_buf', :default_encoding=>Encoding.default_external}</tt>.
     # :views :: The directory holding the view files, defaults to 'views' in the
     #           current directory.
     #
@@ -58,6 +59,13 @@ class Roda
     # :path :: Use the value given as the full pathname for the file, instead
     #          of using the :views and :ext option in combination with the
     #          template name.
+    # :template :: Provides the name of the template to use.  This allows you
+    #              pass a single options hash to the render/view method, while
+    #              still allowing you to specify the template name.
+    # :template_block :: Pass this block when creating the underlying template,
+    #                    ignored when using :inline.
+    # :template_class :: Provides the template class to use, inside of using
+    #                    Tilt or a Tilt[:engine].
     #
     # Here's how those options are used:
     #
@@ -89,15 +97,21 @@ class Roda
         opts[:views] ||= File.expand_path("views", Dir.pwd)
         opts[:layout] = "layout" unless opts.has_key?(:layout)
         opts[:layout_opts] ||= (opts[:layout_opts] || {}).dup
+
+        if layout = opts[:layout]
+          layout = {:template=>layout} unless layout.is_a?(Hash)
+          opts[:layout_opts] = opts[:layout_opts].merge(layout)
+        end
+
         opts[:opts] ||= (opts[:opts] || {}).dup
         opts[:opts][:outvar] ||= '@_out_buf'
-        if RUBY_VERSION >= "1.9"
-          opts[:opts][:default_encoding] ||= Encoding.default_external
+        if RUBY_VERSION >= "1.9" && !opts[:opts].has_key?(:default_encoding)
+          opts[:opts][:default_encoding] = Encoding.default_external
         end
         if opts[:escape]
           opts[:opts][:engine_class] = ErubisEscaping::Eruby
         end
-        opts[:cache] = app.thread_safe_cache if opts.fetch(:cache, true)
+        opts[:cache] = app.thread_safe_cache if opts.fetch(:cache, ENV['RACK_ENV'] != 'development')
       end
 
       module ClassMethods
@@ -106,7 +120,7 @@ class Roda
         # affecting the parent class.
         def inherited(subclass)
           super
-          opts = subclass.opts[:render] = render_opts.dup
+          opts = subclass.opts[:render]
           opts[:layout_opts] = opts[:layout_opts].dup
           opts[:opts] = opts[:opts].dup
           opts[:cache] = thread_safe_cache if opts[:cache]
@@ -121,28 +135,11 @@ class Roda
       module InstanceMethods
         # Render the given template. See Render for details.
         def render(template, opts = OPTS, &block)
-          if template.is_a?(Hash)
-            if opts.empty?
-              opts = template
-            else
-              opts = opts.merge(template)
-            end
-          end
-          render_opts = render_opts()
-
-          if content = opts[:inline]
-            path = content
-            template_block = Proc.new{content}
-            template_class = ::Tilt[opts[:engine] || render_opts[:engine]]
-          else
-            template_class = ::Tilt
-            unless path = opts[:path]
-              path = template_path(template, opts)
-            end
-          end
-
-          cached_template(path) do
-            template_class.new(path, 1, render_opts[:opts].merge(opts), &template_block)
+          opts = find_template(parse_template_opts(template, opts))
+          cached_template(opts) do
+            template_opts = render_opts[:opts]
+            template_opts = template_opts.merge(opts[:opts]) if opts[:opts]
+            opts[:template_class].new(opts[:path], 1, template_opts, &opts[:template_block])
           end.render(self, (opts[:locals]||OPTS), &block)
         end
 
@@ -157,22 +154,16 @@ class Roda
         # for the class, take the result of the template rendering
         # and render it inside the layout.  See Render for details.
         def view(template, opts=OPTS)
-          if template.is_a?(Hash)
-            if opts.empty?
-              opts = template
-            else
-              opts = opts.merge(template)
-            end
-          end
+          opts = parse_template_opts(template, opts)
+          content = opts[:content] || render(opts)
 
-          content = opts[:content] || render(template, opts)
-
-          if layout = opts.fetch(:layout, render_opts[:layout])
-            if layout_opts = opts[:layout_opts]
-              layout_opts = render_opts[:layout_opts].merge(layout_opts)
+          if layout = opts.fetch(:layout, (OPTS if render_opts[:layout]))
+            layout_opts = render_opts[:layout_opts] 
+            if opts[:layout_opts]
+              layout_opts = opts[:layout_opts].merge(layout_opts)
             end
 
-            content = render(layout, layout_opts||OPTS){content}
+            content = render(layout, layout_opts){content}
           end
 
           content
@@ -182,10 +173,11 @@ class Roda
 
         # If caching templates, attempt to retrieve the template from the cache.  Otherwise, just yield
         # to get the template.
-        def cached_template(path, &block)
+        def cached_template(opts, &block)
           if cache = render_opts[:cache]
-            unless template = cache[path]
-              template = cache[path] = yield
+            key = opts[:key]
+            unless template = cache[key]
+              template = cache[key] = yield
             end
             template
           else
@@ -193,10 +185,49 @@ class Roda
           end
         end
 
+        # Given the template name and options, return the template class, template path/content,
+        # and template block to use for the render.
+        def find_template(opts)
+          if content = opts[:inline]
+            path = opts[:path] = content
+            template_class = opts[:template_class] ||= ::Tilt[opts[:engine] || render_opts[:engine]]
+            opts[:template_block] = Proc.new{content}
+          else
+            path = opts[:path] ||= template_path(opts)
+            template_class = opts[:template_class]
+            opts[:template_class] ||= ::Tilt
+          end
+
+          if render_opts[:cache]
+            template_opts = opts[:opts]
+            template_block = opts[:template_block] if !content
+
+            key = if template_class || template_opts || template_block
+              [path, template_class, template_opts, template_block]
+            else
+              path
+            end
+            opts[:key] = key
+          end
+
+          opts
+        end
+
+        # Return a single hash combining the template and opts arguments.
+        def parse_template_opts(template, opts)
+          template = {:template=>template} unless template.is_a?(Hash)
+          opts.merge(template)
+        end
+
+        # The name to use for the template.  By default, just converts the :template option to a string.
+        def template_name(opts)
+          opts[:template].to_s
+        end
+
         # The path for the given template.
-        def template_path(template, opts)
+        def template_path(opts)
           render_opts = render_opts()
-          "#{opts[:views] || render_opts[:views]}/#{template}.#{opts[:ext] || render_opts[:ext] || render_opts[:engine]}"
+          "#{opts[:views] || render_opts[:views]}/#{template_name(opts)}.#{opts[:ext] || render_opts[:ext] || render_opts[:engine]}"
         end
       end
     end

data/lib/roda/plugins/render_each.rb

@@ -23,6 +23,12 @@ class Roda
     # the template will be +bar+.  You can use <tt>:local=>nil</tt> to
     # not set a local variable inside the template.
     module RenderEach
+      # Load the render plugin before this plugin, since this plugin
+      # calls the render method.
+      def self.load_dependencies(app)
+        app.plugin :render
+      end
+
       module InstanceMethods
         # For each value in enum, render the given template using the
         # given opts.  The template and options hash are passed to +render+.

data/lib/roda/plugins/sinatra_helpers.rb

@@ -0,0 +1,523 @@
+class Roda
+  module RodaPlugins
+    # The sinatra_helpers plugin ports most of the helper methods
+    # defined in Sinatra::Helpers to Roda, other than those
+    # helpers that were already covered by other plugins such
+    # as caching and streaming.
+    #
+    # Unlike Sinatra, the helper methods are added to either
+    # the request or response classes instead of directly to
+    # the scope of the route block.  However, for consistency
+    # with Sinatra, delegate methods are added to the scope
+    # of the route block that call the methods on the request
+    # or response.  If you do not want to pollute the namespace
+    # of the route block, you should load the plugin with the
+    # :delegate => false option:
+    #
+    #   plugin :sinatra_helpers, :delegate=>false
+    #
+    # == Class Methods Added
+    #
+    # The only class method added by this plugin is +mime_type+,
+    # which is a shortcut for retrieving or setting MIME types
+    # in Rack's MIME database:
+    #
+    #   Roda.mime_type 'csv' # => 'text/csv'
+    #   Roda.mime_type 'foobar', 'application/foobar' # set
+    #
+    # == Request Methods Added 
+    #
+    # In addition to adding the following methods, this changes
+    # +redirect+ to use a 303 response status code by default for
+    # HTTP 1.1 non-GET requests, and to automatically use
+    # absolute URIs if the +:absolute_redirects+ Roda class option
+    # is true, and to automatically prefix redirect paths with the
+    # script name if the +:prefixed_redirects+ Roda class option is
+    # true.
+    #
+    # When adding delegate methods, a logger method is added to
+    # the route block scope that calls the logger method on the request.
+    # 
+    # === back
+    #
+    # +back+ is an alias to referrer, so you can do:
+    #
+    #   redirect back
+    #
+    # === error
+    #
+    # +error+ sets the response status code to 500 (or a status code you provide),
+    # and halts the request.  It takes an optional body:
+    #
+    #   error           # 500 response, empty boby
+    #   error 501       # 501 reponse, empty body
+    #   error 'b'       # 500 response, 'b' body
+    #   error 501, 'b'  # 501 response, 'b' body
+    #
+    # === not_found
+    #
+    # +not_found+ sets the response status code to 404 and halts the request.
+    # It takes an optional body:
+    #
+    #   not_found      # 404 response, empty body
+    #   not_found 'b'  # 404 response, 'b' body
+    #
+    # === uri
+    #
+    # +uri+ by default returns absolute URIs that are prefixed
+    # by the script name:
+    #
+    #   request.script_name # => '/foo'
+    #   uri '/bar'          # => 'http://example.org/foo/bar'
+    #
+    # You can turn of the absolute or script name prefixing if you want:
+    #
+    #   uri '/bar', false        # => '/foo/bar'
+    #   uri '/bar', true, false  # => 'http://example.org/bar'
+    #   uri '/bar', false, false # => '/bar'
+    #
+    # This method is aliased as +url+ and +to+.
+    #
+    # === send_file
+    #
+    # This will serve the file with the given path from the file system:
+    #
+    #   send_file 'path/to/file.txt'
+    #
+    # Options:
+    #
+    # :disposition :: Set the Content-Disposition to the given disposition.
+    # :filename :: Set the Content-Disposition to attachment (unless :disposition is set),
+    #              and set the filename parameter to the value.
+    # :last_modified :: Explicitly set the Last-Modified header to the given value, and
+    #                   return a not modified response if there has not been modified since
+    #                   the previous request.  This option requires the caching plugin.
+    # :status :: Override the status for the response.
+    # :type :: Set the Content-Type to use for this response.
+    #
+    # == Response Methods Added
+    #
+    # === body
+    #
+    # When called with an argument or block, +body+ sets the body, otherwise
+    # it returns the body:
+    #
+    #   body      # => []
+    #   body('b') # set body to 'b'
+    #   body{'b'} # set body to 'b', but don't call until body is needed
+    #
+    # === body=
+    #
+    # +body+ sets the body to the given value:
+    #
+    #   response.body = 'v'
+    #
+    # This method is not delegated to the scope of the route block,
+    # call +body+ with an argument to set the value.
+    #
+    # === status
+    #
+    # When called with an argument, +status+ sets the status, otherwise
+    # it returns the status:
+    #
+    #   status      # => 200
+    #   status(301) # sets status to 301
+    #
+    # === headers
+    #
+    # When called with an argument, +headers+ merges the given headers
+    # into the current headers, otherwise it returns the headers:
+    #
+    #   headers['Foo'] = 'Bar'
+    #   headers 'Foo' => 'Bar'
+    #
+    # === mime_type
+    #
+    # +mime_type+ just calls the Roda class method to get the mime_type.
+    #
+    # === content_type
+    #
+    # When called with an argument, +content_type+ sets the Content-Type
+    # based on the argument, otherwise it returns the Content-Type.
+    #
+    #   mime_type             # => 'text/html'
+    #   mime_type 'csv'       # set Content-Type to 'text/csv'
+    #   mime_type :csv        # set Content-Type to 'text/csv'
+    #   mime_type '.csv'      # set Content-Type to 'text/csv'
+    #   mime_type 'text/csv'  # set Content-Type to 'text/csv'
+    #
+    # Options:
+    #
+    # :charset :: Set the charset for the mime type to the given charset, if the charset is
+    #             not already set in the mime type.
+    # :default :: Uses the given type if the mime type is not known.  If this option is not
+    #             used and the mime type is not known, an exception will be raised.
+    #
+    # === attachment
+    #
+    # When called with no filename, +attachment+ just sets the Content-Disposition
+    # to attachment.  When called with a filename, this sets the Content-Disposition
+    # to attachment with the appropriate filename parameter, and if the filename
+    # extension is recognized, this also sets the Content-Type to the appropriate
+    # MIME type if not already set.
+    #
+    #   attachment          # set Content-Disposition to 'attachment'
+    #   attachment 'a.csv'  # set Content-Disposition to 'attachment;filename="a.csv"',
+    #                       # also set Content-Type to 'text/csv'
+    #
+    # === status predicates
+    #
+    # This adds the following predicate methods for checking the status:
+    #
+    #   informational?  # 100-199
+    #   success?        # 200-299
+    #   redirect?       # 300-399
+    #   client_error?   # 400-499
+    #   not_found?      # 404
+    #   server_error?   # 500-599
+    #
+    # If the status has not yet been set for the response, these will
+    # return +nil+.
+    #
+    # == License
+    #
+    # The implementation was originally taken from Sinatra,
+    # which is also released under the MIT License:
+    #
+    # Copyright (c) 2007, 2008, 2009 Blake Mizerany
+    # Copyright (c) 2010, 2011, 2012, 2013, 2014 Konstantin Haase
+    # 
+    # Permission is hereby granted, free of charge, to any person
+    # obtaining a copy of this software and associated documentation
+    # files (the "Software"), to deal in the Software without
+    # restriction, including without limitation the rights to use,
+    # copy, modify, merge, publish, distribute, sublicense, and/or sell
+    # copies of the Software, and to permit persons to whom the
+    # Software is furnished to do so, subject to the following
+    # conditions:
+    # 
+    # The above copyright notice and this permission notice shall be
+    # included in all copies or substantial portions of the Software.
+    # 
+    # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+    # OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+    # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+    # HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+    # WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+    # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+    # OTHER DEALINGS IN THE SOFTWARE.
+    module SinatraHelpers
+      CONTENT_TYPE = "Content-Type".freeze
+      CONTENT_DISPOSITION = "Content-Disposition".freeze
+      CONTENT_LENGTH = "Content-Length".freeze
+      OCTET_STREAM = 'application/octet-stream'.freeze
+      ATTACHMENT = 'attachment'.freeze
+      HTTP_VERSION = 'HTTP_VERSION'.freeze
+      HTTP11 = "HTTP/1.1".freeze
+      HTTP_X_FORWARDED_HOST = "HTTP_X_FORWARDED_HOST".freeze
+      EMPTY_STRING = ''.freeze
+      SLASH = '/'.freeze
+      SEMICOLON = ';'.freeze
+      COMMA = ', '.freeze
+      CHARSET = 'charset'.freeze
+      OPTS = {}.freeze
+
+      # Add delegate methods to the route block scope
+      # calling request or response methods, unless the
+      # :delegate option is false.
+      def self.configure(app, opts=OPTS)
+        app.send(:include, DelegateMethods) unless opts[:delegate] == false
+      end
+
+      # Class used when the response body is set explicitly, instead
+      # of using Roda's default body array and response.write to
+      # write to it.
+      class DelayedBody
+        # Save the block that will return the body, it won't be
+        # called until the body is needed.
+        def initialize(&block)
+          @block = block
+        end
+
+        # If the body is a String, yield it, otherwise yield each string
+        # returned by calling each on the body.
+        def each
+          v = value
+          if v.is_a?(String)
+            yield v
+          else
+            v.each{|s| yield s}
+          end
+        end
+
+        # Assume that if the body has been set directly that it is
+        # never empty.
+        def empty?
+          false
+        end
+
+        # Return the body as a single string, mostly useful during testing.
+        def join
+          a = []
+          each{|s| a << s}
+          a.join
+        end
+
+        # Calculate the length for the body.
+        def length
+          length = 0
+          each{|s| length += s.bytesize}
+          length
+        end
+
+        private
+
+        # Cache the body returned by the block.  This way the block won't
+        # be called multiple times.
+        def value
+          @value ||= @block.call
+        end
+      end
+
+      module RequestMethods
+        # Alias for referrer
+        def back
+          referrer
+        end
+
+        # Halt processing and return the error status provided with the given code and
+        # optional body.
+        # If a single argument is given and it is not an integer, consider it the body
+        # and use a 500 status code.
+        def error(code=500, body = nil)
+          unless code.is_a?(Integer)
+            body = code
+            code = 500
+          end
+
+          response.status = code
+          response.body = body if body
+          halt
+        end
+
+        # Halt processing and return a 404 response with an optional body.
+        def not_found(body = nil)
+          error(404, body)
+        end
+
+        # If the absolute_redirects or :prefixed_redirects roda class options has been set, respect those
+        # and update the path.
+        def redirect(path=(no_add_script_name = true; default_redirect_path), status=default_redirect_status)
+          opts = roda_class.opts
+          absolute_redirects = opts[:absolute_redirects]
+          prefixed_redirects = no_add_script_name ? false : opts[:prefixed_redirects]
+          path = uri(path, absolute_redirects, prefixed_redirects) if absolute_redirects || prefixed_redirects
+          super(path, status)
+        end
+
+        # Use the contents of the file at +path+ as the response body.  See plugin documentation for options.
+        def send_file(path, opts = OPTS)
+          res = response
+          headers = res.headers
+          if opts[:type] || !headers[CONTENT_TYPE]
+            res.content_type(opts[:type] || ::File.extname(path), :default => OCTET_STREAM)
+          end
+
+          disposition = opts[:disposition]
+          filename    = opts[:filename]
+          if disposition || filename
+            disposition ||= ATTACHMENT
+            filename = path if filename.nil?
+            res.attachment(filename, disposition)
+          end
+
+          if lm = opts[:last_modified]
+            last_modified(lm)
+          end
+
+          file      = ::Rack::File.new nil
+          file.path = path
+          s, h, b   = file.serving(@env)
+
+          res.status = opts[:status] || s
+          headers.delete(CONTENT_LENGTH)
+          headers.replace(h.merge!(headers))
+          res.body = b
+
+          halt
+        rescue Errno::ENOENT
+          not_found
+        end
+
+        # Generates the absolute URI for a given path in the app.
+        # Takes Rack routers and reverse proxies into account.
+        def uri(addr = nil, absolute = true, add_script_name = true)
+          addr = addr.to_s if addr
+          return addr if addr =~ /\A[A-z][A-z0-9\+\.\-]*:/
+          uri = if absolute
+            h = if @env.has_key?(HTTP_X_FORWARDED_HOST) || port != (ssl? ? 443 : 80)
+              host_with_port
+            else
+              host
+            end
+            ["http#{'s' if ssl?}://#{h}"]
+          else
+            [EMPTY_STRING]
+          end
+          uri << script_name.to_s if add_script_name
+          uri << (addr || path_info)
+          File.join(uri)
+        end
+        alias url uri
+        alias to uri
+
+        private
+
+        # Use a 303 response for non-GET responses if client uses HTTP 1.1.
+        def default_redirect_status
+          if @env[HTTP_VERSION] == HTTP11 && !is_get?
+            303
+          else
+            super
+          end
+        end
+      end
+
+      module ResponseMethods
+        # Set or retrieve the response status code.
+        def status(value = (return @status; nil))
+          @status = value
+        end
+
+        # Set or retrieve the response body. When a block is given,
+        # evaluation is deferred until the body is needed.
+        def body(value = (return @body unless block_given?; nil), &block)
+          if block
+            @body = DelayedBody.new(&block)
+          else
+            self.body = value
+          end
+        end
+
+        # Set the body to the given value.
+        def body=(body)
+          @body = DelayedBody.new{body}
+        end
+
+        # If the body is a DelayedBody, set the appropriate length for it.
+        def finish
+          @length = @body.length if @body.is_a?(DelayedBody) && !@headers[CONTENT_LENGTH]
+          super
+        end
+
+        # Set multiple response headers with Hash, or return the headers if no
+        # argument is given.
+        def headers(hash = (return @headers; nil))
+          @headers.merge!(hash)
+        end
+
+        # Look up a media type by file extension in Rack's mime registry.
+        def mime_type(type)
+          roda_class.mime_type(type)
+        end
+
+        # Set the Content-Type of the response body given a media type or file
+        # extension.  See plugin documentation for options.
+        def content_type(type = (return @headers[CONTENT_TYPE]; nil), opts = OPTS)
+          unless (mime_type = mime_type(type) || opts[:default])
+            raise RodaError, "Unknown media type: #{type}"
+          end
+
+          unless opts.empty?
+            opts.each do |key, val|
+              next if key == :default || (key == :charset && mime_type.include?(CHARSET))
+              val = val.inspect if val =~ /[";,]/
+              mime_type += "#{mime_type.include?(SEMICOLON) ? COMMA : SEMICOLON}#{key}=#{val}"
+            end
+          end
+
+          @headers[CONTENT_TYPE] = mime_type
+        end
+
+        # Set the Content-Disposition to "attachment" with the specified filename,
+        # instructing the user agents to prompt to save.
+        def attachment(filename = nil, disposition=ATTACHMENT)
+          if filename
+            params = "; filename=#{File.basename(filename).inspect}"
+            unless @headers[CONTENT_TYPE]
+              ext = File.extname(filename)
+              unless ext.empty?
+                content_type(ext)
+              end
+            end
+          end
+          @headers[CONTENT_DISPOSITION] = "#{disposition}#{params}"
+        end
+
+        # Whether or not the status is set to 1xx. Returns nil if status not yet set.
+        def informational?
+          @status.between?(100, 199) if @status
+        end
+
+        # Whether or not the status is set to 2xx. Returns nil if status not yet set.
+        def success?
+          @status.between?(200, 299) if @status
+        end
+
+        # Whether or not the status is set to 3xx. Returns nil if status not yet set.
+        def redirect?
+          @status.between?(300, 399) if @status
+        end
+
+        # Whether or not the status is set to 4xx. Returns nil if status not yet set.
+        def client_error?
+          @status.between?(400, 499) if @status
+        end
+
+        # Whether or not the status is set to 5xx. Returns nil if status not yet set.
+        def server_error?
+          @status.between?(500, 599) if @status
+        end
+
+        # Whether or not the status is set to 404. Returns nil if status not yet set.
+        def not_found?
+          @status == 404 if @status
+        end
+      end
+
+      module ClassMethods
+        # If a type and value are given, set the value in Rack's MIME registry.
+        # If only a type is given, lookup the type in Rack's MIME registry and
+        # return it.
+        def mime_type(type=(return; nil), value = nil)
+          return type.to_s if type.to_s.include?(SLASH)
+          type = ".#{type}" unless type.to_s[0] == ?.
+          if value
+            Rack::Mime::MIME_TYPES[type] = value
+          else
+            Rack::Mime.mime_type(type, nil)
+          end
+        end
+      end
+
+      module DelegateMethods
+        [:logger, :back].each do |meth|
+          define_method(meth){@_request.send(meth)}
+        end
+        [:redirect, :uri, :url, :to, :send_file, :error, :not_found].each do |meth|
+          define_method(meth){|*v, &block| @_request.send(meth, *v, &block)}
+        end
+
+        [:informational?, :success?, :redirect?, :client_error?, :server_error?, :not_found?].each do |meth|
+          define_method(meth){@_response.send(meth)}
+        end
+        [:status, :body, :headers, :mime_type, :content_type, :attachment].each do |meth|
+          define_method(meth){|*v, &block| @_response.send(meth, *v, &block)}
+        end
+      end
+    end
+
+    register_plugin(:sinatra_helpers, SinatraHelpers)
+  end
+end