roda-cj 0.9.2 → 0.9.3

data/lib/roda/plugins/all_verbs.rb

@@ -35,7 +35,7 @@ class Roda
           if ::Rack::Request.method_defined?("#{t}?")
             class_eval(<<-END, __FILE__, __LINE__+1)
               def #{t}(*args, &block)
-                is_or_on(*args, &block) if #{t}?
+                _verb(args, &block) if #{t}?
               end
             END
           end

data/lib/roda/plugins/backtracking_array.rb

@@ -0,0 +1,91 @@
+class Roda
+  module RodaPlugins
+    # The backtracking_array plugin changes the handling of array
+    # matchers such that if one of the array entries matches, but
+    # a later match argument fails, it will backtrack and try the
+    # next entry in the array.  For example, the following match
+    # block does not match +/a/b+ by default:
+    #
+    #   r.is ['a', 'a/b'] do |path|
+    #     ...
+    #   end
+    #
+    # This is because the <tt>'a'</tt> entry in the array matches, which
+    # makes the array match.  However, the next matcher is the
+    # terminal matcher (since +r.is+ was used), and since the
+    # path is not terminal as it still contains +/b+ after
+    # matching <tt>'a'</tt>.
+    #
+    # With the backtracking_array plugin, when the terminal matcher
+    # fails, matching will go on to the next entry in the array,
+    # <tt>'a/b'</tt>, which will also match.  Since <tt>'a/b'</tt>
+    # matches the path fully, the terminal matcher also matches,
+    # and the match block yields.
+    module BacktrackingArray
+      module RequestMethods
+        PATH_INFO = "PATH_INFO".freeze
+        SCRIPT_NAME = "SCRIPT_NAME".freeze
+
+        private
+
+        # When matching for a single array, after a successful
+        # array element match, attempt to match all remaining
+        # elements.  If the remaining elements could not be
+        # matched, reset the state and continue to the next
+        # entry in the array.
+        def _match_array(arg, rest=nil)
+          return super unless rest
+
+          script = env[SCRIPT_NAME]
+          path = env[PATH_INFO]
+          caps = captures.dup
+          arg.each do |v|
+            if match(v, rest)
+              if v.is_a?(String)
+                captures.push(v)
+              end
+
+              if match_all(rest)
+                return true
+              end
+
+              # Matching all remaining elements failed, reset state
+              captures.replace(caps)
+              env[SCRIPT_NAME] = script
+              env[PATH_INFO] = path
+            end
+          end
+          false
+        end
+
+        # If any of the args are an array, handle backtracking such
+        # that if a later matcher fails, we roll back to the current
+        # matcher and proceed to the next entry in the array.
+        def match_all(args)
+          args = args.dup
+          until args.empty?
+            arg = args.shift
+            if match(arg, args)
+              return true if arg.is_a?(Array)
+            else
+              return
+            end
+          end
+          true
+        end
+
+        # When matching an array, include the remaining arguments,
+        # otherwise, just match the single argument.
+        def match(v, rest = nil)
+          if v.is_a?(Array)
+            _match_array(v, rest)
+          else
+            super(v)
+          end
+        end
+      end
+    end
+
+    register_plugin(:backtracking_array, BacktrackingArray)
+  end
+end

data/lib/roda/plugins/csrf.rb

@@ -0,0 +1,60 @@
+require 'rack/csrf'
+
+class Roda
+  module RodaPlugins
+    # The csrf plugin adds CSRF protection using rack_csrf, along with
+    # some csrf helper methods to use in your views.  To use it, load
+    # the plugin, with the options hash passed to Rack::Csrf:
+    #
+    #   plugin :csrf, :raise=>true
+    #
+    # This adds the following instance methods:
+    #
+    # csrf_field :: The field name to use for the hidden/meta csrf tag.
+    # csrf_header :: The http header name to use for submitting csrf token via
+    #                headers (useful for javascript).
+    # csrf_metatag :: An html meta tag string containing the token, suitable
+    #                 for placing in the page header
+    # csrf_tag :: An html hidden input tag string containing the token, suitable
+    #             for placing in an html form.
+    # csrf_token :: The value of the csrf token, in case it needs to be accessed
+    #               directly.
+    module Csrf
+      CSRF = ::Rack::Csrf
+
+      # Load the Rack::Csrf middleware into the app with the given options.
+      def self.configure(app, opts={})
+        app.use CSRF, opts
+      end
+
+      module InstanceMethods
+        # The name of the hidden/meta csrf tag.
+        def csrf_field
+          CSRF.field
+        end
+
+        # The http header name to use for submitting csrf token via headers.
+        def csrf_header
+          CSRF.header
+        end
+
+        # An html meta tag string containing the token.
+        def csrf_metatag(opts={})
+          CSRF.metatag(env, opts)
+        end
+
+        # An html hidden input tag string containing the token.
+        def csrf_tag
+          CSRF.tag(env)
+        end
+
+        # The value of the csrf token.
+        def csrf_token
+          CSRF.token(env)
+        end
+      end
+    end
+
+    register_plugin(:csrf, Csrf)
+  end
+end

data/lib/roda/plugins/halt.rb

@@ -54,7 +54,7 @@ class Roda
             when String
               response.write v
             when Array
-              super
+              throw :halt, v
             else
               raise Roda::RodaError, "singular argument to #halt must be Integer, String, or Array"
             end
@@ -69,7 +69,7 @@ class Roda
             raise Roda::RodaError, "too many arguments given to #halt (accepts 0-3, received #{res.length})"
           end
 
-          _halt response.finish
+          super()
         end
       end
     end

data/lib/roda/plugins/json.rb

@@ -0,0 +1,84 @@
+require 'json'
+
+class Roda
+  module RodaPlugins
+    # The json plugin allows matching 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/pass.rb

@@ -18,7 +18,7 @@ class Roda
     module Pass
       module RequestMethods
         # Handle passing inside the current block.
-        def on(*)
+        def _on(_)
           catch(:pass){super}
         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

data/lib/roda/plugins/render.rb

@@ -27,9 +27,8 @@ 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'.
     # :ext :: The file extension to assume for view files, defaults to the :engine
     #         option.
@@ -65,34 +64,6 @@ 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
-        end
-      end
-
       # Setup default rendering options.  See Render for details.
       def self.configure(app, opts={})
         if app.opts[:render]
@@ -112,8 +83,7 @@ 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
+        opts[:cache] = app.thread_safe_cache if opts.fetch(:cache, true)
       end
 
       module ClassMethods
@@ -125,7 +95,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.
@@ -198,7 +168,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/symbol_matchers.rb

@@ -0,0 +1,75 @@
+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 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
+    # :opt :: <tt>/(?:\/([^\/]+))?</tt>, an optional segment
+    # :optd :: <tt>/(?:\/(\d+))?</tt>, an optional decimal segment
+    # :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|
+    #   # 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(: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
+        # 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