roda 0.9.0

data/lib/roda/plugins/indifferent_params.rb

@@ -0,0 +1,47 @@
+class Roda
+  module RodaPlugins
+    # The indifferent_params plugin adds a +params+ instance
+    # method which returns a copy of the request params hash
+    # that will automatically convert symbols to strings.
+    # Example:
+    #
+    #   plugin :indifferent_params
+    #
+    #   route do |r|
+    #     params[:foo]
+    #   end
+    #
+    # The params hash is initialized lazily, so you only pay
+    # the penalty of copying the request params if you call
+    # the +params+ method.
+    module IndifferentParams
+      module InstanceMethods
+        # A copy of the request params that will automatically
+        # convert symbols to strings.
+        def params
+          @_params ||= indifferent_params(request.params)
+        end
+
+        private
+
+        # Recursively process the request params and convert
+        # hashes to support indifferent access, leaving
+        # other values alone.
+        def indifferent_params(params)
+          case params 
+          when Hash
+            h = Hash.new{|h, k| h[k.to_s] if Symbol === k}
+            params.each{|k, v| h[k] = indifferent_params(v)}
+            h
+          when Array
+            params.map{|x| indifferent_params(x)}
+          else
+            params
+          end
+        end
+      end  
+    end
+
+    register_plugin(:indifferent_params, IndifferentParams)
+  end
+end

data/lib/roda/plugins/middleware.rb

@@ -0,0 +1,88 @@
+class Roda
+  module RodaPlugins
+    # The middleware plugin allows the Roda app to be used as
+    # rack middleware.
+    #
+    # In the example below, requests to /mid will return Mid
+    # by the Mid middleware, and requests to /app will not be
+    # matched by the Mid middleware, so they will be forwarded
+    # to App.
+    #
+    #   class Mid < Roda
+    #     plugin :middleware
+    #
+    #     route do |r|
+    #       r.is "mid" do
+    #         "Mid"
+    #       end
+    #     end
+    #   end
+    #
+    #   class App < Roda
+    #     use Mid
+    #
+    #     route do |r|
+    #       r.is "app" do
+    #         "App"
+    #       end
+    #     end
+    #   end
+    #
+    #   run App
+    #
+    # Note that once you use the middleware plugin, you can only use the
+    # Roda app as middleware, and you will get errors if you attempt to
+    # use it as a regular app.
+    module Middleware
+      # Forward instances are what is actually used as middleware.
+      class Forwarder
+        # Store the current middleware and the next middleware to call.
+        def initialize(mid, app)
+          @mid = mid.app
+          @app = app
+        end
+
+        # When calling the middleware, first call the current middleware.
+        # If this returns a result, return that result directly.  Otherwise,
+        # pass handling of the request to the next middleware.
+        def call(env)
+          res = nil
+
+          call_next = catch(:next) do
+            res = @mid.call(env)
+            false
+          end
+
+          if call_next
+            @app.call(env)
+          else
+            res
+          end
+        end
+      end
+
+      module ClassMethods
+        # If an argument is given, this is a middleware app, so create a Forwarder.
+        # Otherwise, this is a usual instance creation, so call super.
+        def new(app=nil)
+          if app
+            Forwarder.new(self, app)
+          else
+            super()
+          end
+        end
+
+        # Override the route block so that if no route matches, we throw so
+        # that the next middleware is called.
+        def route(&block)
+          super do |r|
+            instance_exec(r, &block)
+            throw :next, true
+          end
+        end
+      end
+    end
+
+    register_plugin(:middleware, Middleware)
+  end
+end

data/lib/roda/plugins/multi_route.rb

@@ -0,0 +1,77 @@
+class Roda
+  module RodaPlugins
+    # The multi_route plugin allows for multiple named routes, which the
+    # main route block can dispatch to by name at any point.  If the named
+    # route doesn't handle the request, execution will continue, and if the
+    # named route does handle the request, the response by the named route
+    # will be returned.
+    #
+    # Example:
+    #
+    #   plugin :multi_route
+    #
+    #   route(:foo) do |r|
+    #     r.is 'bar' do
+    #       '/foo/bar'
+    #     end
+    #   end
+    #
+    #   route(:bar) do |r|
+    #     r.is 'foo' do
+    #       '/bar/foo'
+    #     end
+    #   end
+    #
+    #   route do |r|
+    #     r.on "foo" do
+    #       route :foo
+    #     end
+    #
+    #     r.on "bar" do
+    #       route :bar
+    #     end
+    #   end
+    #
+    # Note that in multi-threaded code, you should not attempt to add a
+    # named route after accepting requests.
+    module MultiRoute
+      # Initialize storage for the named routes.
+      def self.configure(app)
+        app.instance_exec{@named_routes ||= {}}
+      end
+
+      module ClassMethods
+        # Copy the named routes into the subclass when inheriting.
+        def inherited(subclass)
+          super
+          subclass.instance_variable_set(:@named_routes, @named_routes.dup)
+        end
+
+        # Return the named route with the given name.
+        def named_route(name)
+          @named_routes[name]
+        end
+
+        # If the given route has a named, treat it as a named route and
+        # store the route block.  Otherwise, this is the main route, so
+        # call super.
+        def route(name=nil, &block)
+          if name
+            @named_routes[name] = block
+          else
+            super(&block)
+          end
+        end
+      end
+
+      module InstanceMethods
+        # Dispatch to the named route with the given name.
+        def route(name)
+          instance_exec(request, &self.class.named_route(name))
+        end
+      end
+    end
+
+    register_plugin(:multi_route, MultiRoute)
+  end
+end

data/lib/roda/plugins/not_found.rb

@@ -0,0 +1,62 @@
+class Roda
+  module RodaPlugins
+    # The not_found plugin adds a +not_found+ class method which sets
+    # a block that is called whenever a 404 response with an empty body
+    # would be returned.  The usual use case for this is the desire for
+    # nice error pages if the page is not found.
+    #
+    # You can provide the block with the plugin call:
+    #
+    #   plugin :not_found do
+    #     "Where did it go?"
+    #   end
+    #   
+    # Or later via a separate call to +not_found+:
+    #
+    #   plugin :not_found
+    #
+    #   not_found do
+    #     "Where did it go?"
+    #   end
+    module NotFound
+      # If a block is given, install the block as the not_found handler.
+      def self.configure(app, &block)
+        if block
+          app.not_found(&block)
+        end
+      end
+
+      module ClassMethods
+        # Install the given block as the not_found handler.
+        def not_found(&block)
+          define_method(:not_found, &block)
+          private :not_found
+        end
+      end
+
+      module InstanceMethods
+        private
+
+        # If routing returns a 404 response with an empty body, call
+        # the not_found handler.
+        def _route
+          result = super
+
+          if result[0] == 404 && (v = result[2]).is_a?(Array) && v.empty?
+            super{not_found}
+          else
+            result
+          end
+        end
+
+        # Use an empty not_found_handler by default, so that loading
+        # the plugin without defining a not_found handler doesn't
+        # break things.
+        def not_found
+        end
+      end
+    end
+
+    register_plugin(:not_found, NotFound)
+  end
+end

data/lib/roda/plugins/pass.rb

@@ -0,0 +1,34 @@
+class Roda
+  module RodaPlugins
+    # The pass plugin adds a request +pass+ method to skip the current +on+
+    # block as if it did not match.
+    #
+    #   plugin :pass
+    #
+    #   route do |r|
+    #     r.on "foo/:bar" do |bar|
+    #       pass if bar == 'baz'
+    #       "/foo/#{bar} (not baz)"
+    #     end
+    #
+    #     r.on "foo/baz" do
+    #       "/foo/baz"
+    #     end
+    #   end
+    module Pass
+      module RequestMethods
+        # Handle passing inside the current block.
+        def on(*)
+          catch(:pass){super}
+        end
+
+        # Skip the current #on block as if it did not match.
+        def pass
+          throw :pass
+        end
+      end
+    end
+
+    register_plugin(:pass, Pass)
+  end
+end

data/lib/roda/plugins/render.rb

@@ -0,0 +1,217 @@
+require "tilt"
+
+class Roda
+  module RodaPlugins
+    # The render plugin adds support for template rendering using the tilt
+    # library.  Two methods are provided for template rendering, +view+
+    # (which uses the layout) and +render+ (which does not).
+    #
+    #   plugin :render
+    #
+    #   route do |r|
+    #     r.is 'foo' do
+    #       view('foo') # renders views/foo.erb inside views/layout.erb
+    #     end
+    #
+    #     r.is 'bar' do
+    #       render('bar') # renders views/bar.erb
+    #     end
+    #   end
+    #
+    # You can provide options to the plugin method, or later by modifying
+    # +render_opts+.
+    #
+    #   plugin :render, :engine=>'haml'
+    #
+    #   render_opts[:views] = 'admin_views'
+    #
+    # 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.
+    # :engine :: The tilt engine to use for rendering, defaults to 'erb'.
+    # :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'}.
+    # :views :: The directory holding the view files, defaults to 'views' in the
+    #           current directory.
+    #
+    # Most of these options can be overridden at runtime by passing options
+    # to the +view+ or +render+ methods:
+    #
+    #   view('foo', :ext=>'html.erb')
+    #   render('foo', :views=>'admin_views')
+    #
+    # There are a couple of additional options to +view+ and +render+ that are
+    # available at runtime:
+    #
+    # :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.
+    # :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.
+    #
+    # Here's how those options are used:
+    #
+    #   view(:inline=>'<%= @foo %>')
+    #   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.
+    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
+        end
+      end
+
+      # Setup default rendering options.  See Render for details.
+      def self.configure(app, opts={})
+        if app.opts[:render]
+          app.opts[:render].merge!(opts)
+        else 
+          app.opts[:render] = opts.dup
+        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[:opts] ||= (opts[:opts] || {}).dup
+        opts[:opts][:outvar] ||= '@_out_buf'
+        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
+      end
+
+      module ClassMethods
+        # Copy the rendering options into the subclass, duping
+        # them as necessary to prevent changes in the subclass
+        # affecting the parent class.
+        def inherited(subclass)
+          super
+          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]
+        end
+
+        # Return the render options for this class.
+        def render_opts
+          opts[:render]
+        end
+      end
+
+      module InstanceMethods
+        # Render the given template. See Render for details.
+        def render(template, 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)
+          end.render(self, opts[:locals], &block)
+        end
+
+        # Return the render options for the instance's class.
+        def render_opts
+          self.class.render_opts
+        end
+
+        # Render the given template.  If there is a default layout
+        # for the class, take the result of the template rendering
+        # and render it inside the layout.  See Render for details.
+        def view(template, opts={})
+          if template.is_a?(Hash)
+            if opts.empty?
+              opts = template
+            else
+              opts = opts.merge(template)
+            end
+          end
+
+          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)
+            end
+
+            content = render(layout, layout_opts||{}){content}
+          end
+
+          content
+        end
+
+        private
+
+        # If caching templates, attempt to retrieve the template from the cache.  Otherwise, just yield
+        # to get the template.
+        def cached_template(path, &block)
+          if cache = render_opts[:cache]
+            cache.fetch(path, &block)
+          else
+            yield
+          end
+        end
+
+        # The path for the given template.
+        def template_path(template, opts)
+          render_opts = render_opts()
+          "#{opts[:views] || render_opts[:views]}/#{template}.#{opts[:ext] || render_opts[:ext] || render_opts[:engine]}"
+        end
+      end
+    end
+
+    register_plugin(:render, Render)
+  end
+end