roda 1.1.0 → 1.2.0

data/lib/roda/plugins/match_affix.rb

@@ -0,0 +1,48 @@
+class Roda
+  module RodaPlugins
+    # The match_affix plugin allows changing the default prefix and suffix used for
+    # match patterns.  Roda's default behavior for a match pattern like <tt>"albums"</tt>
+    # is to use the pattern <tt>/\A\/(?:albums)(?=\/|\z)/</tt>.  This prefixes the pattern
+    # with +/+ and suffixes it with <tt>(?=\/|\z)</tt>.  With the match_affix plugin, you
+    # can change the prefix and suffix to use.  So if you want to be explicit and require
+    # a leading +/+ in patterns, you can set the prefix to <tt>""</tt>.  If you want to
+    # consume a trailing slash instead of leaving it, you can set the suffix to <tt>(\/|\z)</tt>.
+    #
+    # You set the prefix and suffix to use by passing arguments when loading the plugin:
+    #
+    #   plugin :match_affix, ""
+    #
+    # will load the plugin and use an empty prefix.
+    #
+    #   plugin :match_affix, "", /(\/|\z)/
+    #
+    # will use an empty prefix and change the suffix to consume a trailing slash.
+    #
+    #  plugin :match_affix, nil, /(\/|\z)/
+    #
+    # will not modify the prefix and will change the suffix to consume a trailing slash.
+    module MatchAffix
+      PREFIX = "/".freeze
+      SUFFIX = "(?=\/|\z)".freeze
+
+      # Set the default prefix and suffix to use in match patterns, if a non-nil value
+      # is given.
+      def self.configure(app, prefix, suffix=nil)
+        app.opts[:match_prefix] = prefix if prefix
+        app.opts[:match_suffix] = suffix if suffix
+      end
+      
+      module RequestClassMethods
+        private
+
+        # Use the match prefix and suffix provided when loading the plugin, or fallback
+        # to Roda's default prefix/suffix if one was not provided.
+        def consume_pattern(pattern)
+          /\A#{roda_class.opts[:match_prefix] || PREFIX}(?:#{pattern})#{roda_class.opts[:match_suffix] || SUFFIX}/
+        end
+      end
+    end
+
+    register_plugin(:match_affix, MatchAffix)
+  end
+end

data/lib/roda/plugins/multi_route.rb

@@ -125,29 +125,27 @@ class Roda
     module MultiRoute
       # Initialize storage for the named routes.
       def self.configure(app)
-        app.instance_exec do
-          @namespaced_routes ||= {}
-          app::RodaRequest.instance_variable_set(:@namespaced_route_regexps, {})
-        end
+        app.opts[:namespaced_routes] ||= {}
+        app::RodaRequest.instance_variable_set(:@namespaced_route_regexps, {})
       end
 
       module ClassMethods
         # Copy the named routes into the subclass when inheriting.
         def inherited(subclass)
           super
-          nsr = subclass.instance_variable_set(:@namespaced_routes, {})
-          @namespaced_routes.each{|k, v| nsr[k] = v.dup}
+          nsr = subclass.opts[:namespaced_routes]
+          opts[:namespaced_routes].each{|k, v| nsr[k] = v.dup}
           subclass::RodaRequest.instance_variable_set(:@namespaced_route_regexps, {})
         end
 
         # The names for the currently stored named routes
         def named_routes(namespace=nil)
-          @namespaced_routes[namespace].keys
+          opts[:namespaced_routes][namespace].keys
         end
 
         # Return the named route with the given name.
         def named_route(name, namespace=nil)
-          @namespaced_routes[namespace][name]
+          opts[:namespaced_routes][namespace][name]
         end
 
         # If the given route has a name, treat it as a named route and
@@ -155,8 +153,8 @@ class Roda
         # call super.
         def route(name=nil, namespace=nil, &block)
           if name
-            @namespaced_routes[namespace] ||= {}
-            @namespaced_routes[namespace][name] = block
+            opts[:namespaced_routes][namespace] ||= {}
+            opts[:namespaced_routes][namespace][name] = block
             self::RodaRequest.clear_named_route_regexp!(namespace)
           else
             super(&block)
@@ -199,7 +197,7 @@ class Roda
 
         # Dispatch to the named route with the given name.
         def route(name, namespace=nil)
-          scope.instance_exec(self, &self.class.roda_class.named_route(name, namespace))
+          scope.instance_exec(self, &roda_class.named_route(name, namespace))
         end
       end
     end

data/lib/roda/plugins/multi_run.rb

@@ -0,0 +1,81 @@
+class Roda
+  module RodaPlugins
+    # The multi_run plugin provides the ability to easily dispatch to other
+    # rack applications based on the request path prefix.
+    # First, load the plugin:
+    #
+    #   class App < Roda
+    #     plugin :multi_run
+    #   end
+    #
+    # Then, other rack applications can register with the multi_run plugin:
+    #
+    #   App.run "ra", PlainRackApp
+    #   App.run "ro", OtherRodaApp
+    #   App.run "si", SinatraApp
+    #
+    # Inside your route block, you can call r.multi_run to dispatch to all
+    # three rack applications based on the prefix:
+    #
+    #   App.route do |r|
+    #     r.multi_run
+    #   end
+    #
+    # This will dispatch routes starting with +/ra+ to +PlainRackApp+, routes
+    # starting with +/ro+ to +OtherRodaApp+, and routes starting with +/si+ to
+    # SinatraApp.
+    #
+    # The multi_run plugin is similar to the multi_route plugin, with the difference
+    # being the multi_route plugin keeps all routing subtrees in the same Roda app/class,
+    # while multi_run dispatches to other rack apps.  If you want to isolate your routing
+    # subtrees, multi_run is a better approach, but it does not let you set instance
+    # variables in the main Roda app and have those instance variables usable in
+    # the routing subtrees.
+    module MultiRun
+      # Initialize the storage for the dispatched applications
+      def self.configure(app)
+        app.instance_eval do
+          @multi_run_apps ||= {}
+        end
+      end
+
+      module ClassMethods
+        # Hash storing rack applications to dispatch to, keyed by the prefix
+        # for the application.
+        attr_reader :multi_run_apps
+
+        # Add a rack application to dispatch to for the given prefix when
+        # r.multi_run is called.
+        def run(prefix, app)
+          @multi_run_apps[prefix.to_s] = app
+          self::RodaRequest.refresh_multi_run_regexp!
+        end
+      end
+
+      module RequestClassMethods
+        # Refresh the multi_run_regexp, using the stored route prefixes,
+        # preferring longer routes before shorter routes.
+        def refresh_multi_run_regexp!
+          @multi_run_regexp = /(#{Regexp.union(roda_class.multi_run_apps.keys.sort.reverse)})/
+        end
+
+        # Refresh the multi_run_regexp if it hasn't been loaded yet.
+        def multi_run_regexp
+          @multi_run_regexp || refresh_multi_run_regexp!
+        end
+      end
+
+      module RequestMethods
+        # If one of the stored route prefixes match the current request,
+        # dispatch the request to the stored rack application.
+        def multi_run
+          on self.class.multi_run_regexp do |prefix|
+            run scope.class.multi_run_apps[prefix]
+          end
+        end
+      end
+    end
+
+    register_plugin(:multi_run, MultiRun)
+  end
+end

data/lib/roda/plugins/named_templates.rb

@@ -0,0 +1,93 @@
+class Roda
+  module RodaPlugins
+    # The named_templates plugin allows you to specify templates by name,
+    # providing the template code to use for a given name:
+    #
+    #   plugin :named_templates
+    #
+    #   template :layout do
+    #     "<html><body><%= yield %></body></html>"
+    #   end
+    #   template :index do
+    #     "<p>Hello <%= @user %>!</p>"
+    #   end
+    #
+    #   route do |r|
+    #     @user = 'You'
+    #     render(:index)
+    #   end
+    #   # => "<html><body><p>Hello You!</p></body></html>"
+    #
+    # You can provide options for the template, for example to change the
+    # engine that the template uses:
+    #
+    #   template :index, :engine=>:str do
+    #     "<p>Hello #{@user}!</p>"
+    #   end
+    #   
+    # The block you use is reevaluted on every call, allowing you to easily
+    # include additional setup logic:
+    #
+    #   template :index do
+    #     greeting = ['hello', 'hi', 'howdy'].sample
+    #     @user.downcase!
+    #     "<p>#{greating} <%= @user %>!</p>"
+    #   end
+    #   
+    # This plugin also works with the view_subdirs plugin, as long as you
+    # prefix the template name with the view subdirectory:
+    #
+    #   template "main/index" do
+    #     "<html><body><%= yield %></body></html>"
+    #   end
+    #
+    #   route do |r|
+    #     set_view_subdir("main")
+    #     @user = 'You'
+    #     render(:index)
+    #   end
+    module NamedTemplates
+      # Depend on the render plugin
+      def self.load_dependencies(app)
+        app.plugin :render
+      end
+
+      # Initialize the storage for named templates.
+      def self.configure(app)
+        app.opts[:named_templates] ||= {}
+      end
+
+      module ClassMethods
+        # Store a new template block and options for the given template name.
+        def template(name, options=nil, &block)
+          opts[:named_templates][name.to_s] = [options, block]
+          nil
+        end
+      end
+
+      module InstanceMethods
+        private
+
+        # If a template name is given and it matches a named template, call
+        # the named template block to get the inline template to use.
+        def find_template(options)
+          if options[:template] && (template_opts, block = opts[:named_templates][template_name(options)]; block)
+            if template_opts
+              options = template_opts.merge(options)
+            else
+              options = options.dup
+            end
+
+            options[:inline] = instance_exec(&block)
+
+            super(options)
+          else
+            super
+          end
+        end
+      end
+    end
+
+    register_plugin(:named_templates, NamedTemplates)
+  end
+end

data/lib/roda/plugins/not_allowed.rb

@@ -59,48 +59,15 @@ class Roda
     #
     # 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.
+    #
+    # This plugin depends on the all_verbs plugin.  It works by overriding
+    # the verb methods, so it wouldn't work if loaded after the all_verbs
+    # plugin.
     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 defined?(@_is_verbs)
-                always(&block) if #{verb == :get ? :is_get : verb}?
-              else
-                args << ::Roda::RodaPlugins::Base::RequestMethods::TERM
-                if_match(args) do |*a|
-                  if #{verb == :get ? :is_get : verb}?
-                    block_result(yield(*a))
-                    throw :halt, response.finish
-                  end
-                  response.status = 405
-                  response['Allow'] = '#{verb.to_s.upcase}'
-                  nil
-                end
-              end
-            end
-          END
-        end
+      # Depend on the all_verbs plugin, as this plugin overrides methods
+      # defined by it and calls super.
+      def self.load_dependencies(app)
+        app.plugin :all_verbs
       end
 
       module RequestMethods
@@ -110,20 +77,19 @@ class Roda
         # 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
+        def is(*args)
+          super(*args) do
             begin
-              @_is_verbs = []
+              is_verbs = @_is_verbs = []
 
-              ret = if verbs.empty?
+              ret = if args.empty?
                 yield
               else
                 yield(*captures)
               end
 
-              unless @_is_verbs.empty?
-                response.status = 405
-                response['Allow'] = @_is_verbs.join(', ')
+              unless is_verbs.empty?
+                method_not_allowed(is_verbs.join(', '))
               end
 
               ret
@@ -132,6 +98,35 @@ class Roda
             end
           end
         end
+
+        # Setup methods for all verbs.  If inside an is block and not given
+        # arguments, record the verb used.  If given an argument, add an is
+        # check with the argu
+        %w'get post delete head options link patch put trace unlink'.each do |verb|
+          if ::Rack::Request.method_defined?("#{verb}?")
+            class_eval(<<-END, __FILE__, __LINE__+1)
+              def #{verb}(*args, &block)
+                if (empty = args.empty?) && @_is_verbs
+                  @_is_verbs << "#{verb.to_s.upcase}"
+                end
+                super
+                unless empty
+                  is(*args){method_not_allowed("#{verb.to_s.upcase}")}
+                end
+              end
+            END
+          end
+        end
+
+        private
+
+        # Set the response status to 405 (Method Not Allowed), and set the Allow header
+        # to the given string of allowed request methods.
+        def method_not_allowed(verbs)
+          res = response
+          res.status = 405
+          res['Allow'] = verbs
+        end
       end
     end
 

data/lib/roda/plugins/path.rb

@@ -17,9 +17,31 @@ class Roda
     #       r.redirect bar_path(bar)
     #     end
     #   end
+    #
+    # The path method accepts the following options:
+    #
+    # :add_script_name :: Prefix the path generated with SCRIPT_NAME.
+    # :name :: Provide a different name for the method, instead of using <tt>*_path</tt>.
+    # :url :: Create a url method in addition to the path method, which will prefix the string generated
+    #         with the appropriate scheme, host, and port.  If true, creates a <tt>*_url</tt>
+    #         method.  If a Symbol or String, uses the value as the url method name.
+    # :url_only :: Do not create a path method, just a url method.
+    #
+    # Note that if :add_script_name, :url, or :url_only is used, this will also create a <tt>_*_path</tt>
+    # method.  This is necessary in order to support path methods that accept blocks, as you can't pass
+    # a block to a block that is instance_execed.
     module Path
+      DEFAULT_PORTS = {'http' => 80, 'https' => 443}.freeze
+
       module ClassMethods
-        def path(name, path=nil, &block)
+        # Create a new instance method for the named path.  See plugin module documentation for options.
+        def path(name, path=nil, opts={}, &block)
+          if path.is_a?(Hash)
+            raise RodaError,  "cannot provide two option hashses to Roda.path" unless opts.empty?
+            opts = path
+            path = nil
+          end
+
           raise RodaError,  "cannot provide both path and block to Roda.path" if path && block
           raise RodaError,  "must provide either path or block to Roda.path" unless path || block
 
@@ -28,7 +50,46 @@ class Roda
             block = lambda{path}
           end
 
-          define_method("#{name}_path", &block)
+          meth = opts[:name] || "#{name}_path"
+          url = opts[:url]
+          add_script_name = opts[:add_script_name]
+
+          if add_script_name || url || opts[:url_only]
+            _meth = "_#{meth}"
+            define_method(_meth, &block)
+          end
+
+          unless opts[:url_only]
+            if add_script_name
+              define_method(meth) do |*a, &blk|
+                request.script_name.to_s + send(_meth, *a, &blk)
+              end
+            else
+              define_method(meth, &block)
+            end
+          end
+
+          if url || opts[:url_only]
+            url_meth = if url.is_a?(String) || url.is_a?(Symbol)
+              url
+            else
+              "#{name}_url"
+            end
+
+            url_block = lambda do |*a, &blk|
+              r = request
+              scheme = r.scheme
+              port = r.port
+              uri = ["#{scheme}://#{r.host}#{":#{port}" unless DEFAULT_PORTS[scheme] == port}"]
+              uri << request.script_name.to_s if add_script_name
+              uri << send(_meth, *a, &blk)
+              File.join(uri)
+            end
+
+            define_method(url_meth, &url_block)
+          end
+
+          nil
         end
       end
     end