actionmailer_csi 2.3.5.p6

data/lib/action_mailer/helpers.rb

@@ -0,0 +1,113 @@
+require 'active_support/dependencies'
+
+module ActionMailer
+  module Helpers #:nodoc:
+    def self.included(base) #:nodoc:
+      # Initialize the base module to aggregate its helpers.
+      base.class_inheritable_accessor :master_helper_module
+      base.master_helper_module = Module.new
+
+      # Extend base with class methods to declare helpers.
+      base.extend(ClassMethods)
+
+      base.class_eval do
+        # Wrap inherited to create a new master helper module for subclasses.
+        class << self
+          alias_method_chain :inherited, :helper
+        end
+
+        # Wrap initialize_template_class to extend new template class
+        # instances with the master helper module.
+        alias_method_chain :initialize_template_class, :helper
+      end
+    end
+
+    module ClassMethods
+      # Makes all the (instance) methods in the helper module available to templates rendered through this controller.
+      # See ActionView::Helpers (link:classes/ActionView/Helpers.html) for more about making your own helper modules
+      # available to the templates.
+      def add_template_helper(helper_module) #:nodoc:
+        master_helper_module.module_eval "include #{helper_module}"
+      end
+
+      # Declare a helper:
+      #   helper :foo
+      # requires 'foo_helper' and includes FooHelper in the template class.
+      #   helper FooHelper
+      # includes FooHelper in the template class.
+      #   helper { def foo() "#{bar} is the very best" end }
+      # evaluates the block in the template class, adding method +foo+.
+      #   helper(:three, BlindHelper) { def mice() 'mice' end }
+      # does all three.
+      def helper(*args, &block)
+        args.flatten.each do |arg|
+          case arg
+            when Module
+              add_template_helper(arg)
+            when String, Symbol
+              file_name  = arg.to_s.underscore + '_helper'
+              class_name = file_name.camelize
+
+              begin
+                require_dependency(file_name)
+              rescue LoadError => load_error
+                requiree = / -- (.*?)(\.rb)?$/.match(load_error.message).to_a[1]
+                msg = (requiree == file_name) ? "Missing helper file helpers/#{file_name}.rb" : "Can't load file: #{requiree}"
+                raise LoadError.new(msg).copy_blame!(load_error)
+              end
+
+              add_template_helper(class_name.constantize)
+            else
+              raise ArgumentError, 'helper expects String, Symbol, or Module argument'
+          end
+        end
+
+        # Evaluate block in template class if given.
+        master_helper_module.module_eval(&block) if block_given?
+      end
+
+      # Declare a controller method as a helper.  For example,
+      #   helper_method :link_to
+      #   def link_to(name, options) ... end
+      # makes the link_to controller method available in the view.
+      def helper_method(*methods)
+        methods.flatten.each do |method|
+          master_helper_module.module_eval <<-end_eval
+            def #{method}(*args, &block)
+              controller.__send__(%(#{method}), *args, &block)
+            end
+          end_eval
+        end
+      end
+
+      # Declare a controller attribute as a helper.  For example,
+      #   helper_attr :name
+      #   attr_accessor :name
+      # makes the name and name= controller methods available in the view.
+      # The is a convenience wrapper for helper_method.
+      def helper_attr(*attrs)
+        attrs.flatten.each { |attr| helper_method(attr, "#{attr}=") }
+      end
+
+      private
+        def inherited_with_helper(child)
+          inherited_without_helper(child)
+          begin
+            child.master_helper_module = Module.new
+            child.master_helper_module.__send__(:include, master_helper_module)
+            child.helper child.name.to_s.underscore
+          rescue MissingSourceFile => e
+            raise unless e.is_missing?("helpers/#{child.name.to_s.underscore}_helper")
+          end
+        end
+    end
+
+    private
+      # Extend the template class instance with our controller's helper module.
+      def initialize_template_class_with_helper(assigns)
+        returning(template = initialize_template_class_without_helper(assigns)) do
+          template.extend self.class.master_helper_module
+        end
+      end
+  end
+end

data/lib/action_mailer/mail_helper.rb

@@ -0,0 +1,17 @@
+module MailHelper
+  # Uses Text::Format to take the text and format it, indented two spaces for
+  # each line, and wrapped at 72 columns.
+  def block_format(text)
+    formatted = text.split(/\n\r\n/).collect { |paragraph| 
+      Text::Format.new(
+        :columns => 72, :first_indent => 2, :body_indent => 2, :text => paragraph
+      ).format
+    }.join("\n")
+    
+    # Make list points stand on their own line
+    formatted.gsub!(/[ ]*([*]+) ([^*]*)/) { |s| "  #{$1} #{$2.strip}\n" }
+    formatted.gsub!(/[ ]*([#]+) ([^#]*)/) { |s| "  #{$1} #{$2.strip}\n" }
+
+    formatted
+  end
+end

data/lib/action_mailer/part.rb

@@ -0,0 +1,107 @@
+module ActionMailer
+  # Represents a subpart of an email message. It shares many similar
+  # attributes of ActionMailer::Base.  Although you can create parts manually
+  # and add them to the +parts+ list of the mailer, it is easier
+  # to use the helper methods in ActionMailer::PartContainer.
+  class Part
+    include AdvAttrAccessor, PartContainer, Utils
+
+    # Represents the body of the part, as a string. This should not be a
+    # Hash (like ActionMailer::Base), but if you want a template to be rendered
+    # into the body of a subpart you can do it with the mailer's +render+ method
+    # and assign the result here.
+    adv_attr_accessor :body
+    
+    # Specify the charset for this subpart. By default, it will be the charset
+    # of the containing part or mailer.
+    adv_attr_accessor :charset
+    
+    # The content disposition of this part, typically either "inline" or
+    # "attachment".
+    adv_attr_accessor :content_disposition
+    
+    # The content type of the part.
+    adv_attr_accessor :content_type
+    
+    # The filename to use for this subpart (usually for attachments).
+    adv_attr_accessor :filename
+    
+    # Accessor for specifying additional headers to include with this part.
+    adv_attr_accessor :headers
+    
+    # The transfer encoding to use for this subpart, like "base64" or
+    # "quoted-printable".
+    adv_attr_accessor :transfer_encoding
+
+    # Create a new part from the given +params+ hash. The valid params keys
+    # correspond to the accessors.
+    def initialize(params)
+      @content_type = params[:content_type]
+      @content_disposition = params[:disposition] || "inline"
+      @charset = params[:charset]
+      @body = params[:body]
+      @filename = params[:filename]
+      @transfer_encoding = params[:transfer_encoding] || "quoted-printable"
+      @headers = params[:headers] || {}
+      @parts = []
+    end
+
+    # Convert the part to a mail object which can be included in the parts
+    # list of another mail object.
+    def to_mail(defaults)
+      part = TMail::Mail.new
+
+      real_content_type, ctype_attrs = parse_content_type(defaults)
+
+      if @parts.empty?
+        part.content_transfer_encoding = transfer_encoding || "quoted-printable"
+        case (transfer_encoding || "").downcase
+          when "base64" then
+            part.body = TMail::Base64.folding_encode(body)
+          when "quoted-printable"
+            part.body = [normalize_new_lines(body)].pack("M*")
+          else
+            part.body = body
+        end
+
+        # Always set the content_type after setting the body and or parts!
+        # Also don't set filename and name when there is none (like in
+        # non-attachment parts)
+        if content_disposition == "attachment"
+          ctype_attrs.delete "charset"
+          part.set_content_type(real_content_type, nil,
+            squish("name" => filename).merge(ctype_attrs))
+          part.set_content_disposition(content_disposition,
+            squish("filename" => filename).merge(ctype_attrs))
+        else
+          part.set_content_type(real_content_type, nil, ctype_attrs)
+          part.set_content_disposition(content_disposition) 
+        end        
+      else
+        if String === body
+          @parts.unshift Part.new(:charset => charset, :body => @body, :content_type => 'text/plain')
+          @body = nil
+        end
+          
+        @parts.each do |p|
+          prt = (TMail::Mail === p ? p : p.to_mail(defaults))
+          part.parts << prt
+        end
+        
+        if real_content_type =~ /multipart/
+          ctype_attrs.delete 'charset'
+          part.set_content_type(real_content_type, nil, ctype_attrs)
+        end
+      end
+
+      headers.each { |k,v| part[k] = v }
+
+      part
+    end
+
+    private
+      def squish(values={})
+        values.delete_if { |k,v| v.nil? }
+      end
+  end
+end

data/lib/action_mailer/part_container.rb

@@ -0,0 +1,55 @@
+module ActionMailer
+  # Accessors and helpers that ActionMailer::Base and ActionMailer::Part have
+  # in common. Using these helpers you can easily add subparts or attachments
+  # to your message:
+  #
+  #   def my_mail_message(...)
+  #     ...
+  #     part "text/plain" do |p|
+  #       p.body "hello, world"
+  #       p.transfer_encoding "base64"
+  #     end
+  #
+  #     attachment "image/jpg" do |a|
+  #       a.body = File.read("hello.jpg")
+  #       a.filename = "hello.jpg"
+  #     end
+  #   end
+  module PartContainer
+    # The list of subparts of this container
+    attr_reader :parts
+
+    # Add a part to a multipart message, with the given content-type. The
+    # part itself is yielded to the block so that other properties (charset,
+    # body, headers, etc.) can be set on it.
+    def part(params)
+      params = {:content_type => params} if String === params
+      part = Part.new(params)
+      yield part if block_given?
+      @parts << part
+    end
+
+    # Add an attachment to a multipart message. This is simply a part with the
+    # content-disposition set to "attachment".
+    def attachment(params, &block)
+      params = { :content_type => params } if String === params
+      params = { :disposition => "attachment",
+                 :transfer_encoding => "base64" }.merge(params)
+      part(params, &block)
+    end
+
+    private
+    
+      def parse_content_type(defaults=nil)
+        if content_type.blank? 
+          return defaults                                                ? 
+            [ defaults.content_type, { 'charset' => defaults.charset } ] : 
+            [ nil, {} ] 
+        end 
+        ctype, *attrs = content_type.split(/;\s*/)
+        attrs = attrs.inject({}) { |h,s| k,v = s.split(/=/, 2); h[k] = v; h }
+        [ctype, {"charset" => charset || defaults && defaults.charset}.merge(attrs)]
+      end
+
+  end
+end

data/lib/action_mailer/quoting.rb

@@ -0,0 +1,61 @@
+module ActionMailer
+  module Quoting #:nodoc:
+    # Convert the given text into quoted printable format, with an instruction
+    # that the text be eventually interpreted in the given charset.
+    def quoted_printable(text, charset)
+      text = text.gsub( /[^a-z ]/i ) { quoted_printable_encode($&) }.
+                  gsub( / /, "_" )
+      "=?#{charset}?Q?#{text}?="
+    end
+
+    # Convert the given character to quoted printable format, taking into
+    # account multi-byte characters (if executing with $KCODE="u", for instance)
+    def quoted_printable_encode(character)
+      result = ""
+      character.each_byte { |b| result << "=%02X" % b }
+      result
+    end
+
+    # A quick-and-dirty regexp for determining whether a string contains any
+    # characters that need escaping.
+    if !defined?(CHARS_NEEDING_QUOTING)
+      CHARS_NEEDING_QUOTING = /[\000-\011\013\014\016-\037\177-\377]/
+    end
+
+    # Quote the given text if it contains any "illegal" characters
+    def quote_if_necessary(text, charset)
+      text = text.dup.force_encoding(Encoding::ASCII_8BIT) if text.respond_to?(:force_encoding)
+
+      (text =~ CHARS_NEEDING_QUOTING) ?
+        quoted_printable(text, charset) :
+        text
+    end
+
+    # Quote any of the given strings if they contain any "illegal" characters
+    def quote_any_if_necessary(charset, *args)
+      args.map { |v| quote_if_necessary(v, charset) }
+    end
+
+    # Quote the given address if it needs to be. The address may be a
+    # regular email address, or it can be a phrase followed by an address in
+    # brackets. The phrase is the only part that will be quoted, and only if
+    # it needs to be. This allows extended characters to be used in the
+    # "to", "from", "cc", "bcc" and "reply-to" headers.
+    def quote_address_if_necessary(address, charset)
+      if Array === address
+        address.map { |a| quote_address_if_necessary(a, charset) }
+      elsif address =~ /^(\S.*)\s+(<.*>)$/
+        address = $2
+        phrase = quote_if_necessary($1.gsub(/^['"](.*)['"]$/, '\1'), charset)
+        "\"#{phrase}\" #{address}"
+      else
+        address
+      end
+    end
+
+    # Quote any of the given addresses, if they need to be.
+    def quote_any_address_if_necessary(charset, *args)
+      args.map { |v| quote_address_if_necessary(v, charset) }
+    end
+  end
+end

data/lib/action_mailer/test_case.rb

@@ -0,0 +1,64 @@
+require 'active_support/test_case'
+
+module ActionMailer
+  class NonInferrableMailerError < ::StandardError
+    def initialize(name)
+      super "Unable to determine the mailer to test from #{name}. " +
+        "You'll need to specify it using tests YourMailer in your " +
+        "test case definition"
+    end
+  end
+
+  class TestCase < ActiveSupport::TestCase
+    include Quoting, TestHelper
+
+    setup :initialize_test_deliveries
+    setup :set_expected_mail
+
+    class << self
+      def tests(mailer)
+        write_inheritable_attribute(:mailer_class, mailer)
+      end
+
+      def mailer_class
+        if mailer = read_inheritable_attribute(:mailer_class)
+          mailer
+        else
+          tests determine_default_mailer(name)
+        end
+      end
+
+      def determine_default_mailer(name)
+        name.sub(/Test$/, '').constantize
+      rescue NameError => e
+        raise NonInferrableMailerError.new(name)
+      end
+    end
+
+    protected
+      def initialize_test_deliveries
+        ActionMailer::Base.delivery_method = :test
+        ActionMailer::Base.perform_deliveries = true
+        ActionMailer::Base.deliveries = []
+      end
+
+      def set_expected_mail
+        @expected = TMail::Mail.new
+        @expected.set_content_type "text", "plain", { "charset" => charset }
+        @expected.mime_version = '1.0'
+      end
+
+    private
+      def charset
+        "utf-8"
+      end
+
+      def encode(subject)
+        quoted_printable(subject, charset)
+      end
+
+      def read_fixture(action)
+        IO.readlines(File.join(RAILS_ROOT, 'test', 'fixtures', self.class.mailer_class.name.underscore, action))
+      end
+  end
+end

data/lib/action_mailer/test_helper.rb

@@ -0,0 +1,68 @@
+module ActionMailer
+  module TestHelper
+    # Asserts that the number of emails sent matches the given number.
+    #
+    #   def test_emails
+    #     assert_emails 0
+    #     ContactMailer.deliver_contact
+    #     assert_emails 1
+    #     ContactMailer.deliver_contact
+    #     assert_emails 2
+    #   end
+    #
+    # If a block is passed, that block should cause the specified number of emails to be sent.
+    #
+    #   def test_emails_again
+    #     assert_emails 1 do
+    #       ContactMailer.deliver_contact
+    #     end
+    #
+    #     assert_emails 2 do
+    #       ContactMailer.deliver_contact
+    #       ContactMailer.deliver_contact
+    #     end
+    #   end
+    def assert_emails(number)
+      if block_given?
+        original_count = ActionMailer::Base.deliveries.size
+        yield
+        new_count = ActionMailer::Base.deliveries.size
+        assert_equal original_count + number, new_count, "#{number} emails expected, but #{new_count - original_count} were sent"
+      else
+        assert_equal number, ActionMailer::Base.deliveries.size
+      end
+    end
+
+    # Assert that no emails have been sent.
+    #
+    #   def test_emails
+    #     assert_no_emails
+    #     ContactMailer.deliver_contact
+    #     assert_emails 1
+    #   end
+    #
+    # If a block is passed, that block should not cause any emails to be sent.
+    #
+    #   def test_emails_again
+    #     assert_no_emails do
+    #       # No emails should be sent from this block
+    #     end
+    #   end
+    #
+    # Note: This assertion is simply a shortcut for:
+    #
+    #   assert_emails 0
+    def assert_no_emails(&block)
+      assert_emails 0, &block
+    end
+  end
+end
+
+# TODO: Deprecate this
+module Test
+  module Unit
+    class TestCase
+      include ActionMailer::TestHelper
+    end
+  end
+end

data/lib/action_mailer/utils.rb

@@ -0,0 +1,7 @@
+module ActionMailer
+  module Utils #:nodoc:
+    def normalize_new_lines(text)
+      text.to_s.gsub(/\r\n?/, "\n")
+    end
+  end
+end