roda 0.9.0 → 1.0.0

data/lib/roda/plugins/render.rb

@@ -27,10 +27,11 @@ class Roda
     #
     # The following options are supported:
     #
-    # :cache :: A specific cache to store templates in, or nil/false to not
-    #           cache templates (useful for development), defaults to true to
-    #           automatically use the default template cache.
+    # :cache :: nil/false to not cache templates (useful for development), defaults
+    #           to true 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 handles postfix
+    #            conditions inside <%= %> 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'.
@@ -50,6 +51,9 @@ class Roda
     # There are a couple of additional options to +view+ and +render+ that are
     # available at runtime:
     #
+    # :content :: Only respected by +view+, provides the content to render
+    #             inside the layout, instead of rendering a template to get
+    #             the content.
     # :inline :: Use the value given as the template code, instead of looking
     #            for template code in a file.
     # :locals :: Hash of local variables to make available inside the template.
@@ -65,31 +69,9 @@ class Roda
     # 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.
     module Render
-      # Default template cache.  Thread-safe so that multiple threads can
-      # simultaneously use the cache.
-      class Cache
-        # Mutex used to synchronize access to the cache.  Uses a
-        # singleton mutex to reduce memory.
-        MUTEX = ::Mutex.new
-
-        # Initialize the cache.
-        def initialize
-          MUTEX.synchronize{@cache = {}}
-        end
-        
-        # Clear the cache.
-        alias clear initialize
-
-        # If the template is found in the cache under the given key,
-        # return it, otherwise yield to get the template, and
-        # store the template under the given key
-        def fetch(key)
-          unless template = MUTEX.synchronize{@cache[key]}
-            template = yield
-            MUTEX.synchronize{@cache[key] = template}
-          end
-
-          template
+      def self.load_dependencies(app, opts={})
+        if opts[:escape]
+          app.plugin :_erubis_escaping
         end
       end
 
@@ -112,8 +94,10 @@ class Roda
         if RUBY_VERSION >= "1.9"
           opts[:opts][:default_encoding] ||= Encoding.default_external
         end
-        cache = opts.fetch(:cache, true)
-        opts[:cache] = Cache.new if cache == true
+        if opts[:escape]
+          opts[:opts][:engine_class] = ErubisEscaping::Eruby
+        end
+        opts[:cache] = app.thread_safe_cache if opts.fetch(:cache, true)
       end
 
       module ClassMethods
@@ -125,7 +109,7 @@ class Roda
           opts = subclass.opts[:render] = render_opts.dup
           opts[:layout_opts] = opts[:layout_opts].dup
           opts[:opts] = opts[:opts].dup
-          opts[:cache] = Cache.new if opts[:cache]
+          opts[:cache] = thread_safe_cache if opts[:cache]
         end
 
         # Return the render options for this class.
@@ -179,7 +163,7 @@ class Roda
             end
           end
 
-          content = render(template, opts)
+          content = opts[:content] || render(template, opts)
 
           if layout = opts.fetch(:layout, render_opts[:layout])
             if layout_opts = opts[:layout_opts]
@@ -198,7 +182,10 @@ class Roda
         # to get the template.
         def cached_template(path, &block)
           if cache = render_opts[:cache]
-            cache.fetch(path, &block)
+            unless template = cache[path]
+              template = cache[path] = yield
+            end
+            template
           else
             yield
           end

data/lib/roda/plugins/render_each.rb

@@ -0,0 +1,61 @@
+class Roda
+  module RodaPlugins
+    # The render_each plugin allows you to render a template for each
+    # value in an enumerable, returning the concatention of all of the
+    # template renderings.  For example:
+    #
+    #   render_each([1,2,3], :foo)
+    #
+    # will render the +foo+ template 3 times.  Each time the template
+    # is rendered, the local variable +foo+ will contain the given
+    # value (e.g. on the first rendering +foo+ is 1).
+    #
+    # You can pass additional render options via an options hash:
+    #
+    #   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)
+    #
+    # Will render the +foo+ template, but the local variable used inside
+    # the template will be +bar+.  You can use <tt>:local=>nil</tt> to
+    # not set a local variable inside the template.
+    module RenderEach
+      module InstanceMethods
+        EMPTY_STRING = ''.freeze
+
+        # For each value in enum, render the given template using the
+        # given opts.  The template and options hash are passed to +render+.
+        # Additional options supported:
+        # :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={})
+          if as = opts.has_key?(:local)
+            as = opts[:local]
+          else
+            as = template.to_s.to_sym
+          end
+
+          if as
+            opts = opts.dup
+            if locals = opts[:locals]
+              locals = opts[:locals] = locals.dup
+            else
+              locals = opts[:locals] = {}
+            end
+          end
+
+          enum.map do |v|
+            locals[as] = v if as
+            render(template, opts)
+          end.join
+        end
+      end
+    end
+
+    register_plugin(:render_each, RenderEach)
+  end
+end

data/lib/roda/plugins/symbol_matchers.rb

@@ -0,0 +1,79 @@
+class Roda
+  module RodaPlugins
+    # The symbol_matchers plugin allows you do define custom regexps to use
+    # for specific symbols.  For example, if you have a route such as:
+    #
+    #   r.on :username do
+    #     # ...
+    #   end
+    #
+    # By default this will match all nonempty segments.  However, if your usernames
+    # must be 6-20 characters, and can only contain +a-z+ and +0-9+, you can do:
+    #
+    #   plugin :symbol_matchers
+    #   symbol_matcher :username, /([a-z0-9]{6,20})/
+    #
+    # Then the route will only if the path is +/foobar123+, but not if it is
+    # +/foo+, +/FooBar123+, or +/foobar_123+.
+    #
+    # Note that this feature does not apply to just symbols, but also to
+    # embedded colons in strings, so the following:
+    #
+    #   r.on "users/:username" do
+    #     # ...
+    #   end
+    #
+    # Would match +/users/foobar123+, but not +/users/foo+, +/users/FooBar123+,
+    # or +/users/foobar_123+.
+    #
+    # By default, this plugin sets up the following symbol matchers:
+    #
+    # :d :: <tt>/(\d+)/</tt>, a decimal segment
+    # :format :: <tt>/(?:\.(\w+))?/</tt>, an optional format/extension
+    # :opt :: <tt>/(?:\/([^\/]+))?</tt>, an optional segment
+    # :optd :: <tt>/(?:\/(\d+))?</tt>, an optional decimal segment
+    # :rest :: <tt>/(.*)/</tt>, all remaining characters, if any
+    # :w :: <tt>/(\w+)/</tt>, a alphanumeric segment
+    #
+    # Note that because of how segment matching works, :format, :opt, and :optd
+    # are only going to work inside of a string, like this:
+    #
+    #   r.is "album:opt" do |id| end
+    #   # matches /album (yielding nil) and /album/foo (yielding "foo")
+    #   # does not match /album/ or /album/foo/bar
+    module SymbolMatchers
+      def self.configure(app)
+        app.symbol_matcher(:d, /(\d+)/)
+        app.symbol_matcher(:format, /(?:\.(\w+))?/)
+        app.symbol_matcher(:opt, /(?:\/([^\/]+))?/)
+        app.symbol_matcher(:optd, /(?:\/(\d+))?/)
+        app.symbol_matcher(:rest, /(.*)/)
+        app.symbol_matcher(:w, /(\w+)/)
+      end
+
+      module ClassMethods
+        # Set the regexp to use for the given symbol, instead of the default.
+        def symbol_matcher(s, re)
+          request_module{define_method(:"match_symbol_#{s}"){re}}
+        end
+      end
+
+      module RequestMethods
+        private
+
+        # Allow for symbol specific regexps, by using match_symbol_#{s} if
+        # defined.  If not defined, calls super for the default behavior.
+        def _match_symbol_regexp(s)
+          meth = :"match_symbol_#{s}"
+          if respond_to?(meth)
+            send(meth)
+          else
+            super
+          end
+        end
+      end
+    end
+
+    register_plugin(:symbol_matchers, SymbolMatchers)
+  end
+end

data/lib/roda/plugins/symbol_views.rb

@@ -0,0 +1,40 @@
+class Roda
+  module RodaPlugins
+    # The symbol_views plugin allows match blocks to return
+    # symbols, and consider those symbols as views to use for the
+    # response body.  So you can take code like:
+    #
+    #   r.root do
+    #     view :index
+    #   end
+    #   r.is "foo" do
+    #     view :foo
+    #   end
+    #
+    # and DRY it up:
+    #
+    #   r.root do
+    #     :index
+    #   end
+    #   r.is "foo" do
+    #     :foo
+    #   end
+    module SymbolViews
+      module RequestMethods
+        private
+
+        # If the block result is a symbol, consider the symbol a
+        # template name and use the template view as the body.
+        def block_result_body(result)
+          if result.is_a?(Symbol)
+            scope.view(result)
+          else
+            super
+          end
+        end
+      end
+    end
+
+    register_plugin(:symbol_views, SymbolViews)
+  end
+end

data/lib/roda/plugins/view_subdirs.rb

@@ -0,0 +1,53 @@
+class Roda
+  module RodaPlugins
+    # The view_subdirs plugin is designed for sites that have
+    # outgrown a flat view directory and use subdirectories
+    # for views.  It allows you to set the view directory to
+    # use, and template names that do not contain a slash will
+    # automatically use that view subdirectory.  Example:
+    #
+    #   plugin :render
+    #   plugin :view_subdirs
+    #
+    #   route do |r|
+    #     r.on "users" do
+    #       set_view_subdir 'users'
+    #       
+    #       r.get :id do
+    #         view 'profile' # uses ./views/users/profile.erb
+    #       end
+    #
+    #       r.get 'list' do
+    #         view 'lists/users' # uses ./views/lists/users.erb
+    #       end
+    #     end
+    #   end
+    #
+    # This plugin should be loaded after the render plugin, since
+    # it works by overriding parts of the render plugin.
+    module ViewSubdirs
+      module InstanceMethods
+        # Set the view subdirectory to use.  This can be set to nil
+        # to not use a view subdirectory.
+        def set_view_subdir(v)
+          @_view_subdir = v
+        end
+
+        private
+
+        # Override the template name to use the view subdirectory if the
+        # there is a view subdirectory and the template name does not
+        # contain a slash.
+        def template_path(template, opts)
+          t = template.to_s
+          if (v = @_view_subdir) && t !~ /\//
+            template = "#{v}/#{t}"
+          end
+          super
+        end
+      end
+    end
+
+    register_plugin(:view_subdirs, ViewSubdirs)
+  end
+end

data/lib/roda/version.rb

@@ -0,0 +1,3 @@
+class Roda
+  RodaVersion = '1.0.0'.freeze
+end

data/spec/matchers_spec.rb

@@ -467,14 +467,28 @@ describe "path matchers" do
     status('/useradf').should == 404
   end
 
-  it "matching the root" do
+  it "matching the root with a string" do
     app do |r|
-      r.on "" do
+      r.is "" do
         "Home"
       end
     end
 
     body.should == 'Home'
+    status("//").should == 404
+    status("/foo").should == 404
+  end
+
+  it "matching the root with the root method" do
+    app do |r|
+      r.root do
+        "Home"
+      end
+    end
+
+    body.should == 'Home'
+    status('REQUEST_METHOD'=>'POST').should == 404
+    status("//").should == 404
     status("/foo").should == 404
   end
 end
@@ -614,18 +628,34 @@ describe "request verb methods" do
   end
 end
 
+describe "all matcher" do
+  it "should match only all all arguments match" do
+    app do |r|
+      r.is :all=>['foo', :y] do |file|
+        file
+      end
+    end
+
+    body("/foo/bar").should == 'bar'
+    status.should == 404
+    status("/foo").should == 404
+    status("/foo/").should == 404
+    status("/foo/bar/baz").should == 404
+  end
+end
+
 describe "extension matcher" do
   it "should match given file extensions" do
     app do |r|
-      r.on "styles" do
+      r.on "css" do
         r.on :extension=>"css" do |file|
           file
         end
       end
     end
 
-    body("/styles/reset.css").should == 'reset'
-    status("/styles/reset.bar").should == 404
+    body("/css/reset.css").should == 'reset'
+    status("/css/reset.bar").should == 404
   end
 end
 
@@ -656,3 +686,29 @@ describe "route block that returns string" do
     body.should == '+1'
   end
 end
+
+describe "hash_matcher" do
+  it "should enable the handling of arbitrary hash keys" do
+    app(:bare) do 
+      hash_matcher(:foos){|v| consume(self.class.cached_matcher(:"foos-#{v}"){/((?:foo){#{v}})/})}
+      route do |r|
+        r.is :foos=>1 do |f|
+          "1#{f}"
+        end
+        r.is :foos=>2 do |f|
+          "2#{f}"
+        end
+        r.is :foos=>3 do |f|
+          "3#{f}"
+        end
+      end
+    end
+
+    body("/foo").should == '1foo'
+    body("/foofoo").should == '2foofoo'
+    body("/foofoofoo").should == '3foofoofoo'
+    status("/foofoofoofoo").should == 404
+    status.should == 404
+  end
+end
+

data/spec/plugin/_erubis_escaping_spec.rb

@@ -0,0 +1,29 @@
+require File.expand_path("spec_helper", File.dirname(File.dirname(__FILE__)))
+
+begin
+  require 'erubis'
+  require 'tilt/erb'
+  begin
+    require 'tilt/erubis'
+  rescue LoadError
+    # Tilt 1 support
+  end
+rescue LoadError
+  warn "tilt or erubis not installed, skipping _erubis_escaping plugin test"  
+else
+describe "_erubis_escaping plugin" do
+  before do
+    app(:bare) do
+      plugin :render, :escape=>true
+
+      route do |r|
+        render(:inline=>'<%= "<>" %> <%== "<>" %><%= "<>" if false %>')
+      end
+    end
+  end
+
+  it "should escape inside <%= %> and not inside <%== %>, and handle postfix conditionals" do
+    body.should == '&lt;&gt; <>'
+  end
+end
+end