actionmailer 0.9.1 → 1.0.0

data/lib/action_mailer/helpers.rb

@@ -0,0 +1,115 @@
+module ActionMailer #:nodoc:
+  module Helpers #:nodoc:
+    def self.append_features(base)
+      super
+
+      # 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 :inherited_without_helper, :inherited
+          alias_method :inherited, :inherited_with_helper
+        end
+
+        # Wrap initialize_template_class to extend new template class
+        # instances with the master helper module.
+        alias_method :initialize_template_class_without_helper, :initialize_template_class
+        alias_method :initialize_template_class, :initialize_template_class_with_helper
+      end
+    end
+
+    module ClassMethods #:nodoc:
+      # 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).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.underscore
+          rescue MissingSourceFile => e
+            raise unless e.is_missing?("helpers/#{child.name.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/part.rb

@@ -0,0 +1,76 @@
+require 'action_mailer/adv_attr_accessor'
+require 'action_mailer/part_container'
+require 'action_mailer/utils'
+
+module ActionMailer
+  class Part #:nodoc:
+    include ActionMailer::AdvAttrAccessor
+    include ActionMailer::PartContainer
+
+    adv_attr_accessor :content_type, :content_disposition, :charset, :body
+    adv_attr_accessor :filename, :transfer_encoding, :headers
+
+    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
+
+    def to_mail(defaults)
+      part = TMail::Mail.new
+
+      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 = [Utils.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"
+          part.set_content_type(content_type || defaults.content_type, nil,
+            squish("charset" => nil, "name" => filename))
+          part.set_content_disposition(content_disposition,
+            squish("filename" => filename))
+        else
+          part.set_content_type(content_type || defaults.content_type, nil,
+            "charset" => (charset || defaults.charset))      
+          part.set_content_disposition(content_disposition) 
+        end        
+      else
+        if String === body
+          part = TMail::Mail.new
+          part.body = body
+          part.set_content_type content_type, nil, { "charset" => charset }
+          part.set_content_disposition "inline"
+          m.parts << part
+        end
+          
+        @parts.each do |p|
+          prt = (TMail::Mail === p ? p : p.to_mail(defaults))
+          part.parts << prt
+        end
+        
+        part.set_content_type(content_type, nil, { "charset" => charset }) if content_type =~ /multipart/
+      end
+    
+      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,25 @@
+module ActionMailer
+  module PartContainer #:nodoc:
+    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
+
+  end
+end

data/lib/action_mailer/quoting.rb

@@ -0,0 +1,99 @@
+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 ) { "=%02x" % $&[0] }.gsub( / /, "_" )
+      "=?#{charset}?Q?#{text}?="
+    end
+
+    # A quick-and-dirty regexp for determining whether a string contains any
+    # characters that need escaping.
+    CHARS_NEEDING_QUOTING = /[\000-\011\013\014\016-\037\177-\377]/
+
+    # Quote the given text if it contains any "illegal" characters
+    def quote_if_necessary(text, charset)
+      (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", and "bcc" 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
+
+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 ) { "=%02x" % $&[0] }.gsub( / /, "_" )
+      "=?#{charset}?Q?#{text}?="
+    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 =~ 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", and "bcc" 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/utils.rb

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

data/lib/action_mailer/vendor/tmail/attachments.rb

@@ -14,18 +14,19 @@ module TMail
       if multipart?
         parts.collect { |part| 
           if part.header["content-type"].main_type != "text"
-            content   = part.body.unpack("m")[0]
-            content   = part.body if content.blank?
-            file_name = part.header["content-type"].params["name"]
+            content   = part.body # unquoted automatically by TMail#body
+            file_name = part.sub_header("content-type", "name") ||
+                        part.sub_header("content-disposition", "filename")
             
             next if file_name.blank? || content.blank?
             
             attachment = Attachment.new(content)
-            attachment.original_filename = file_name.strip.dup
+            attachment.original_filename = file_name.strip
+            attachment.content_type = part.content_type
             attachment
           end
         }.compact
       end      
     end
   end
-end
+end

data/lib/action_mailer/vendor/tmail/encode.rb

@@ -253,6 +253,7 @@ module TMail
     # FIXME: implement line folding
     #
     def kv_pair( k, v )
+      return if v.nil?
       v = normalize_encoding(v)
       if token_safe?(v)
         add_text k + '=' + v

data/lib/action_mailer/vendor/tmail/facade.rb

@@ -442,7 +442,8 @@ module TMail
         h.disposition = str
         h.params.clear
       else
-        h = store('Content-Disposition', str)
+        store('Content-Disposition', str)
+        h = @header['content-disposition']
       end
       h.params.replace params if params
     end

data/lib/action_mailer/vendor/tmail/mail.rb

@@ -145,6 +145,10 @@ module TMail
       @header[key.downcase]
     end
 
+    def sub_header(key, param)
+      (hdr = self[key]) ? hdr[param] : nil
+    end
+
     alias fetch []
 
     def []=( key, val )

data/lib/action_mailer/vendor/tmail/net.rb

@@ -61,7 +61,7 @@ module TMail
     end
 
     def add_message_id( fqdn = nil )
-      self.message_id = ::TMail::new_msgid(fqdn)
+      self.message_id = ::TMail::new_message_id(fqdn)
     end
 
     def add_date

data/lib/action_mailer/vendor/tmail/quoting.rb

@@ -1,101 +1,124 @@
-begin
-  require 'iconv'
-  require 'base64'
-
-  module TMail
-    class Mail
-      def subject(to_charset = 'utf-8')
-        Unquoter.unquote_and_convert_to(quoted_subject, to_charset)
-      end
-
-      def unquoted_body(to_charset = 'utf-8')
-        from_charset = header['content-type']['charset'] rescue 'us-ascii'
-        Unquoter.unquote_and_convert_to(quoted_body, to_charset, from_charset)
-      end
+module TMail
+  class Mail
+    def subject(to_charset = 'utf-8')
+      Unquoter.unquote_and_convert_to(quoted_subject, to_charset)
+    end
 
-      def body(to_charset = 'utf-8', &block)
-        attachment_presenter = block || Proc.new { |file_name| "Attachment: #{file_name}\n" }
-      
-        if multipart?
-          parts.collect { |part| 
-            part.header["content-type"].main_type == "text" ? 
-              part.unquoted_body(to_charset) :
-              attachment_presenter.call(part.header["content-type"].params["name"])
-          }.join
+    def unquoted_body(to_charset = 'utf-8')
+      from_charset = sub_header("content-type", "charset")
+      case (content_transfer_encoding || "7bit").downcase
+        when "quoted-printable"
+          Unquoter.unquote_quoted_printable_and_convert_to(quoted_body,
+            to_charset, from_charset)
+        when "base64"
+          Unquoter.unquote_base64_and_convert_to(quoted_body, to_charset,
+            from_charset)
+        when "7bit", "8bit"
+          Unquoter.convert_to(quoted_body, to_charset, from_charset)
+        when "binary"
+          quoted_body
         else
-          unquoted_body(to_charset)
-        end
+          quoted_body
       end
     end
 
-    class Unquoter
-      class << self
-        def unquote_and_convert_to(text, to_charset, from_charset = "iso-8859-1")
-          return "" if text.nil?
-          if text =~ /^=\?(.*?)\?(.)\?(.*)\?=$/
-            from_charset = $1
-            quoting_method = $2
-            text = $3
-            case quoting_method.upcase
-              when "Q" then
-                unquote_quoted_printable_and_convert_to(text, from_charset, to_charset)
-              when "B" then
-                unquote_base64_and_convert_to(text, from_charset, to_charset)
-              else
-                raise "unknown quoting method #{quoting_method.inspect}"
-            end
+    def body(to_charset = 'utf-8', &block)
+      attachment_presenter = block || Proc.new { |file_name| "Attachment: #{file_name}\n" }
+    
+      if multipart?
+        parts.collect { |part| 
+          header = part["content-type"]
+
+          if part.multipart?
+            part.body(to_charset, &attachment_presenter)
+          elsif header.nil?
+            ""
+          elsif header.main_type == "text"
+            part.unquoted_body(to_charset)
           else
-            unquote_quoted_printable_and_convert_to(text, from_charset, to_charset)
+            attachment_presenter.call(header["name"] || "(unnamed)")
           end
-        end
-   
-        def unquote_quoted_printable_and_convert_to(text, from, to)
-          text ? Iconv.iconv(to, from || "ISO-8859-1", text.gsub(/_/," ").unpack("M*").first).first : ""
-        end
-   
-        def unquote_base64_and_convert_to(text, from, to)
-          text ? Iconv.iconv(to, from || "ISO-8859-1", Base64.decode64(text)).first : ""
-        end
+        }.join
+      else
+        unquoted_body(to_charset)
       end
     end
   end
 
-  if __FILE__ == $0
-    require 'test/unit'
- 
-    class TC_Unquoter < Test::Unit::TestCase
-      def test_unquote_quoted_printable
-        a ="=?ISO-8859-1?Q?[166417]_Bekr=E6ftelse_fra_Rejsefeber?=" 
-        b = TMail::Unquoter.unquote_and_convert_to(a, 'utf-8')
-        assert_equal "[166417] Bekr\303\246ftelse fra Rejsefeber", b
+  class Unquoter
+    class << self
+      def unquote_and_convert_to(text, to_charset, from_charset = "iso-8859-1")
+        return "" if text.nil?
+        if text =~ /^=\?(.*?)\?(.)\?(.*)\?=$/
+          from_charset = $1
+          quoting_method = $2
+          text = $3
+          case quoting_method.upcase
+            when "Q" then
+              unquote_quoted_printable_and_convert_to(text, to_charset, from_charset)
+            when "B" then
+              unquote_base64_and_convert_to(text, to_charset, from_charset)
+            else
+              raise "unknown quoting method #{quoting_method.inspect}"
+          end
+        else
+          convert_to(text, to_charset, from_charset)
+        end
       end
  
-      def test_unquote_base64
-        a ="=?ISO-8859-1?B?WzE2NjQxN10gQmVrcuZmdGVsc2UgZnJhIFJlanNlZmViZXI=?="
-        b = TMail::Unquoter.unquote_and_convert_to(a, 'utf-8')
-        assert_equal "[166417] Bekr\303\246ftelse fra Rejsefeber", b
+      def unquote_quoted_printable_and_convert_to(text, to, from)
+        convert_to(text.gsub(/_/," ").unpack("M*").first, to, from)
       end
  
-      def test_unquote_without_charset
-        a ="[166417]_Bekr=E6ftelse_fra_Rejsefeber" 
-        b = TMail::Unquoter.unquote_and_convert_to(a, 'utf-8')
-        assert_equal "[166417] Bekr\303\246ftelse fra Rejsefeber", b
+      def unquote_base64_and_convert_to(text, to, from)
+        convert_to(Base64.decode(text).first, to, from)
+      end
+
+      begin
+        require 'iconv'
+        def convert_to(text, to, from)
+          return text unless to && from
+          text ? Iconv.iconv(to, from, text).first : ""
+        rescue Iconv::IllegalSequence, Errno::EINVAL
+          # the 'from' parameter specifies a charset other than what the text
+          # actually is...not much we can do in this case but just return the
+          # unconverted text.
+          #
+          # Ditto if either parameter represents an unknown charset, like
+          # X-UNKNOWN.
+          text
+        end
+      rescue LoadError
+        # Not providing quoting support
+        def convert_to(text, to, from)
+          warn "Action Mailer: iconv not loaded; ignoring conversion from #{from} to #{to} (#{__FILE__}:#{__LINE__})"
+          text
+        end
       end
     end
   end
-rescue LoadError => e
-  # Not providing quoting support
-  module TMail
-    class Mail
-      def subject
-        warn "Action Mailer: iconv couldn't be required, so the charset conversion is skipped"
-        quoted_subject
-      end
-      
-      def body
-        warn "Action Mailer: iconv couldn't be required, so the charset conversion is skipped"
-        quoted_body
-      end
+end
+
+if __FILE__ == $0
+  require 'test/unit'
+
+  class TC_Unquoter < Test::Unit::TestCase
+    def test_unquote_quoted_printable
+      a ="=?ISO-8859-1?Q?[166417]_Bekr=E6ftelse_fra_Rejsefeber?=" 
+      b = TMail::Unquoter.unquote_and_convert_to(a, 'utf-8')
+      assert_equal "[166417] Bekr\303\246ftelse fra Rejsefeber", b
+    end
+
+    def test_unquote_base64
+      a ="=?ISO-8859-1?B?WzE2NjQxN10gQmVrcuZmdGVsc2UgZnJhIFJlanNlZmViZXI=?="
+      b = TMail::Unquoter.unquote_and_convert_to(a, 'utf-8')
+      assert_equal "[166417] Bekr\303\246ftelse fra Rejsefeber", b
+    end
+
+    def test_unquote_without_charset
+      a ="[166417]_Bekr=E6ftelse_fra_Rejsefeber" 
+      b = TMail::Unquoter.unquote_and_convert_to(a, 'utf-8')
+      assert_equal "[166417]_Bekr=E6ftelse_fra_Rejsefeber", b
     end
   end
 end