roda 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3c4531548815188387cfc8a1cd6eb4803ca52228
-  data.tar.gz: f25f081bd7ed74c63d5b4da6ca87d8ad3a413c42
+  metadata.gz: 9bbbb565f4b5766e8e11f78d322a5446da6358bd
+  data.tar.gz: 4e7b782d3d4a2292e9461c47053156a18d56bec2
 SHA512:
-  metadata.gz: 4fd832236f0c0a59129f10303c56c82f3ec9e63d27f8c85cd5080e0ac1cd3477cd3321f309618a6c2d4690b43b79ab5d687c9243957156d61532e472118943a1
-  data.tar.gz: ca178d1d5b1945ad3f94a9d4273d9cbbfd8726f5f5f924d7eefd9949d0be732eb028e6f2fd1f7f2e7eee526ae04ef796bb2899ebbcbb690bac4a13e0021241af
+  metadata.gz: 864fd659136483c2867b91e6512df778fd9f331c60e30b8166f1146afda0810cb1f08d56b38f2c01f50d7fcd477b9914def3d0eb1479de2533f0db8f94dc3dc3
+  data.tar.gz: 79dcb04899e305ed875f439d3ebb57cbaf9092bba1614e8fcbbb4b15da55c9b10c74086f3bf24e7b543b9dcaaf9f3042009ab611a9e7b7f0aa0b0077a91a32b0

data/CHANGELOG

@@ -1,3 +1,23 @@
+= 2.2.0 (2015-04-13)
+
+* Add :escaper render plugin option to support custom escaping of <%= %> tags when :escape is used (jeremyevans)
+
+* Add :escape_safe_classes render plugin option, to not escape certain string subclasses when :escape is used (jeremyevans)
+
+* Split partials method from padrino_render plugin into partials plugin (kematzy) (#19)
+
+* Add shared_vars plugin, for sharing variables between multiple Roda apps (jeremyevans)
+
+* Add delay method to chunked plugin, for delaying a block execution until right before content template rendering (jeremyevans)
+
+* Have default Content-Type header when using the default_headers plugin (jeremyevans)
+
+* Add :by_name option to the path plugin, for registering classes by name, useful when reloading code (jeremyevans)
+
+* Add Roda.path_block to get the block related to the given class used for Road#path (jeremyevans)
+
+* Make Roda#path work correctly in subclasses (jeremyevans)
+
 = 2.1.0 (2015-03-13)
 
 * Have add_file in the mailer plugin support blocks, which are called after the file has been added (jeremyevans)

data/MIT-LICENSE

@@ -1,5 +1,6 @@
 Copyright (c) 2014-2015 Jeremy Evans
-Copyright (c) 2010, 2011 Michel Martens, Damian Janowski and Cyril David
+Copyright (c) 2010-2014 Michel Martens, Damian Janowski and Cyril David
+Copyright (c) 2008-2009 Christian Neukirchen
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.rdoc

@@ -744,8 +744,49 @@ to escape by default, so that in your templates:
   <%= '<>' %>  # outputs &lt;&gt; 
   <%== '<>' %> # outputs <>
 
+You can also provide a +:escape_safe_classes+ option, which will
+make <tt><%= %></tt> not escape certain string subclasses, useful
+if you have helpers that already return escaped output using a
+string subclass instance.
+
 This support requires {Erubis}[http://www.kuwata-lab.com/erubis/].
 
+=== Security Related HTTP Headers
+
+You may want to look into setting the following HTTP headers, which
+can be done at the web server level, but can also be done at the
+application level using using the +default_headers+ plugin:
+
+Content-Security-Policy/X-Content-Security-Policy :: Defines policy for how javascript and other
+                                                     types of content can be used on the page.
+Frame-Options/X-Frame-Options :: Provides click-jacking projection by not allowing usage inside
+                                 a frame.
+Strict-Transport-Security :: Enforces SSL/TLS Connections to the application.
+X-Content-Type-Options :: Forces some browsers to respect a declared Content-Type header.
+X-XSS-Protection :: Enables an XSS mitigation filter in some browsers.
+
+Example:
+
+  class App < Roda
+    plugin :default_headers,
+      'Content-Type'=>'text/html',
+      'Content-Security-Policy'=>"default-src 'self'",
+      'Strict-Transport-Security'=>'max-age=16070400;',
+      'X-Frame-Options'=>'deny',
+      'X-Content-Type-Options'=>'nosniff',
+      'X-XSS-Protection'=>'1; mode=block'
+  end
+
+== Reloading
+
+Most rack-based reloaders will work with Roda, including:
+
+* {rack-unreloader}[https://github.com/jeremyevans/rack-unreloader]
+* {rerun}[https://github.com/alexch/rerun]
+* {shotgun}[https://github.com/rtomayko/shotgun]
+* {Rack::Reloader}[https://github.com/rack/rack/blob/master/lib/rack/reloader.rb]
+* {pistol}[https://github.com/monk/pistol]
+
 == Plugins
 
 By design, Roda has a very small core, providing only the essentials.

data/Rakefile

@@ -68,15 +68,16 @@ end
 
 begin
   begin
-    # RSpec 1
-    require "spec/rake/spectask"
-    spec_class = Spec::Rake::SpecTask
-    spec_files_meth = :spec_files=
-  rescue LoadError
+    raise LoadError if ENV['RSPEC1']
     # RSpec 2
     require "rspec/core/rake_task"
     spec_class = RSpec::Core::RakeTask
     spec_files_meth = :pattern=
+  rescue LoadError
+    # RSpec 1
+    require "spec/rake/spectask"
+    spec_class = Spec::Rake::SpecTask
+    spec_files_meth = :spec_files=
   end
 
   spec = lambda do |name, files, d|

data/doc/release_notes/2.1.0.txt

@@ -80,7 +80,7 @@
       path(Track){|track| "/albums/#{track.album_id}/tracks/#{track.number}"}
 
       route do
-        r.get 'tracks/:id' |track_id|
+        r.get 'tracks/:id' do |track_id|
           r.redirect(path(Track[track_id]))
         end
       end

data/doc/release_notes/2.2.0.txt

@@ -0,0 +1,97 @@
+= New Plugins
+
+* A shared_vars plugin has been added, for sharing variables between
+  multiple Roda apps.  Example:
+
+    class API < Roda
+      plugin :shared_vars
+      route do |r|
+        user = shared[:user]
+        # ...
+      end
+    end
+ 
+    class App < Roda
+      plugin :shared_vars
+ 
+      route do |r|
+        r.on :user_id do |user_id|
+          shared[:user] = User[user_id]
+          r.run API
+        end
+      end
+    end
+ 
+  If you pass a hash to shared, it will update the shared
+  variables with the content of the hash:
+ 
+    route do |r|
+      r.on :user_id do |user_id|
+        shared(:user => User[user_id])
+        r.run API
+      end
+    end
+ 
+  You can also pass a block to shared, which will set the
+  shared variables only for the given block, restoring the
+  previous shared variables afterward:
+ 
+    route do |r|
+      r.on :user_id do |user_id|
+        shared(:user => User[user_id]) do
+          r.run API
+        end
+      end
+    end
+
+* The partials method added by the padrino_render plugin has been
+  extracted into a partials plugin, for users who want to use the
+  partials method without having render use a layout by default.
+
+= Other New Features
+
+* The render plugin when using the :escape option now additionally
+  supports an :escape_safe_classes option, which accepts a class or
+  array of classes that should not be automatically escaped when using
+  <%= %> tags.  This makes easier to integrate with helpers or
+  external libraries that return already html escaped strings, without
+  using <%== %> tags.
+
+  For complete control, an :escaper option is also supported, which
+  will be used for escaping <%= %> strings.  The value of this option
+  should be an object that responds to escape_xml with a single
+  argument and returns an output string.
+
+* A Roda#delay method has been added to the chunked plugin, which
+  delays execution of the given block until right before the content
+  template is rendered.  This allows you to continue to use the
+  routing tree to DRY up your code even when streaming template
+  rendering.  Example:
+
+    r.on 'albums/:d' do |album_id|
+      delay do
+        @album = Album[album_id]
+      end
+      r.get 'info' do
+        chunked(:info)
+      end
+      r.get 'tracks' do
+        chunked(:tracks)
+      end
+    end
+
+* The path plugin now supports a :by_name option, which makes lookup
+  of the class be by name as opposed to by reference.  This is
+  designed for use in development when doing code reloading.
+
+* Roda.path_block has been added to the path plugin for returning the
+  block associated with the given class.
+
+= Other Improvements
+
+* The default_headers plugin now defaults to the same headers that
+  Roda uses by default (just the Content-Type header with text/html
+  value).  Previously, it did not set a Content-Type header if you
+  didn't specify one.
+
+* In the path plugin, Roda#path now works correctly in subclasses.

data/lib/roda/plugins/_erubis_escaping.rb

@@ -2,23 +2,50 @@ require 'erubis'
 
 class Roda
   module RodaPlugins
-    # The _erubis_escaping plugin is an internal plugin that provides a
-    # subclass of Erubis::EscapedEruby with a bugfix and an optimization.
+    # The _erubis_escaping plugin handles escaping of <tt><%= %></tt> inside
+    # ERB templates.  It is an internal plugin that should not be loaded
+    # directlyn by user code.
     module ErubisEscaping
-      # Optimized subclass that fixes escaping of postfix conditionals.
+      # Escaper which escapes by default, but does not escape instances of
+      # classes marked as safe.
+      class UnsafeClassEscaper
+        # Default escaper if the string needs to be escaped.
+        Escaper = Erubis::XmlHelper
+
+        # Record the classes to consider safe.
+        def initialize(safe_classes)
+          @safe_classes = Array(safe_classes).freeze
+          freeze
+        end
+
+        # If the string given is not an instance of one of the safe
+        # classes, escape it, otherwise return it verbatim.  If the
+        # given object is not already a string, convert it to a string first.
+        def escape_xml(string)
+          unless string.is_a?(String)
+            string = string.to_s
+          end
+
+          if @safe_classes.any?{|c| string.is_a?(c)}
+            string
+          else
+            Escaper.escape_xml(string)
+          end
+        end
+      end
+
+      # Subclass that works with specified escaper, also handling
+      # postfix conditionals inside <tt><%= %></tt> tags.
       class Eruby < Erubis::EscapedEruby
-        # Set escaping class to a local variable, so you don't need a
-        # constant lookup per escape.
+        # Set escaping object to a local variable
         def convert_input(codebuf, input)
-          codebuf << '_erubis_xml_helper = Erubis::XmlHelper;'
+          codebuf << '_erubis_escaper = render_opts[:escaper];'
           super
         end
 
-        # Fix bug in Erubis::EscapedEruby where postfix conditionals inside
-        # <%= %> are broken (e.g. <%= foo if bar %> ), and optimize by using
-        # a local variable instead of a constant lookup.
+        # Use escaping object to escape the code, and handle postfix conditionals.
         def add_expr_escaped(src, code)
-          src << " #{@bufvar} << _erubis_xml_helper.escape_xml((" << code << '));'
+          src << " " << @bufvar << " << _erubis_escaper.escape_xml((" <<  code << "));"
         end
       end
     end

data/lib/roda/plugins/chunked.rb

@@ -37,6 +37,23 @@ class Roda
     #     end
     #   end
     #
+    # You can also call delay manually with a block, and the execution of the
+    # block will be delayed until rendering the content template.  This is
+    # useful if you want to delay execution for all routes under a branch:
+    #
+    #   r.on 'albums/:d' do |album_id|
+    #     delay do
+    #       @album = Album[album_id]
+    #     end
+    #     r.get 'info' do
+    #       chunked(:info)
+    #     end
+    #     r.get 'tracks' do
+    #       chunked(:tracks)
+    #     end
+    #   end
+    #
+    #
     # If you want to chunk all responses, pass the :chunk_by_default option
     # when loading the plugin:
     #
@@ -192,15 +209,19 @@ class Roda
         end
 
         # Render a response to the user in chunks.  See Chunked for
-        # an overview.
+        # an overview.  If a block is given, it is passed to #delay.
         def chunked(template, opts=OPTS, &block)
           unless defined?(@_chunked)
             @_chunked = env[HTTP_VERSION] == HTTP11
           end
 
+          if block
+            delay(&block)
+          end
+
           unless @_chunked
             # If chunking is disabled, do a normal rendering of the view.
-            yield if block
+            run_delayed_blocks
             return view(template, opts)
           end
 
@@ -214,7 +235,7 @@ class Roda
           
           # Hack so that the arguments don't need to be passed
           # through the response and body objects.
-          @_each_chunk_args = [template, opts, block]
+          @_each_chunk_args = [template, opts]
 
           res = response
           headers = res.headers
@@ -226,11 +247,18 @@ class Roda
           throw :halt, res.finish_with_body(Body.new(self))
         end
 
+        # Delay the execution of the block until right before the
+        # content template is to be rendered.
+        def delay(&block)
+          raise RodaError, "must pass a block to Roda#delay" unless block
+          (@_delays ||= []) << block
+        end
+
         # Yield each chunk of the template rendering separately.
         def each_chunk
           response.body.each{|s| yield s}
 
-          template, opts, block = @_each_chunk_args
+          template, opts = @_each_chunk_args
 
           # Use a lambda for the flusher, so that a call to flush
           # by a template can result in this method yielding a chunk
@@ -243,12 +271,12 @@ class Roda
           if layout_opts  = view_layout_opts(opts)
             @_out_buf = render_template(layout_opts) do
               flush
-              block.call if block
+              run_delayed_blocks
               yield opts[:content] || render_template(template, opts)
               nil
             end
           else
-            yield if block
+            run_delayed_blocks
             yield view(template, opts)
           end
 
@@ -268,6 +296,14 @@ class Roda
         def flush
           @_flusher.call if @_flusher
         end
+        
+        private
+
+        # Run all delayed blocks
+        def run_delayed_blocks
+          return unless @_delays
+          @_delays.each(&:call)
+        end
       end
     end
 

data/lib/roda/plugins/default_headers.rb

@@ -20,7 +20,7 @@ class Roda
     module DefaultHeaders
       # Merge the given headers into the existing default headers, if any.
       def self.configure(app, headers={})
-        app.opts[:default_headers] = (app.opts[:default_headers] || {}).merge(headers).freeze
+        app.opts[:default_headers] = (app.default_headers || app::RodaResponse::DEFAULT_HEADERS).merge(headers).freeze
       end 
 
       module ClassMethods

data/lib/roda/plugins/multi_route.rb

@@ -133,7 +133,7 @@ class Roda
         # Freeze the namespaced routes so that there can be no thread safety issues at runtime.
         def freeze
           opts[:namespaced_routes].freeze
-          opts[:namespaced_routes].each_value{|v| v.freeze}
+          opts[:namespaced_routes].each_value(&:freeze)
           super
         end
 

data/lib/roda/plugins/padrino_render.rb

@@ -5,7 +5,9 @@ class Roda
     # rendering supports is supported by this plugin (yet), it
     # currently handles enough to be a drop in replacement for
     # some applications.
-    #
+    # 
+    #   plugin :padrino_render, :views => 'path/2/views'
+    # 
     # 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
@@ -15,22 +17,14 @@ class Roda
     #   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
-    #
-    # 
+    # Note that this plugin loads the :partials plugin.
     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
+        app.plugin :partials, opts
       end
 
       module InstanceMethods
@@ -39,19 +33,6 @@ class Roda
         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
 

data/lib/roda/plugins/partials.rb

@@ -0,0 +1,47 @@
+class Roda
+  module RodaPlugins
+    # The partials plugin adds a +partial+ method, which renders 
+    # templates without the layout.
+    # 
+    #   plugin :partials, :views => 'path/2/views'
+    # 
+    # Template files are prefixed with an underscore:
+    #
+    #   partial('test')     # uses _test.erb
+    #   partial('dir/test') # uses dir/_test.erb
+    #
+    # This is basically equivalent to:
+    #
+    #   render('_test')
+    #   render('dir/_test')
+    #
+    # Note that this plugin automatically loads the :render plugin.
+    module Partials
+      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
+        # 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(:partials, Partials)
+  end
+end

data/lib/roda/plugins/path.rb

@@ -61,11 +61,15 @@ class Roda
       DEFAULT_PORTS = {'http' => 80, 'https' => 443}.freeze
       OPTS = {}.freeze
 
-      # Initialize the path classes when loading the plugin
-      def self.configure(app)
+      # Initialize the path classes when loading the plugin. Options:
+      # :by_name :: Register classes by name, which is friendlier when reloading code.
+      def self.configure(app, opts=OPTS)
         app.instance_eval do
-          @path_classes ||= {}
-          unless @path_classes[String]
+          if opts.has_key?(:by_name)
+            self.opts[:path_class_by_name] = opts[:by_name]
+          end
+          self.opts[:path_classes] ||= {}
+          unless path_block(String)
             path(String){|str| str}
           end
         end
@@ -73,11 +77,13 @@ class Roda
 
       module ClassMethods
         # Hash of recognizes classes for path instance method.  Keys are classes, values are procs.
-        attr_reader :path_classes
+        def path_classes
+          opts[:path_classes]
+        end
 
         # Freeze the path classes when freezing the app.
         def freeze
-          @path_classes.freeze
+          path_classes.freeze
           super
         end
 
@@ -86,7 +92,10 @@ class Roda
           if name.is_a?(Class)
             raise RodaError, "can't provide path or options when calling path with a class" unless path.nil? && opts.empty?
             raise RodaError, "must provide a block when calling path with a class" unless block
-            @path_classes[name] = block
+            if self.opts[:path_class_by_name]
+              name = name.name
+            end
+            path_classes[name] = block
             return
           end
 
@@ -145,6 +154,14 @@ class Roda
 
           nil
         end
+        
+        # Return the block related to the given class, or nil if there is no block.
+        def path_block(klass)
+          if opts[:path_class_by_name]
+            klass = klass.name
+          end
+          path_classes[klass]
+        end
       end
 
       module InstanceMethods
@@ -153,13 +170,13 @@ class Roda
         # :add_script_name option is true, this prepends the SCRIPT_NAME to the path.
         def path(obj, *args)
           app = self.class
-          if blk = app.path_classes[obj.class]
-            path = instance_exec(obj, *args, &blk)
-            path = request.script_name.to_s + path if app.opts[:add_script_name]
-            path
-          else
+          unless blk = app.path_block(obj.class)
             raise RodaError, "unrecognized object given to Roda#path: #{obj.inspect}"
           end
+
+          path = instance_exec(obj, *args, &blk)
+          path = request.script_name.to_s + path if app.opts[:add_script_name]
+          path
         end
       end
     end

data/lib/roda/plugins/render.rb

@@ -31,6 +31,11 @@ class Roda
     # :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.
+    # :escape_safe_classes :: String subclasses that should not be HTML escaped when used in
+    #            <tt><%= %></tt> tags, when :escape is used. Can be an array for multiple classes.
+    # :escaper :: Object used for escaping output of <tt><%= %></tt>, when :escape is used,
+    #             overriding the default.  If given, object should respond to +escape_xml+ with
+    #             a single argument and return an output string.
     # :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'.
@@ -119,6 +124,12 @@ class Roda
         end
         if opts[:escape]
           template_opts[:engine_class] = ErubisEscaping::Eruby
+
+          opts[:escaper] ||= if opts[:escape_safe_classes]
+            ErubisEscaping::UnsafeClassEscaper.new(opts[:escape_safe_classes])
+          else
+            ::Erubis::XmlHelper
+          end
         end
         opts[:cache] = app.thread_safe_cache if opts.fetch(:cache, ENV['RACK_ENV'] != 'development')
         opts[:layout_opts].freeze

data/lib/roda/plugins/shared_vars.rb

@@ -0,0 +1,85 @@
+class Roda
+  module RodaPlugins
+    # The shared_vars plugin adds a shared method for storing
+    # shared variables across nested Roda apps.
+    #
+    #   class API < Roda
+    #     plugin :shared_vars
+    #     route do |r|
+    #       user = shared[:user]
+    #       # ...
+    #     end
+    #   end
+    #
+    #   class App < Roda
+    #     plugin :shared_vars
+    #
+    #     route do |r|
+    #       r.on :user_id do |user_id|
+    #         shared[:user] = User[user_id]
+    #         r.run API
+    #       end
+    #     end
+    #   end
+    #
+    # If you pass a hash to shared, it will update the shared
+    # vars with the content of the hash:
+    #
+    #   route do |r|
+    #     r.on :user_id do |user_id|
+    #       shared(:user => User[user_id])
+    #       r.run API
+    #     end
+    #   end
+    #
+    # You can also pass a block to shared, which will set the
+    # shared variables only for the given block, restoring the
+    # previous shared variables afterward:
+    #
+    #   route do |r|
+    #     r.on :user_id do |user_id|
+    #       shared(:user => User[user_id]) do
+    #         r.run API
+    #       end
+    #     end
+    #   end
+    module SharedVars
+      KEY = 'roda.shared'.freeze
+
+      module InstanceMethods
+        # Returns the current shared vars for the request.  These are
+        # stored in the request's environment, so they will be implicitly
+        # shared with other apps using this plugin.
+        #
+        # If the +vars+ argument is given, it should be a hash that will be
+        # merged into the current shared vars.
+        #
+        # If a block is given, a +vars+ argument must be provided, and it will
+        # only make the changes to the shared vars for the duration of the
+        # block, restoring the previous shared vars before the block returns.
+        def shared(vars=nil)
+          h = env[KEY] ||= {}
+
+          if block_given?
+            if vars
+              begin
+                env[KEY] = h.merge(vars)
+                yield
+              ensure
+                env[KEY] = h
+              end
+            else
+              raise RodaError, "must pass a vars hash when calling shared with a block"
+            end
+          elsif vars
+            h.merge!(vars)
+          end
+
+          h
+        end
+      end
+    end
+
+    register_plugin(:shared_vars, SharedVars)
+  end
+end

data/lib/roda/plugins/streaming.rb

@@ -119,7 +119,7 @@ class Roda
         def close
           return if closed?
           @closed = true
-          @scheduler.schedule{@callbacks.each{|c| c.call}}
+          @scheduler.schedule{@callbacks.each(&:call)}
         end
 
         # Whether the connection has already been closed.

data/lib/roda/version.rb

@@ -4,7 +4,7 @@ class Roda
   RodaMajorVersion = 2
 
   # The minor version of Roda, updated for new feature releases of Roda.
-  RodaMinorVersion = 1
+  RodaMinorVersion = 2
 
   # The patch version of Roda, updated only for bug fixes from the last
   # feature release.

data/spec/plugin/_erubis_escaping_spec.rb

@@ -12,7 +12,7 @@ rescue LoadError
   warn "tilt or erubis not installed, skipping _erubis_escaping plugin test"  
 else
 describe "_erubis_escaping plugin" do
-  before do
+  it "should escape inside <%= %> and not inside <%== %>, and handle postfix conditionals" do
     app(:bare) do
       plugin :render, :escape=>true
 
@@ -20,10 +20,39 @@ describe "_erubis_escaping plugin" do
         render(:inline=>'<%= "<>" %> <%== "<>" %><%= "<>" if false %>')
       end
     end
+
+    body.should == '&lt;&gt; <>'
   end
 
-  it "should escape inside <%= %> and not inside <%== %>, and handle postfix conditionals" do
+  it "should consider classes in :escape_safe_classes as safe" do
+    c = Class.new(String)
+    c2 = Class.new(String)
+    app(:bare) do
+      plugin :render, :escape=>true, :escape_safe_classes=>c
+
+      route do |r|
+        @c, @c2 = c, c2
+        render(:inline=>'<%= @c2.new("<>") %> <%= @c.new("<>") %>')
+      end
+    end
+
     body.should == '&lt;&gt; <>'
   end
+
+  it "should allow use of custom :escaper" do
+    escaper = Object.new
+    def escaper.escape_xml(s)
+      s.gsub("'", "''")
+    end
+    app(:bare) do
+      plugin :render, :escape=>true, :escaper=>escaper
+
+      route do |r|
+        render(:inline=>'<%= "ab\'1" %> <%== "ab\'1" %>')
+      end
+    end
+
+    body.should == "ab''1 ab'1"
+  end
 end
 end

data/spec/plugin/chunked_spec.rb

@@ -7,9 +7,7 @@ rescue LoadError
 else
 describe "chunked plugin" do 
   def cbody(env={})
-    b = ''
-    req({'HTTP_VERSION'=>'HTTP/1.1'}.merge(env))[2].each{|s| b << s}
-    b
+    body({'HTTP_VERSION'=>'HTTP/1.1'}.merge(env))
   end
 
   it "streams templates in chunked encoding only if HTTP 1.1 is used" do
@@ -42,6 +40,26 @@ describe "chunked plugin" do
     body.should == "hmht"
   end
 
+  it "has delay accept block that is called after layout yielding but before content when streaming" do
+    app(:chunked) do |r|
+      delay do
+        @h << 'i'
+      end
+      @h = 'h'
+      chunked(:inline=>'m<%= @h %>', :layout=>{:inline=>'<%= @h %><%= yield %>t'}) do
+        @h << 'j'
+      end
+    end
+
+    cbody.should == "1\r\nh\r\n4\r\nmhij\r\n1\r\nt\r\n0\r\n\r\n"
+    body.should == "hijmhijt"
+  end
+
+  it "has delay raise if not given a block" do
+    app(:chunked){|r| delay}
+    proc{body}.should raise_error(Roda::RodaError)
+  end
+
   it "works when a layout is not used" do
     app(:chunked) do |r|
       chunked(:inline=>'m', :layout=>nil)

data/spec/plugin/default_headers_spec.rb

@@ -43,6 +43,20 @@ describe "default_headers plugin" do
     req[1].should == {'Content-Type'=>'text/json', 'Foo'=>'baz'}
   end
 
+  it "should have a default Content-Type header" do
+    h = {'Foo'=>'bar'}
+
+    app(:bare) do
+      plugin :default_headers, h
+
+      route do |r|
+        r.halt response.finish_with_body([])
+      end
+    end
+
+    req[1].should == {'Content-Type'=>'text/html', 'Foo'=>'bar'}
+  end
+
   it "should work correctly in subclasses" do
     h = {'Content-Type'=>'text/json', 'Foo'=>'bar'}
 

data/spec/plugin/padrino_render_spec.rb

@@ -11,18 +11,7 @@ describe "padrino_render plugin" do
       plugin :padrino_render, :views=>"./spec/views"
 
       route do |r|
-        r.is "partial" do
-          partial("test", :locals=>{:title => "About Roda"})
-        end
-
-        r.is "partial/subdir" do
-          partial("about/test", :locals=>{:title => "About Roda"})
-        end
-
-        r.is "partial/inline" do
-          partial(:inline=>"Hello <%= name %>", :locals=>{:name => "Agent Smith"})
-        end
-
+        
         r.is "render" do
           render(:content=>'bar', :layout_opts=>{:locals=>{:title=>"Home"}})
         end
@@ -34,18 +23,6 @@ describe "padrino_render plugin" do
     end
   end
 
-  it "partial renders without layout, and prepends _ to template" do
-    body("/partial").strip.should == "<h1>About Roda</h1>"
-  end
-
-  it "partial renders without layout, and prepends _ to template" do
-    body("/partial/subdir").strip.should == "<h1>Subdir: About Roda</h1>"
-  end
-
-  it "partial handles inline partials" do
-    body("/partial/inline").strip.should == "Hello Agent Smith"
-  end
-
   it "render uses layout by default" do
     body("/render").strip.should == "<title>Roda: Home</title>\nbar"
   end

data/spec/plugin/partials_spec.rb

@@ -0,0 +1,43 @@
+require File.expand_path("spec_helper", File.dirname(File.dirname(__FILE__)))
+
+begin
+  require 'tilt/erb'
+rescue LoadError
+  warn "tilt not installed, skipping partials plugin test"  
+else
+  describe "partials plugin" do
+    before do
+      app(:bare) do
+        plugin :partials, :views=>"./spec/views"
+
+        route do |r|
+          r.is "partial" do
+            partial("test", :locals=>{:title => "About Roda"})
+          end
+
+          r.is "partial/subdir" do
+            partial("about/test", :locals=>{:title => "About Roda"})
+          end
+
+          r.is "partial/inline" do
+            partial(:inline=>"Hello <%= name %>", :locals=>{:name => "Agent Smith"})
+          end
+        
+        end
+      end
+    end
+
+    it "partial renders without layout, and prepends _ to template" do
+      body("/partial").strip.should == "<h1>About Roda</h1>"
+    end
+
+    it "partial renders without layout, and prepends _ to template" do
+      body("/partial/subdir").strip.should == "<h1>Subdir: About Roda</h1>"
+    end
+
+    it "partial handles inline partials" do
+      body("/partial/inline").strip.should == "Hello Agent Smith"
+    end
+
+  end
+end

data/spec/plugin/path_spec.rb

@@ -152,6 +152,49 @@ describe "path plugin" do
     body('path'=>[@obj, 'foo', 'bar'], 'SCRIPT_NAME'=>'/baz').should == '/baz/d/1/foo/bar'
   end
 
+  it "Roda#path works in subclasses" do
+    old_app = @app
+    @app = Class.new(@app)
+    @app.route{|r| path('/a')}
+    body.should == '/a'
+
+    @app.path(String){|b| "/foo#{b}"}
+    body.should == '/foo/a'
+
+    @app = old_app
+    body('path'=>'/a').should == '/a'
+  end
+
+  it "registers classes by reference by default" do
+    c1 = Class.new
+    def c1.name; 'C'; end
+    c2 = Class.new
+    def c2.name; 'C'; end
+    @app.path(c1){'/c'}
+    @app.route{|r| path(r.env['c'])}
+    body('c'=>c1.new).should == '/c'
+    proc{body('c'=>c2.new)}.should raise_error(Roda::RodaError)
+  end
+
+  it ":by_name => option registers classes by name" do
+    c1 = Class.new
+    def c1.name; 'C'; end
+    c2 = Class.new
+    def c2.name; 'C'; end
+    @app.plugin :path, :by_name=>true
+    @app.path(c1){'/c'}
+    @app.route{|r| path(r.env['c'])}
+    body('c'=>c1.new).should == '/c'
+    body('c'=>c2.new).should == '/c'
+  end
+
+  it "Roda.path_block returns the block used" do
+    c = Class.new
+    b = proc{|x| x.to_s}
+    @app.path(c, &b)
+    @app.path_block(c).should == b
+  end
+
   it "Roda.path doesn't work with classes without blocks" do
     proc{app.path(Class.new)}.should raise_error(Roda::RodaError)
   end

data/spec/plugin/shared_vars_spec.rb

@@ -0,0 +1,45 @@
+require File.expand_path("spec_helper", File.dirname(File.dirname(__FILE__)))
+
+describe "shared_vars plugin" do 
+  it "adds shared method for sharing variables across multiple apps" do
+    app(:shared_vars) {|r| shared[:c]}
+    old_app = app
+    app(:shared_vars) do |r|
+      shared[:c] = 'c'
+      r.run old_app
+    end
+
+    body.should == 'c'
+  end
+
+  it "adds shared with hash merges the hash into the shared vars" do
+    app(:shared_vars) do |r|
+      shared(:c=>'c')
+      shared[:c]
+    end
+
+    body.should == 'c'
+  end
+
+  it "calling shared with hash and a block sets shared variables only for that block" do
+    app(:shared_vars) do |r|
+      c = nil
+      d = nil
+      shared[:c] = 'b'
+      shared(:c=>'c', :d=>'d') do
+        c = shared[:c]
+        d = shared[:d]
+      end
+      "#{shared[:c]}:#{shared[:d]}:#{c}:#{d}"
+    end
+
+    body.should == 'b::c:d'
+  end
+
+  it "calling shared with no arguments and a block raises an error" do
+    app(:shared_vars) do |r|
+      shared{}
+    end
+    proc{body}.should raise_error(Roda::RodaError)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: roda
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-13 00:00:00.000000000 Z
+date: 2015-04-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -138,6 +138,7 @@ extra_rdoc_files:
 - doc/release_notes/1.3.0.txt
 - doc/release_notes/2.0.0.txt
 - doc/release_notes/2.1.0.txt
+- doc/release_notes/2.2.0.txt
 files:
 - CHANGELOG
 - MIT-LICENSE
@@ -150,6 +151,7 @@ files:
 - doc/release_notes/1.3.0.txt
 - doc/release_notes/2.0.0.txt
 - doc/release_notes/2.1.0.txt
+- doc/release_notes/2.2.0.txt
 - lib/roda.rb
 - lib/roda/plugins/_erubis_escaping.rb
 - lib/roda/plugins/all_verbs.rb
@@ -190,12 +192,14 @@ files:
 - lib/roda/plugins/not_found.rb
 - lib/roda/plugins/padrino_render.rb
 - lib/roda/plugins/param_matchers.rb
+- lib/roda/plugins/partials.rb
 - lib/roda/plugins/pass.rb
 - lib/roda/plugins/path.rb
 - lib/roda/plugins/path_matchers.rb
 - lib/roda/plugins/per_thread_caching.rb
 - lib/roda/plugins/render.rb
 - lib/roda/plugins/render_each.rb
+- lib/roda/plugins/shared_vars.rb
 - lib/roda/plugins/sinatra_helpers.rb
 - lib/roda/plugins/slash_path_empty.rb
 - lib/roda/plugins/static.rb
@@ -255,12 +259,14 @@ files:
 - spec/plugin/not_found_spec.rb
 - spec/plugin/padrino_render_spec.rb
 - spec/plugin/param_matchers_spec.rb
+- spec/plugin/partials_spec.rb
 - spec/plugin/pass_spec.rb
 - spec/plugin/path_matchers_spec.rb
 - spec/plugin/path_spec.rb
 - spec/plugin/per_thread_caching_spec.rb
 - spec/plugin/render_each_spec.rb
 - spec/plugin/render_spec.rb
+- spec/plugin/shared_vars_spec.rb
 - spec/plugin/sinatra_helpers_spec.rb
 - spec/plugin/slash_path_empty_spec.rb
 - spec/plugin/static_spec.rb