roda-cj 0.9.1

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

data/lib/roda/plugins/streaming.rb

@@ -0,0 +1,165 @@
+class Roda
+  module RodaPlugins
+    # The streaming plugin adds support for streaming responses
+    # from roda using the +stream+ method:
+    #
+    #   plugin :streaming
+    #
+    #   route do |r|
+    #     stream do |out|
+    #       ['a', 'b', 'c'].each{|v| out << v; sleep 1}
+    #     end
+    #   end
+    #
+    # In order for streaming to work, any webservers used in
+    # front of the roda app must not buffer responses.
+    #
+    # 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.
+    #
+    # 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
+      # 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={}, &back)
+          @scheduler = opts[:scheduler] || Scheduler.new(self)
+          @back = back.to_proc
+          @keep_open = opts[:keep_open]
+          @callbacks = []
+          @closed = false
+
+          if opts[:callback]
+            callback(&opts[:callback])
+          end
+        end
+
+        # Add output to the streaming response body.
+        def <<(data)
+          @scheduler.schedule{@front.call(data.to_s)}
+          self
+        end
+
+        # Add the given block as a callback to call when the block closes.
+        def callback(&block)
+          return yield if closed?
+          @callbacks << block
+        end
+
+        # Alias to callback for EventMachine compatibility.
+        alias errback callback
+
+        # If not already closed, close the connection, and call
+        # any callbacks.
+        def close
+          return if closed?
+          @closed = true
+          @scheduler.schedule{@callbacks.each{|c| c.call}}
+        end
+
+        # Whether the connection has already been closed.
+        def closed?
+          @closed
+        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
+        end
+      end
+
+      module InstanceMethods
+        # 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)
+          opts = opts.merge(:scheduler=>EventMachine) if !opts.has_key?(:scheduler) && env['async.callback']
+
+          if opts[:loop]
+            block = proc do |out|
+              until out.closed?
+                yield(out)
+              end
+            end
+          end
+
+          res = response
+          request.halt [res.status || 200, res.headers, Stream.new(opts, &block)]
+        end
+      end
+    end
+
+    register_plugin(:streaming, Streaming)
+  end
+end

data/lib/roda/version.rb

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