roda 2.29.0 → 3.0.0

data/lib/roda/plugins/render_each.rb

@@ -15,20 +15,17 @@ class Roda
     #
     # You can pass additional render options via an options hash:
     #
-    #   render_each([1,2,3], :foo, :views=>'partials')
+    #   render_each([1,2,3], :foo, views: 'partials')
     #
     # One additional option supported by is +:local+, which sets the
     # local variable containing the current value to use.  So:
     #
-    #   render_each([1,2,3], :foo, :local=>:bar)
+    #   render_each([1,2,3], :foo, local: :bar)
     #
     # Will render the +foo+ template, but the local variable used inside
-    # the template will be +bar+.  You can use <tt>:local=>nil</tt> to
+    # the template will be +bar+.  You can use <tt>local: nil</tt> to
     # not set a local variable inside the template.
     module RenderEach
-      OPTS = {}.freeze
-      RodaPlugins.deprecate_constant(self, :OPTS)
-
       # Load the render plugin before this plugin, since this plugin
       # calls the render method.
       def self.load_dependencies(app)
@@ -42,7 +39,7 @@ class Roda
         # :local :: The local variable to use for the current enum value
         #           inside the template.  An explicit +nil+ value does not
         #           set a local variable.  If not set, uses the template name.
-        def render_each(enum, template, opts=RodaPlugins::OPTS)
+        def render_each(enum, template, opts=OPTS)
           if as = opts.has_key?(:local)
             as = opts[:local]
           else

data/lib/roda/plugins/render_locals.rb

@@ -5,15 +5,15 @@ class Roda
   module RodaPlugins
     # The render_locals plugin allows setting default locals for rendering templates.
     #
-    #   plugin :render_locals, :render=>{:heading=>'Hello'}
+    #   plugin :render_locals, render: {heading: 'Hello'}
     #
     #   route do |r|
     #     r.get "foo" do
-    #       view 'foo', :locals=>{:name=>'Foo'} # locals: {:heading=>'Hello', :name=>'Foo'}
+    #       view 'foo', locals: {name: 'Foo'} # locals: {:heading=>'Hello', :name=>'Foo'}
     #     end
     #
     #     r.get "bar" do
-    #       view 'foo', :locals=>{:heading=>'Bar'} # locals: {:heading=>'Bar'}
+    #       view 'foo', locals: {heading: 'Bar'} # locals: {:heading=>'Bar'}
     #     end
     #
     #     view "default" # locals: {:heading=>'Hello'}
@@ -25,14 +25,11 @@ class Roda
     # layout :: The default locals to use for layout rendering
     # merge :: Whether to merge template locals into layout locals
     module RenderLocals
-      OPTS = {}.freeze
-      RodaPlugins.deprecate_constant(self, :OPTS)
-
-      def self.load_dependencies(app, opts=RodaPlugins::OPTS)
+      def self.load_dependencies(app, opts=OPTS)
         app.plugin :render
       end
 
-      def self.configure(app, opts=RodaPlugins::OPTS)
+      def self.configure(app, opts=OPTS)
         app.opts[:render_locals] = (app.opts[:render_locals] || {}).merge(opts[:render]||{}).freeze
         app.opts[:layout_locals] = (app.opts[:layout_locals] || {}).merge(opts[:layout]||{}).freeze
         if opts.has_key?(:merge)
@@ -52,11 +49,6 @@ class Roda
           opts[:layout_locals]
         end
 
-        # RODA3: Remove
-        def render_plugin_handle_locals?
-          false
-        end
-
         # If this isn't the layout template, then use the plugin's render locals as the default locals.
         def render_template_opts(template, opts)
           opts = super
@@ -76,12 +68,7 @@ class Roda
             merge_locals = layout_opts.has_key?(:merge_locals) ? layout_opts[:merge_locals] : self.opts[:merge_locals] 
 
             locals = {}
-            if merge_locals && (plugin_locals = render_locals)
-              locals.merge!(plugin_locals)
-            end
-            if layout_locals = layout_locals()
-              locals.merge!(layout_locals)
-            end
+            locals.merge!(layout_locals)
             if merge_locals && (method_locals = opts[:locals])
               locals.merge!(method_locals)
             end
@@ -90,7 +77,6 @@ class Roda
             end
 
             layout_opts[:locals] = locals
-            layout_opts[:_is_layout] = true
             layout_opts
           end
         end

data/lib/roda/plugins/request_headers.rb

@@ -19,16 +19,14 @@ class Roda
     #
     #   r.headers['X-My-Header']
     #
-    # The name is actually case-insensitive so x-my-header will work as well.
-    #
+    # The name is actually case-insensitive so <tt>x-my-header</tt> will work as well.
     #
     # Example:
     #
     #   plugin :request_headers
-    #
     module RequestHeaders
       module RequestMethods
-        # Provide access to the request headers while normalising indexes.
+        # Provide access to the request headers while normalizing indexes.
         def headers
           @request_headers ||= Headers.new(@env)
         end

data/lib/roda/plugins/run_append_slash.rb

@@ -21,13 +21,10 @@ class Roda
     #   # GET /a => App gets "/" as PATH_INFO
     #   # GET /a/ => App gets "/" as PATH_INFO
     module RunAppendSlash
-      OPTS = {}.freeze
-      RodaPlugins.deprecate_constant(self, :OPTS)
-
       # Set plugin specific options.  Options:
       # :use_redirects :: Whether to issue 302 redirects when appending the
       #                   trailing slash.
-      def self.configure(app, opts=RodaPlugins::OPTS)
+      def self.configure(app, opts=OPTS)
         app.opts[:run_append_slash_redirect] = !!opts[:use_redirects]
       end
 

data/lib/roda/plugins/run_handler.rb

@@ -7,7 +7,7 @@ class Roda
     # the rack response array, before it returns it as a response.
     #
     # Additionally, r.run also takes a options hash, and you can provide a
-    # <tt>:not_found=>:pass</tt> option to keep routing normally if the rack
+    # <tt>not_found: :pass</tt> option to keep routing normally if the rack
     # app returns a 404 response.
     #
     #
@@ -16,7 +16,7 @@ class Roda
     #   route do |r|
     #     r.on 'a' do
     #       # Keep running code if RackAppFoo doesn't return a result
-    #       r.run RackAppFoo, :not_found=>:pass
+    #       r.run RackAppFoo, not_found: :pass
     #
     #       # Change response status codes before returning.
     #       r.run(RackAppBar) do |response|
@@ -25,17 +25,14 @@ class Roda
     #     end
     #   end
     module RunHandler
-      OPTS = {}.freeze
-      RodaPlugins.deprecate_constant(self, :OPTS)
-
       module RequestMethods
         # If a block is given, yield the rack response array to it.  The response can
         # be modified before it is returned by the current app.
         # 
-        # If the <tt>:not_found=>:pass</tt> option is given, and the rack response
+        # If the <tt>not_found: :pass</tt> option is given, and the rack response
         # returned by the app is a 404 response, do not return the response, continue
         # routing normally.
-        def run(app, opts=RodaPlugins::OPTS)
+        def run(app, opts=OPTS)
           res = catch(:halt){super(app)}
           yield res if block_given?
           throw(:halt, res) unless opts[:not_found] == :pass && res[0] == 404

data/lib/roda/plugins/shared_vars.rb

@@ -3,7 +3,7 @@
 #
 class Roda
   module RodaPlugins
-    # The shared_vars plugin adds a shared method for storing
+    # The shared_vars plugin adds a +shared+ method for storing
     # shared variables across nested Roda apps.
     #
     #   class API < Roda
@@ -30,7 +30,7 @@ class Roda
     #
     #   route do |r|
     #     r.on Integer do |user_id|
-    #       shared(:user => User[user_id])
+    #       shared(user: User[user_id])
     #       r.run API
     #     end
     #   end
@@ -41,15 +41,12 @@ class Roda
     #
     #   route do |r|
     #     r.on Integer do |user_id|
-    #       shared(:user => User[user_id]) do
+    #       shared(user: User[user_id]) do
     #         r.run API
     #       end
     #     end
     #   end
     module SharedVars
-      KEY = 'roda.shared'.freeze
-      RodaPlugins.deprecate_constant(self, :KEY)
-
       module InstanceMethods
         # Returns the current shared vars for the request.  These are
         # stored in the request's environment, so they will be implicitly

data/lib/roda/plugins/sinatra_helpers.rb

@@ -15,9 +15,9 @@ class Roda
     # 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:
+    # <tt>delegate: false</tt> option:
     #
-    #   plugin :sinatra_helpers, :delegate=>false
+    #   plugin :sinatra_helpers, delegate: false
     #
     # == Class Methods Added
     #
@@ -211,35 +211,6 @@ class Roda
     # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
     # OTHER DEALINGS IN THE SOFTWARE.
     module SinatraHelpers
-      OPTS = {}.freeze
-      RodaPlugins.deprecate_constant(self, :OPTS)
-      CONTENT_TYPE = "Content-Type".freeze
-      RodaPlugins.deprecate_constant(self, :CONTENT_TYPE)
-      CONTENT_DISPOSITION = "Content-Disposition".freeze
-      RodaPlugins.deprecate_constant(self, :CONTENT_DISPOSITION)
-      CONTENT_LENGTH = "Content-Length".freeze
-      RodaPlugins.deprecate_constant(self, :CONTENT_LENGTH)
-      OCTET_STREAM = 'application/octet-stream'.freeze
-      RodaPlugins.deprecate_constant(self, :OCTET_STREAM)
-      ATTACHMENT = 'attachment'.freeze
-      RodaPlugins.deprecate_constant(self, :ATTACHMENT)
-      HTTP_VERSION = 'HTTP_VERSION'.freeze
-      RodaPlugins.deprecate_constant(self, :HTTP_VERSION)
-      HTTP11 = "HTTP/1.1".freeze
-      RodaPlugins.deprecate_constant(self, :HTTP11)
-      HTTP_X_FORWARDED_HOST = "HTTP_X_FORWARDED_HOST".freeze
-      RodaPlugins.deprecate_constant(self, :HTTP_X_FORWARDED_HOST)
-      EMPTY_STRING = ''.freeze
-      RodaPlugins.deprecate_constant(self, :EMPTY_STRING)
-      SLASH = '/'.freeze
-      RodaPlugins.deprecate_constant(self, :SLASH)
-      SEMICOLON = ';'.freeze
-      RodaPlugins.deprecate_constant(self, :SEMICOLON)
-      COMMA = ', '.freeze
-      RodaPlugins.deprecate_constant(self, :COMMA)
-      CHARSET = 'charset'.freeze
-      RodaPlugins.deprecate_constant(self, :CHARSET)
-
       # Depend on the status_303 plugin.
       def self.load_dependencies(app, _opts = nil)
         app.plugin :status_303
@@ -248,7 +219,7 @@ class Roda
       # Add delegate methods to the route block scope
       # calling request or response methods, unless the
       # :delegate option is false.
-      def self.configure(app, opts=RodaPlugins::OPTS)
+      def self.configure(app, opts=OPTS)
         app.send(:include, DelegateMethods) unless opts[:delegate] == false
       end
 
@@ -339,7 +310,7 @@ class Roda
         end
 
         # Use the contents of the file at +path+ as the response body.  See plugin documentation for options.
-        def send_file(path, opts = RodaPlugins::OPTS)
+        def send_file(path, opts = OPTS)
           res = response
           headers = res.headers
           if opts[:type] || !headers["Content-Type"]
@@ -360,12 +331,12 @@ class Roda
 
           file = ::Rack::File.new nil
           s, h, b = if Rack.release > '2'
-            # :nocov:
             file.serving(self, path)
-            # :nocov:
           else
+            # :nocov:
             file.path = path
             file.serving(@env)
+            # :nocov:
           end
 
           res.status = opts[:status] || s
@@ -441,7 +412,7 @@ class Roda
 
         # 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 = RodaPlugins::OPTS)
+        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
@@ -520,17 +491,17 @@ class Roda
 
       module DelegateMethods
         [:logger, :back].each do |meth|
-          define_method(meth){@_request.send(meth)}
+          define_method(meth){@_request.public_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)}
+          define_method(meth){|*v, &block| @_request.public_send(meth, *v, &block)}
         end
 
         [:informational?, :success?, :redirect?, :client_error?, :server_error?, :not_found?].each do |meth|
-          define_method(meth){@_response.send(meth)}
+          define_method(meth){@_response.public_send(meth)}
         end
         [:status, :body, :headers, :mime_type, :content_type, :attachment].each do |meth|
-          define_method(meth){|*v, &block| @_response.send(meth, *v, &block)}
+          define_method(meth){|*v, &block| @_response.public_send(meth, *v, &block)}
         end
       end
     end

data/lib/roda/plugins/slash_path_empty.rb

@@ -11,9 +11,6 @@ class Roda
     # are processed.  This can make it easier to handle applications
     # where a trailing "/" in the path should be ignored.
     module SlashPathEmpty
-      SLASH = "/".freeze
-      RodaPlugins.deprecate_constant(self, :SLASH)
-
       module RequestMethods
         private
 

data/lib/roda/plugins/static.rb

@@ -22,8 +22,8 @@ class Roda
     #
     #   opts[:root] = '/path/to/app'
     #   plugin :static, ['/js', '/css'] # path: /path/to/app/public
-    #   plugin :static, ['/images'], :root=>'pub'  # path: /path/to/app/pub
-    #   plugin :static, ['/media'], :root=>'/path/to/public' # path: /path/to/public
+    #   plugin :static, ['/images'], root: 'pub'  # path: /path/to/app/pub
+    #   plugin :static, ['/media'], root: '/path/to/public' # path: /path/to/public
     module Static
       # Load the Rack::Static middleware.  Use the paths given as the :urls option,
       # and set the :root option to be relative to the application's :root option.

data/lib/roda/plugins/static_routing.rb

@@ -4,7 +4,7 @@
 class Roda
   module RodaPlugins
     # The static_routing plugin adds static_* routing class methods for handling
-    # static routes (i.e. routes with static paths, no placeholders).  These
+    # static routes (i.e. routes with static paths, no nesting or placeholders).  These
     # routes are processed before the normal routing tree and designed for
     # maximum performance.  This can be substantially faster than Roda's normal
     # tree based routing if you have large numbers of static routes, about 3-4x
@@ -59,8 +59,7 @@ class Roda
       module ClassMethods
         # Freeze the static route metadata when freezing the app.
         def freeze
-          opts[:static_routes].freeze
-          opts[:static_routes].each_value(&:freeze)
+          opts[:static_routes].freeze.each_value(&:freeze)
           super
         end
 

data/lib/roda/plugins/streaming.rb

@@ -19,12 +19,8 @@ class Roda
     #
     # The stream method takes the following options:
     #
-    # :callback :: A callback proc to call when the connection is
-    #              closed.
-    # :keep_open :: Whether to keep the connection open after the
-    #               stream block returns, default is false.
-    # :loop :: Whether to call the stream block continuously until
-    #          the connection is closed.
+    # :callback :: A callback proc to call when the connection is closed.
+    # :loop :: Whether to call the stream block continuously until the connection is closed.
     #
     # If the :loop option is used, you can override the
     # handle_stream_error method to change how exceptions
@@ -44,111 +40,32 @@ class Roda
     #   end
     #
     # or handle the errors in some other way.
-    #
-    # 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 Streaming
-      OPTS = {}.freeze
-      RodaPlugins.deprecate_constant(self, :OPTS)
-
       # Class of the response body in case you use #stream.
-      #
-      # Three things really matter: The front and back block (back being the
-      # block generating content, front the one sending it to the client) and
-      # the scheduler, integrating with whatever concurrency feature the Rack
-      # handler is using.
-      #
-      # Scheduler has to respond to defer and schedule.
       class Stream
         include Enumerable
 
-        # The default scheduler to used when streaming, useful for code
-        # using ruby's default threading support.
-        class Scheduler
-          # Store the stream to schedule.
-          def initialize(stream)
-            @stream = stream
-          end
-
-          # Immediately yield.
-          def defer(*)
-            yield
-          end
-
-          # Close the stream if there is an exception when scheduling,
-          # and reraise the exception if so.
-          def schedule(*)
-            yield
-          rescue Exception
-            @stream.close
-            raise
-          end
-        end
-
         # Handle streaming options, see Streaming for details.
-        def initialize(opts=RodaPlugins::OPTS, &back)
-          @scheduler = opts[:scheduler] || Scheduler.new(self)
-          @back = back.to_proc
-          @keep_open = opts[:keep_open]
-          @callbacks = []
+        def initialize(opts=OPTS, &block)
+          @block = block
+          @out = nil
+          @callback = opts[:callback]
           @closed = false
-
-          if opts[:callback]
-            @callbacks << opts[:callback]
-          end
         end
 
         # Add output to the streaming response body.
         def write(data)
-          @scheduler.schedule{@front.call(data.to_s)}
+          @out.call(data.to_s)
           self
         end
-
-        # Alias for +write+.
-        def <<(data)
-          write(data)
-        end
-
-        # Add the given block as a callback to call when the block closes.
-        def callback(&block)
-          RodaPlugins.warn 'Stream#callback in the streaming plugin is deprecated and will be removed in Roda 3.  Specify callback at initialization using the stream method :callback option.'
-          return yield if closed?
-          @callbacks << block
-        end
-
-        # Alias to callback for EventMachine compatibility.
-        alias errback callback
+        alias << write
 
         # If not already closed, close the connection, and call
         # any callbacks.
         def close
           return if closed?
           @closed = true
-          @scheduler.schedule{@callbacks.each(&:call)}
+          @callback.call if @callback
         end
 
         # Whether the connection has already been closed.
@@ -157,16 +74,11 @@ class Roda
         end
 
         # Yield values to the block as they are passed in via #<<.
-        def each(&front)
-          @front = front
-          @scheduler.defer do
-            begin
-              @back.call(self)
-            rescue Exception => e
-              @scheduler.schedule{raise e}
-            end
-            close unless @keep_open
-          end
+        def each(&out)
+          @out = out
+          @block.call(self)
+        ensure
+          close
         end
       end
 
@@ -174,12 +86,7 @@ class Roda
         # Immediately return a streaming response using the current response
         # status and headers, calling the block to get the streaming response.
         # See Streaming for details.
-        def stream(opts=RodaPlugins::OPTS, &block)
-          if !opts.has_key?(:scheduler) && env['async.callback']
-            RodaPlugins.warn 'The automatic support for EventMachine in the streaming plugin is deprecated and will be removed in Roda 3.'
-            opts = opts.merge(:scheduler=>EventMachine)
-          end
-
+        def stream(opts=OPTS, &block)
           if opts[:loop]
             block = proc do |out|
               until out.closed?