roda 1.1.0 → 1.2.0

data/lib/roda/plugins/environments.rb

@@ -0,0 +1,68 @@
+class Roda
+  module RodaPlugins
+    # The environments plugin adds a environment class accessor to get
+    # the environment for the application, 3 predicate class methods
+    # to check for the current environment (development?, test? and
+    # production?), and a class configure method that takes environment(s)
+    # and yields to the block if the given environment(s) match the
+    # current environment.
+    #
+    # The default environment for the application is based on
+    # <tt>ENV['RACK_ENV']</tt>.
+    #
+    # Example:
+    #
+    #   class Roda
+    #     plugin :environments
+    #
+    #     environment  # => :development
+    #     development? # => true
+    #     test?        # => false
+    #     production?  # => false
+    #
+    #     # Set the environment for the application
+    #     self.environment = :test 
+    #     test?        # => true
+    #
+    #     configure do
+    #       # called, as no environments given
+    #     end
+    #
+    #     configure :development, :production do
+    #       # not called, as no environments match
+    #     end
+    #
+    #     configure :test do
+    #       # called, as environment given matches current environment
+    #     end
+    #   end
+    module Environments
+      # Set the environment to use for the app.  Default to ENV['RACK_ENV']
+      # if no environment is given.  If ENV['RACK_ENV'] is not set and
+      # no environment is given, assume the development environment.
+      def self.configure(app, env=ENV["RACK_ENV"])
+        app.environment = (env || 'development').to_sym
+      end
+
+      module ClassMethods
+        # The current environment for the application, which should be stored
+        # as a symbol.
+        attr_accessor :environment
+
+        # If no environments are given or one of the given environments
+        # matches the current environment, yield the receiver to the block.
+        def configure(*envs)
+          if envs.empty? || envs.any?{|s| s == environment}
+            yield self
+          end
+        end
+
+        [:development, :test, :production].each do |env|
+          define_method("#{env}?"){environment == env}
+        end
+      end
+    end
+
+    register_plugin(:environments, Environments)
+  end
+end

data/lib/roda/plugins/error_email.rb

@@ -41,7 +41,7 @@ class Roda
           format = lambda{|h| h.map{|k, v| "#{k.inspect} => #{v.inspect}"}.sort.join("\n")}
 
           message = <<END
-Path: #{s.request.full_path_info}
+Path: #{s.request.path}
 
 Backtrace:
 
@@ -88,7 +88,6 @@ END
         # the superclass.
         def inherited(subclass)
           super
-          subclass.opts[:error_email] = subclass.opts[:error_email].dup
           subclass.opts[:error_email][:headers] = subclass.opts[:error_email][:headers].dup
         end
       end

data/lib/roda/plugins/error_handler.rb

@@ -51,7 +51,7 @@ class Roda
         def _route
           super
         rescue => e
-          response.status = 500
+          @_response.status = 500
           super{handle_error(e)}
         end
 

data/lib/roda/plugins/halt.rb

@@ -53,12 +53,14 @@ class Roda
               raise Roda::RodaError, "singular argument to #halt must be Integer, String, or Array"
             end
           when 2
-            response.status = res[0]
-            response.write res[1]
+            resp = response
+            resp.status = res[0]
+            resp.write res[1]
           when 3
-            response.status = res[0]
-            response.headers.merge!(res[1])
-            response.write res[2]
+            resp = response
+            resp.status = res[0]
+            resp.headers.merge!(res[1])
+            resp.write res[2]
           else
             raise Roda::RodaError, "too many arguments given to #halt (accepts 0-3, received #{res.length})"
           end

data/lib/roda/plugins/head.rb

@@ -23,13 +23,15 @@ class Roda
     # HEAD requests for +/+, +/a+, and +/b+ will all return 200 status
     # with an empty body.
     module Head
+      EMPTY_ARRAY = [].freeze
+
       module InstanceMethods
         # Always use an empty response body for head requests, with a
         # content length of 0.
         def call(*)
           res = super
-          if request.head?
-            res[2] = []
+          if @_request.head?
+            res[2] = EMPTY_ARRAY
           end
           res
         end

data/lib/roda/plugins/header_matchers.rb

@@ -8,23 +8,23 @@ class Roda
     # It adds a +:header+ matcher for matching on arbitrary headers, which matches
     # if the header is present:
     #
-    #   route do |r|
-    #     r.on :header=>'X-App-Token' do
-    #     end
+    #   r.on :header=>'X-App-Token' do
     #   end
     #
     # It adds a +:host+ matcher for matching by the host of the request:
     #
-    #   route do |r|
-    #     r.on :host=>'foo.example.com' do
-    #     end
+    #   r.on :host=>'foo.example.com' do
+    #   end
+    #
+    # It adds a +:user_agent+ matcher for matching on a user agent patterns, which
+    # yields the regexp captures to the block:
+    #
+    #   r.on :user_agent=>/Chrome\/([.\d]+)/ do |chrome_version|
     #   end
     #
     # It adds an +:accept+ matcher for matching based on the Accept header:
     #
-    #   route do |r|
-    #     r.on :accept=>'text/csv' do
-    #     end
+    #   r.on :accept=>'text/csv' do
     #   end
     #
     # Note that the accept matcher is very simple and cannot handle wildcards,
@@ -49,6 +49,14 @@ class Roda
         def match_host(hostname)
           hostname === host
         end
+
+        # Match the submitted user agent to the given pattern, capturing any
+        # regexp match groups.
+        def match_user_agent(pattern)
+          if (user_agent = @env["HTTP_USER_AGENT"]) && user_agent.to_s =~ pattern
+            @captures.concat($~[1..-1])
+          end
+        end
       end
     end
 

data/lib/roda/plugins/hooks.rb

@@ -30,10 +30,8 @@ class Roda
     # handle cases where before hooks are added after the route block.
     module Hooks
       def self.configure(app)
-        app.instance_exec do
-          @after ||= nil
-          @before ||= nil
-        end
+        app.opts[:before_hook] ||= nil
+        app.opts[:after_hook] ||= nil
       end
 
       module ClassMethods
@@ -42,17 +40,14 @@ class Roda
         # then instance_execs the given after proc, so that the given
         # after proc always executes after the previous one.
         def after(&block)
-          if block
-            @after = if b = @after
-              @after = proc do |res|
-                instance_exec(res, &b)
-                instance_exec(res, &block)
-              end
-            else
-              block
+          opts[:after_hook] = if b = opts[:after_hook]
+            proc do |res|
+              instance_exec(res, &b)
+              instance_exec(res, &block)
             end
+          else
+            block
           end
-          @after
         end
 
         # Add a before hook.  If there is already a before hook defined,
@@ -60,25 +55,14 @@ class Roda
         # then instance_execs the existing before proc, so that the given
         # before proc always executes before the previous one.
         def before(&block)
-          if block
-            @before = if b = @before
-              @before = proc do
-                instance_exec(&block)
-                instance_exec(&b)
-              end
-            else
-              block
+          opts[:before_hook] = if b = opts[:before_hook]
+            proc do
+              instance_exec(&block)
+              instance_exec(&b)
             end
+          else
+            block
           end
-          @before
-        end
-
-        # Copy the before and after hooks into the subclasses
-        # when inheriting
-        def inherited(subclass)
-          super
-          subclass.instance_variable_set(:@before, @before)
-          subclass.instance_variable_set(:@after, @after)
         end
       end
 
@@ -88,13 +72,13 @@ class Roda
         # Before routing, execute the before hooks, and
         # execute the after hooks before returning.
         def _route(*, &block)
-          if b = self.class.before
+          if b = opts[:before_hook]
             instance_exec(&b)
           end
 
           res = super
         ensure
-          if b = self.class.after
+          if b = opts[:after_hook]
             instance_exec(res, &b)
           end
         end

data/lib/roda/plugins/json.rb

@@ -36,19 +36,13 @@ class Roda
     module Json
       # Set the classes to automatically convert to JSON
       def self.configure(app)
-        app.instance_eval do
-          @json_result_classes ||= [Array, Hash]
-        end
+        app.opts[:json_result_classes] ||= [Array, Hash]
       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)
+        def json_result_classes
+          opts[:json_result_classes]
         end
       end
 
@@ -63,7 +57,7 @@ class Roda
         # application/json content-type.
         def block_result_body(result)
           case result
-          when *self.class.roda_class.json_result_classes
+          when *roda_class.json_result_classes
             response[CONTENT_TYPE] = APPLICATION_JSON
             convert_to_json(result)
           else

data/lib/roda/plugins/mailer.rb

@@ -0,0 +1,233 @@
+require 'stringio'
+require 'mail'
+
+class Roda
+  module RodaPlugins
+    # The mailer plugin allows your Roda application to send emails easily.
+    #
+    #   class App < Roda
+    #     plugin :render
+    #     plugin :mailer
+    #
+    #     route do |r|
+    #       r.on "albums" do
+    #         r.mail "added" do |album|
+    #           @album = album
+    #           from 'from@example.com'
+    #           to 'to@example.com'
+    #           cc 'cc@example.com'
+    #           bcc 'bcc@example.com'
+    #           subject 'Album Added'
+    #           add_file "path/to/album_added_img.jpg"
+    #           render(:albums_added_email) # body
+    #         end
+    #       end
+    #     end
+    #   end
+    #
+    # The default method for sending a mail is +sendmail+:
+    #
+    #   App.sendmail("/albums/added", Album[1])
+    #
+    # If you want to return the <tt>Mail::Message</tt> instance for further modification,
+    # you can just use the +mail+ method:
+    #
+    #   mail = App.mail("/albums/added", Album[1])
+    #   mail.from 'from2@example.com'
+    #   mail.deliver
+    #
+    # The mailer plugin uses the mail gem, so if you want to configure how
+    # email is sent, you can use <tt>Mail.defaults</tt> (see the mail gem documentation for
+    # more details):
+    #
+    #   Mail.defaults do
+    #     delivery_method :smtp, :address=>'smtp.example.com', :port=>587
+    #   end
+    #
+    # You can support multipart emails using +text_part+ and +html_part+:
+    #
+    #   r.mail "added" do |album_added|
+    #     from 'from@example.com'
+    #     to 'to@example.com'
+    #     subject 'Album Added'
+    #     text_part render('album_added.txt')  # views/album_added.txt.erb
+    #     html_part render('album_added.html') # views/album_added.html.erb
+    #   end
+    #
+    # In addition to allowing you to use Roda's render plugin for rendering
+    # email bodies, you can use all of Roda's usual routing tree features
+    # to DRY up your code:
+    #
+    #   r.on "albums/:d" do |album_id|
+    #     @album = Album[album_id.to_i]
+    #     from 'from@example.com'
+    #     to 'to@example.com'
+    #
+    #     r.mail "added" do
+    #       subject 'Album Added'
+    #       render(:albums_added_email)
+    #     end
+    #
+    #     r.mail "deleted" do
+    #       subject 'Album Deleted'
+    #       render(:albums_deleted_email)
+    #     end
+    #   end
+    #
+    # When sending a mail via +mail+ or +sendmail+, an Error will be raised
+    # if the mail object does not have a body.  This is similar to the 404
+    # status that Roda uses by default for web requests that don't have
+    # a body. If you want to specifically send an email with an empty body, you
+    # can use the explicit empty string:
+    #
+    #   r.mail do
+    #     from 'from@example.com'
+    #     to 'to@example.com'
+    #     subject 'No Body Here'
+    #     ""
+    #   end
+    #
+    # By default, the mailer uses text/plain as the Content-Type for emails.
+    # You can override the default by specifying a :content_type option when
+    # loading the plugin:
+    #
+    #   plugin :mailer, :content_type=>'text/html'
+    #
+    # The mailer plugin does support being used inside a Roda application
+    # that is handling web requests, where the routing block for mails and
+    # web requests is shared.  However, it's recommended that you create a
+    # separate Roda application for emails. This can be a subclass of your main
+    # Roda application if you want your helper methods to automatically be
+    # available in your email views.
+    module Mailer
+      REQUEST_METHOD = "REQUEST_METHOD".freeze
+      PATH_INFO = "PATH_INFO".freeze
+      SCRIPT_NAME = 'SCRIPT_NAME'.freeze
+      EMPTY_STRING = ''.freeze
+      RACK_INPUT = 'rack.input'.freeze
+      RODA_MAIL = 'roda.mail'.freeze
+      RODA_MAIL_ARGS = 'roda.mail_args'.freeze
+      MAIL = "MAIL".freeze
+      CONTENT_TYPE = 'Content-Type'.freeze
+      TEXT_PLAIN = "text/plain".freeze
+
+      # Error raised when the using the mail class method, but the routing
+      # tree doesn't return the mail object. 
+      class Error < ::Roda::RodaError; end
+
+      # Set the options for the mailer.  Options:
+      # :content_type :: The default content type for emails (default: text/plain)
+      def self.configure(app, opts={})
+        app.opts[:mailer] = (app.opts[:mailer]||{}).merge(opts).freeze
+      end
+
+      module ClassMethods
+        # Return a Mail::Message instance for the email for the given request path
+        # and arguments.  You can further manipulate the returned mail object before
+        # calling +deliver+ to send the mail.
+        def mail(path, *args)
+          mail = ::Mail.new
+          unless mail.equal?(allocate.call(PATH_INFO=>path, SCRIPT_NAME=>EMPTY_STRING, REQUEST_METHOD=>MAIL, RACK_INPUT=>StringIO.new, RODA_MAIL=>mail, RODA_MAIL_ARGS=>args, &route_block))
+            raise Error, "route did not return mail instance for #{path.inspect}, #{args.inspect}"
+          end
+          mail
+        end
+
+        # Calls +mail+ and immediately sends the resulting mail.
+        def sendmail(*args)
+          mail(*args).deliver
+        end
+      end
+
+      module RequestMethods
+        # Similar to routing tree methods such as +get+ and +post+, this matches
+        # only if the request method is MAIL (only set when using the Roda class
+        # +mail+ or +sendmail+ methods) and the rest of the arguments match
+        # the request.  This yields any of the captures to the block, as well as
+        # any arguments passed to the +mail+ or +sendmail+ Roda class methods.
+        def mail(*args)
+          if @env[REQUEST_METHOD] == MAIL
+            if_match(args) do |*vs|
+              yield *(vs + @env[RODA_MAIL_ARGS])
+            end
+          end
+        end
+      end
+
+      module ResponseMethods
+        # The mail object related to the current request.
+        attr_accessor :mail
+
+        # If the related request was an email request, add any response headers
+        # to the email, as well as adding the response body to the email.
+        # Return the email unless no body was set for it, which would indicate
+        # that the routing tree did not handle the request.
+        def finish
+          if m = mail
+            header_content_type = @headers.delete(CONTENT_TYPE)
+            m.headers(@headers)
+            m.body(@body.join) unless @body.empty?
+
+            if content_type = header_content_type || roda_class.opts[:mailer][:content_type]
+              if mail.multipart?
+                if mail.content_type =~ /multipart\/mixed/ &&
+                   mail.parts.length >= 2 &&
+                   (part = mail.parts.find{|p| !p.attachment && p.content_type == TEXT_PLAIN})
+                  part.content_type = content_type
+                end
+              else
+                mail.content_type = content_type
+              end
+            end
+
+            unless m.body.to_s.empty? && m.parts.empty? && @body.empty?
+              m
+            end
+          else
+            super
+          end
+        end
+      end
+
+      module InstanceMethods
+        # Add delegates for common email methods.
+        [:from, :to, :cc, :bcc, :subject, :add_file].each do |meth|
+          define_method(meth) do |*args|
+            env[RODA_MAIL].send(meth, *args)
+            nil
+          end
+        end
+        [:text_part, :html_part].each do |meth|
+          define_method(meth) do |*args|
+            _mail_part(meth, *args)
+          end
+        end
+
+        private
+
+        # If this is an email request, set the mail object in the response, as well
+        # as the default content_type for the email.
+        def _route
+          if mail = env[RODA_MAIL]
+            res = @_response
+            res.mail = mail
+            res.headers.delete(CONTENT_TYPE)
+          end
+          super
+        end
+
+        # Set the text_part or html_part (depending on the method) in the related email,
+        # using the given body and optional headers.
+        def _mail_part(meth, body, headers=nil)
+          env[RODA_MAIL].send(meth) do
+            body(body)
+            headers(headers) if headers
+          end
+          nil
+        end
+      end
+    end
+
+    register_plugin(:mailer, Mailer)
+  end
+end