roda 0.9.0 → 1.0.0

data/lib/roda/plugins/header_matchers.rb

@@ -35,14 +35,14 @@ class Roda
 
         # Match if the given mimetype is one of the accepted mimetypes.
         def match_accept(mimetype)
-          if env["HTTP_ACCEPT"].to_s.split(',').any?{|s| s.strip == mimetype}
+          if @env["HTTP_ACCEPT"].to_s.split(',').any?{|s| s.strip == mimetype}
             response["Content-Type"] = mimetype
           end
         end
 
         # Match if the given uppercase key is present inside the environment.
         def match_header(key)
-          env[key.upcase.tr("-","_")]
+          @env[key.upcase.tr("-","_")]
         end
 
         # Match if the host of the request is the same as the hostname.

data/lib/roda/plugins/json.rb

@@ -0,0 +1,84 @@
+require 'json'
+
+class Roda
+  module RodaPlugins
+    # The json plugin allows match blocks to return
+    # arrays or hashes, and have those arrays or hashes be
+    # converted to json which is used as the response body.
+    # It also sets the response content type to application/json.
+    # So you can take code like:
+    #
+    #   r.root do
+    #     response['Content-Type'] = 'application/json'
+    #     [1, 2, 3].to_json
+    #   end
+    #   r.is "foo" do
+    #     response['Content-Type'] = 'application/json'
+    #     {'a'=>'b'}.to_json
+    #   end
+    #
+    # and DRY it up:
+    #
+    #   plugin :json
+    #   r.root do
+    #     [1, 2, 3]
+    #   end
+    #   r.is "foo" do
+    #     {'a'=>'b'}
+    #   end
+    #
+    # By default, only arrays and hashes are handled, but you
+    # can automatically convert other types to json by adding
+    # them to json_result_classes:
+    #
+    #   plugin :json
+    #   json_result_classes << Sequel::Model
+    module Json
+      # Set the classes to automatically convert to JSON
+      def self.configure(app)
+        app.instance_eval do
+          @json_result_classes ||= [Array, Hash]
+        end
+      end
+
+      module ClassMethods
+        # The classes that should be automatically converted to json
+        attr_reader :json_result_classes
+
+        # Copy the json_result_classes into the subclass
+        def inherited(subclass)
+          super
+          subclass.instance_variable_set(:@json_result_classes, json_result_classes.dup)
+        end
+      end
+
+      module RequestMethods
+        CONTENT_TYPE = 'Content-Type'.freeze
+        APPLICATION_JSON = 'application/json'.freeze
+
+        private
+
+        # If the result is an instance of one of the json_result_classes,
+        # convert the result to json and return it as the body, using the
+        # application/json content-type.
+        def block_result_body(result)
+          case result
+          when *self.class.roda_class.json_result_classes
+            response[CONTENT_TYPE] = APPLICATION_JSON
+            convert_to_json(result)
+          else
+            super
+          end
+        end
+
+        # Convert the given object to JSON.  Uses to_json by default,
+        # but can be overridden to use a different implementation.
+        def convert_to_json(obj)
+          obj.to_json
+        end
+      end
+    end
+
+    register_plugin(:json, Json)
+  end
+end

data/lib/roda/plugins/multi_route.rb

@@ -1,39 +1,56 @@
 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.
+    # main route block can dispatch to by name at any point by calling +route+.
+    # If the named route doesn't handle the request, execution will continue,
+    # and if the named route does handle the request, the response returned by
+    # the named route will be returned.
+    #
+    # In addition, this also adds the +r.multi_route+ method, which will assume
+    # check if the first segment in the path matches a named route, and dispatch
+    # to that named route.
     #
     # Example:
     #
     #   plugin :multi_route
     #
-    #   route(:foo) do |r|
+    #   route('foo') do |r|
     #     r.is 'bar' do
     #       '/foo/bar'
     #     end
     #   end
     #
-    #   route(:bar) do |r|
+    #   route('bar') do |r|
     #     r.is 'foo' do
     #       '/bar/foo'
     #     end
     #   end
     #
     #   route do |r|
+    #     r.multi_route
+    #
+    #     # or
+    #
     #     r.on "foo" do
-    #       route :foo
+    #       r.route 'foo'
     #     end
     #
     #     r.on "bar" do
-    #       route :bar
+    #       r.route 'bar'
     #     end
     #   end
     #
     # Note that in multi-threaded code, you should not attempt to add a
     # named route after accepting requests.
+    #
+    # If you want to use the +r.multi_route+ method, use string names for the
+    # named routes.  Also, you can provide a block to +r.multi_route+ that is
+    # called if the route matches but the named route did not handle the
+    # request:
+    #
+    #   r.multi_route do
+    #     "default body"
+    #   end
     module MultiRoute
       # Initialize storage for the named routes.
       def self.configure(app)
@@ -47,6 +64,11 @@ class Roda
           subclass.instance_variable_set(:@named_routes, @named_routes.dup)
         end
 
+        # An names for the currently stored named routes
+        def named_routes
+          @named_routes.keys
+        end
+
         # Return the named route with the given name.
         def named_route(name)
           @named_routes[name]
@@ -64,10 +86,28 @@ class Roda
         end
       end
 
-      module InstanceMethods
+      module RequestClassMethods
+        # A regexp matching any of the current named routes.
+        def named_route_regexp
+          @named_route_regexp ||= /(#{Regexp.union(roda_class.named_routes)})/
+        end
+      end
+
+      module RequestMethods
+        # Check if the first segment in the path matches any of the current
+        # named routes.  If so, call that named route.  If not, do nothing.
+        # If the named route does not handle the request, and a block
+        # is given, yield to the block.
+        def multi_route
+          on self.class.named_route_regexp do |section|
+            route(section)
+            yield if block_given?
+          end
+        end
+
         # Dispatch to the named route with the given name.
         def route(name)
-          instance_exec(request, &self.class.named_route(name))
+          scope.instance_exec(self, &self.class.roda_class.named_route(name))
         end
       end
     end

data/lib/roda/plugins/not_allowed.rb

@@ -0,0 +1,140 @@
+class Roda
+  module RodaPlugins
+    # The not_allowed plugin makes Roda attempt to automatically
+    # support the 405 Method Not Allowed response status. The plugin
+    # changes the +r.get+ and +r.post+ verb methods to automatically
+    # return a 405 status if they are called with any arguments, and
+    # the arguments match but the request method does not match. So
+    # this code:
+    #
+    #   r.get '' do
+    #     "a"
+    #   end
+    #
+    # will return a 200 response for <tt>GET /</tt> and a 405
+    # response for <tt>POST /</tt>.
+    #
+    # This plugin also changes the +r.is+ method so that if you use
+    # a verb method inside +r.is+, it returns a 405 status if none
+    # of the verb methods match.  So this code:
+    #
+    #   r.is '' do
+    #     r.get do
+    #       "a"
+    #     end
+    #
+    #     r.post do
+    #       "b"
+    #     end
+    #   end
+    #
+    # will return a 200 response for <tt>GET /</tt> and <tt>POST /</tt>,
+    # but a 405 response for <tt>PUT /</tt>.
+    #
+    # Note that this plugin will probably not do what you want for
+    # code such as:
+    #
+    #   r.get '' do
+    #     "a"
+    #   end
+    #
+    #   r.post '' do
+    #     "b"
+    #   end
+    #
+    # Since for a <tt>POST /</tt> request, when +r.get+ method matches
+    # the path but not the request method, it will return an immediate
+    # 405 response.  You must DRY up this code for it work correctly,
+    # like this:
+    #
+    #   r.is '' do
+    #     r.get do
+    #       "a"
+    #     end
+    #
+    #     r.post do
+    #       "b"
+    #     end
+    #   end
+    #
+    # In all cases where it uses a 405 response, it also sets the +Allow+
+    # header in the response to contain the request methods supported.
+    # 
+    # To make this affect the verb methods added by the all_verbs plugin,
+    # load this plugin first.
+    module NotAllowed
+      # Redefine the +r.get+ and +r.post+ methods when loading the plugin.
+      def self.configure(app)
+        app.request_module do
+          app::RodaRequest.def_verb_method(self, :get)
+          app::RodaRequest.def_verb_method(self, :post)
+        end
+      end
+
+      module RequestClassMethods
+        # Define a method named +verb+ in the given module which will
+        # return a 405 response if the method is called with any
+        # arguments and the arguments terminally match but the
+        # request method does not.
+        #
+        # If called without any arguments, check to see if the call
+        # is inside a terminal match, and in that case record the
+        # request method used.
+        def def_verb_method(mod, verb)
+          mod.class_eval(<<-END, __FILE__, __LINE__+1)
+            def #{verb}(*args, &block)
+              if args.empty?
+                @_is_verbs << "#{verb.to_s.upcase}" if @_is_verbs
+                always(&block) if #{verb == :get ? :is_get : verb}?
+              else
+                args << ::Roda::RodaPlugins::Base::RequestMethods::TERM
+                if_match(args) do |*args|
+                  if #{verb == :get ? :is_get : verb}?
+                    block_result(yield(*args))
+                    throw :halt, response.finish
+                  end
+                  response.status = 405
+                  response['Allow'] = '#{verb.to_s.upcase}'
+                  nil
+                end
+              end
+            end
+          END
+        end
+      end
+
+      module RequestMethods
+        # Keep track of verb calls inside the block.  If there are any
+        # verb calls inside the block, but the block returned, assume
+        # that the verb calls inside the block did not match, and
+        # since there was already a successful terminal match, the
+        # request method must not be allowed, so return a 405
+        # response in that case.
+        def is(*verbs)
+          super(*verbs) do
+            begin
+              @_is_verbs = []
+
+              ret = if verbs.empty?
+                yield
+              else
+                yield(*captures)
+              end
+
+              unless @_is_verbs.empty?
+                response.status = 405
+                response['Allow'] = @_is_verbs.join(', ')
+              end
+
+              ret
+            ensure
+              @_is_verbs = nil
+            end
+          end
+        end
+      end
+    end
+
+    register_plugin(:not_allowed, NotAllowed)
+  end
+end

data/lib/roda/plugins/pass.rb

@@ -1,6 +1,6 @@
 class Roda
   module RodaPlugins
-    # The pass plugin adds a request +pass+ method to skip the current +on+
+    # The pass plugin adds a request +pass+ method to skip the current match
     # block as if it did not match.
     #
     #   plugin :pass
@@ -17,14 +17,21 @@ class Roda
     #   end
     module Pass
       module RequestMethods
-        # Handle passing inside the current block.
-        def on(*)
+        # Skip the current match block as if it did not match.
+        def pass
+          throw :pass
+        end
+
+        private
+
+        # Handle passing inside the match block.
+        def always
           catch(:pass){super}
         end
 
-        # Skip the current #on block as if it did not match.
-        def pass
-          throw :pass
+        # Handle passing inside the match block.
+        def if_match(_)
+          catch(:pass){super}
         end
       end
     end

data/lib/roda/plugins/per_thread_caching.rb

@@ -0,0 +1,70 @@
+class Roda
+  module RodaPlugins
+    # The per_thread_caching plugin changes the default cache
+    # from being a shared thread safe cache to a separate cache per
+    # thread.  This means getting or setting values no longer
+    # needs a mutex on non-MRI ruby implementations, which may be
+    # faster when using a thread pool.  However, since the caches
+    # are no longer shared, this will take up more memory.
+    #
+    # Note that it does not make sense to use this plugin on MRI,
+    # since the default cache on MRI doesn't use a mutex as it
+    # is already thread safe due to the GVL.
+    #
+    # Using this plugin changes the matcher regexp cache to use
+    # per-thread caches, and changes the default for future
+    # thread-safe caches to use per-thread caches.
+    #
+    # If you want the render plugin's template cache to use
+    # per-thread caches, you should load this plugin before the
+    # render plugin.
+    module PerThreadCaching
+      def self.configure(app)
+        app::RodaRequest.match_pattern_cache = app.thread_safe_cache
+      end
+
+      class Cache
+        # Mutex used to ensure multiple per-thread caches
+        # don't use the same key
+        MUTEX = ::Mutex.new
+
+        n = 0
+        # Auto incrementing number proc used to make sure
+        # multiple thread-thread caches don't use the same key.
+        N = lambda{MUTEX.synchronize{n += 1}}
+
+        # Store unique symbol used to look up in the per
+        # thread caches.
+        def initialize
+          @o = :"roda_per_thread_cache_#{N.call}"
+        end
+
+        # Return the current thread's cached value.
+        def [](key)
+          _hash[key]
+        end
+
+        # Set the current thread's cached value.
+        def []=(key, value)
+          _hash[key] = value
+        end
+
+        private
+
+        # The current thread's cache.
+        def _hash
+          ::Thread.current[@o] ||= {}
+        end
+      end
+
+      module ClassMethods
+        # Use the per-thread cache instead of the default cache.
+        def thread_safe_cache
+          Cache.new
+        end
+      end
+    end
+
+    register_plugin(:per_thread_caching, PerThreadCaching)
+  end
+end