roda 1.3.0 → 2.0.0

data/lib/roda/plugins/padrino_render.rb

@@ -0,0 +1,60 @@
+class Roda
+  module RodaPlugins
+    # The padrino_render plugin adds rendering support that is
+    # similar to Padrino's.  While not everything Padrino's
+    # rendering supports is supported by this plugin (yet), it
+    # currently handles enough to be a drop in replacement for
+    # some applications.
+    #
+    # Most notably, this makes the +render+ method default to
+    # using the layout, similar to how the +view+ method works
+    # in the render plugin.  If you want to call render and not
+    # use a layout, you can use the <tt>:layout=>false</tt>
+    # option:
+    #
+    #   render('test')                 # layout
+    #   render('test', :layout=>false) # no layout
+    #
+    # This also adds a +partial+ method, which renders templates
+    # without the layout, but prefixes the template filename to
+    # use with an underscore:
+    #
+    #   partial('test')     # uses _test.erb
+    #   partial('dir/test') # uses dir/_test.erb
+    #
+    # 
+    module PadrinoRender
+      OPTS = {}.freeze
+      SLASH = '/'.freeze
+
+      # Depend on the render plugin, since this overrides
+      # some of its methods.
+      def self.load_dependencies(app, opts=OPTS)
+        app.plugin :render, opts
+      end
+
+      module InstanceMethods
+        # Call view with the given arguments, so that render
+        # uses a layout by default.
+        def render(template, opts=OPTS)
+          view(template, opts)
+        end
+
+        # Renders the given template without a layout, but
+        # prefixes the template filename to use with an 
+        # underscore.
+        def partial(template, opts=OPTS)
+          opts = parse_template_opts(template, opts)
+          if opts[:template]
+            template = opts[:template].split(SLASH)
+            template[-1] = "_#{template[-1]}"
+            opts[:template] = template.join(SLASH)
+          end
+          render_template(opts)
+        end
+      end
+    end
+
+    register_plugin(:padrino_render, PadrinoRender)
+  end
+end

data/lib/roda/plugins/param_matchers.rb

@@ -6,15 +6,15 @@ class Roda
     # It adds a :param matcher for matching on any param with the
     # same name, yielding the value of the param.
     #
-    #   r.on :param=>'foo' do |value|
+    #   r.on :param => 'foo' do |value|
     #     # Matches '?foo=bar', '?foo='
     #     # Doesn't match '?bar=foo'
     #   end
     #
     # It adds a :param! matcher for matching on any non-empty param
-    # with the same name, yielding the value of the param
+    # with the same name, yielding the value of the param.
     #
-    #   r.on :param!=>'foo' do |value|
+    #   r.on(:param! => 'foo') do |value|
     #     # Matches '?foo=bar'
     #     # Doesn't match '?foo=', '?bar=foo'
     #   end

data/lib/roda/plugins/path.rb

@@ -32,10 +32,11 @@ class Roda
     # a block to a block that is instance_execed.
     module Path
       DEFAULT_PORTS = {'http' => 80, 'https' => 443}.freeze
+      OPTS = {}.freeze
 
       module ClassMethods
         # Create a new instance method for the named path.  See plugin module documentation for options.
-        def path(name, path=nil, opts={}, &block)
+        def path(name, path=nil, opts=OPTS, &block)
           if path.is_a?(Hash)
             raise RodaError,  "cannot provide two option hashses to Roda.path" unless opts.empty?
             opts = path

data/lib/roda/plugins/render.rb

@@ -28,7 +28,7 @@ class Roda
     #           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,
+    # :escape :: Use Roda's Erubis escaping support, which makes <tt><%= %></tt> escape output,
     #            <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
@@ -65,7 +65,7 @@ class Roda
     # :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].
+    #                    Tilt or <tt>Tilt[:engine]</tt>.
     #
     # Here's how those options are used:
     #
@@ -73,7 +73,8 @@ class Roda
     #   render(:path=>'/path/to/template.erb')
     #
     # If you pass a hash as the first argument to +view+ or +render+, it should
-    # have either +:inline+ or +:path+ as one of the keys.
+    # have either +:template+, +:inline+, +:path+, or +:content+ (for +view+) as
+    # one of the keys.
     module Render
       OPTS={}.freeze
 
@@ -85,27 +86,30 @@ class Roda
 
       # Setup default rendering options.  See Render for details.
       def self.configure(app, opts=OPTS)
+        orig_opts = opts
         if app.opts[:render]
           app.opts[:render] = app.opts[:render].merge(opts)
         else
           app.opts[:render] = opts.dup
         end
 
-        if opts[:opts] && !opts[:template_opts]
-          RodaPlugins.deprecate("The render plugin :opts option is deprecated and will be removed in Roda 2.  Switch to using the :template_opts option")
-          app.opts[:render][:template_opts] = opts[:opts]
-        end
-
         opts = app.opts[:render]
         opts[:engine] ||= "erb"
         opts[:ext] = nil unless opts.has_key?(:ext)
         opts[:views] ||= File.expand_path("views", Dir.pwd)
-        opts[:layout] = "layout" unless opts.has_key?(:layout)
-        opts[:layout_opts] ||= (opts[:layout_opts] || {}).dup
+        opts[:layout_opts] = (opts[:layout_opts] || {}).dup
+
+        if layout = orig_opts.fetch(:layout, true)
+          opts[:layout] = true unless opts.has_key?(:layout)
 
-        if layout = opts[:layout]
-          layout = {:template=>layout} unless layout.is_a?(Hash)
-          opts[:layout_opts] = opts[:layout_opts].merge(layout)
+          case layout
+          when Hash
+            opts[:layout_opts].merge!(layout)
+          when true
+            opts[:layout_opts][:template] ||= 'layout'
+          else
+            opts[:layout_opts][:template] = layout
+          end
         end
 
         template_opts = opts[:template_opts] = (opts[:template_opts] || {}).dup
@@ -117,9 +121,9 @@ class Roda
           template_opts[:engine_class] = ErubisEscaping::Eruby
         end
         opts[:cache] = app.thread_safe_cache if opts.fetch(:cache, ENV['RACK_ENV'] != 'development')
-        opts.extend(RodaDeprecateMutation)
-        opts[:layout_opts].extend(RodaDeprecateMutation)
-        opts[:template_opts].extend(RodaDeprecateMutation)
+        opts[:layout_opts].freeze
+        opts[:template_opts].freeze
+        opts.freeze
       end
 
       module ClassMethods
@@ -128,11 +132,9 @@ class Roda
         # affecting the parent class.
         def inherited(subclass)
           super
-          opts = subclass.opts[:render].dup
-          opts[:layout_opts] = opts[:layout_opts].dup.extend(RodaDeprecateMutation)
-          opts[:template_opts] = opts[:template_opts].dup.extend(RodaDeprecateMutation)
+          opts = subclass.opts[:render] = subclass.opts[:render].dup
           opts[:cache] = thread_safe_cache if opts[:cache]
-          subclass.opts[:render] = opts.extend(RodaDeprecateMutation)
+          opts.freeze
         end
 
         # Return the render options for this class.
@@ -148,10 +150,6 @@ class Roda
           cached_template(opts) do
             template_opts = render_opts[:template_opts]
             current_template_opts = opts[:template_opts]
-            if opts[:opts] && !current_template_opts
-              RodaPlugins.deprecate("The render method :opts option is deprecated and will be removed in Roda 2.  Switch to using the :template_opts option")
-              current_template_opts = opts[:opts]
-            end
             template_opts = template_opts.merge(current_template_opts) if current_template_opts
             opts[:template_class].new(opts[:path], 1, template_opts, &opts[:template_block])
           end.render(self, (opts[:locals]||OPTS), &block)
@@ -169,15 +167,10 @@ class Roda
         # and render it inside the layout.  See Render for details.
         def view(template, opts=OPTS)
           opts = parse_template_opts(template, opts)
-          content = opts[:content] || render(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 = opts[:content] || render_template(opts)
 
-            content = render(layout, layout_opts){content}
+          if layout_opts  = view_layout_opts(opts)
+            content = render_template(layout_opts){content}
           end
 
           content
@@ -185,6 +178,10 @@ class Roda
 
         private
 
+        # Private alias for render.  Should be used by other plugins when they want to render a template
+        # without a layout, as plugins can override render to use a layout.
+        alias render_template render
+
         # If caching templates, attempt to retrieve the template from the cache.  Otherwise, just yield
         # to get the template.
         def cached_template(opts, &block)
@@ -214,10 +211,6 @@ class Roda
 
           if render_opts[:cache]
             template_opts = opts[:template_opts]
-            if opts[:opts] && !template_opts
-              RodaPlugins.deprecate("The render method :opts option is deprecated and will be removed in Roda 2.  Switch to using the :template_opts option")
-              template_opts = opts[:opts]
-            end
             template_block = opts[:template_block] if !content
 
             key = if template_class || template_opts || template_block
@@ -242,11 +235,36 @@ class Roda
           opts[:template].to_s
         end
 
-        # The path for the given template.
+        # The template path for the given options.
         def template_path(opts)
           render_opts = render_opts()
           "#{opts[:views] || render_opts[:views]}/#{template_name(opts)}.#{opts[:ext] || render_opts[:ext] || render_opts[:engine]}"
         end
+
+        # If a layout should be used, return a hash of options for
+        # rendering the layout template.  If a layout should not be
+        # used, return nil.
+        def view_layout_opts(opts)
+          if layout = opts.fetch(:layout, render_opts[:layout])
+            layout_opts = if opts[:layout_opts]
+              opts[:layout_opts].merge(render_opts[:layout_opts])
+            else
+              render_opts[:layout_opts].dup
+            end
+
+            case layout
+            when Hash
+              layout_opts.merge!(layout)
+            when true
+              # use default layout
+            else
+              layout_opts[:template] = layout
+            end
+
+            layout_opts
+          end
+        end
+
       end
     end
 

data/lib/roda/plugins/render_each.rb

@@ -23,6 +23,8 @@ 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
+      OPTS = {}.freeze
+
       # Load the render plugin before this plugin, since this plugin
       # calls the render method.
       def self.load_dependencies(app)
@@ -36,7 +38,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={})
+        def render_each(enum, template, opts=OPTS)
           if as = opts.has_key?(:local)
             as = opts[:local]
           else
@@ -54,7 +56,7 @@ class Roda
 
           enum.map do |v|
             locals[as] = v if as
-            render(template, opts)
+            render_template(template, opts)
           end.join
         end
       end

data/lib/roda/plugins/static_path_info.rb

@@ -1,71 +1,10 @@
 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
-          begin
-            script_name = e[SCRIPT_NAME]
-            path_info = e[PATH_INFO]
-            e[SCRIPT_NAME] += path_info.chomp(path)
-            e[PATH_INFO] = path
-            super
-          ensure
-            e[SCRIPT_NAME] = script_name
-            e[PATH_INFO] = path_info
-          end
-        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
 
+    # For backwards compatibilty, don't raise an error
+    # if trying to load the plugin
     register_plugin(:static_path_info, StaticPathInfo)
   end
 end

data/lib/roda/plugins/streaming.rb

@@ -50,6 +50,8 @@ class Roda
     # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
     # OTHER DEALINGS IN THE SOFTWARE.
     module Streaming
+      OPTS = {}.freeze
+
       # Class of the response body in case you use #stream.
       #
       # Three things really matter: The front and back block (back being the
@@ -85,7 +87,7 @@ class Roda
         end
 
         # Handle streaming options, see Streaming for details.
-        def initialize(opts={}, &back)
+        def initialize(opts=OPTS, &back)
           @scheduler = opts[:scheduler] || Scheduler.new(self)
           @back = back.to_proc
           @keep_open = opts[:keep_open]
@@ -143,7 +145,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={}, &block)
+        def stream(opts=OPTS, &block)
           opts = opts.merge(:scheduler=>EventMachine) if !opts.has_key?(:scheduler) && env['async.callback']
 
           if opts[:loop]

data/lib/roda/version.rb

@@ -1,10 +1,10 @@
 class Roda
   # The major version of Roda, updated only for major changes that are
   # likely to require modification to Roda apps.
-  RodaMajorVersion = 1
+  RodaMajorVersion = 2
 
   # The minor version of Roda, updated for new feature releases of Roda.
-  RodaMinorVersion = 3
+  RodaMinorVersion = 0
 
   # The patch version of Roda, updated only for bug fixes from the last
   # feature release.