mail 2.4.4 → 2.6.3

data/lib/mail/parsers/ragel/ruby/machines/received_machine.rb.rl

@@ -0,0 +1,37 @@
+%%{
+  machine received;
+
+  include rb_actions "rb_actions.rl";
+  include common "../../common.rl";
+
+  getkey data_unpacked[p];
+
+  main := received;
+}%%
+
+module Mail
+  module Parsers
+    module Ragel
+      module ReceivedMachine
+        %%write data;
+
+        def self.parse(data)
+          p = 0
+          eof = data.length
+          stack = []
+
+          actions = []
+          data_unpacked = data.bytes.to_a
+          %%write init;
+          %%write exec;
+
+          if p == eof && cs >= %%{ write first_final; }%%
+            return actions, nil
+          else
+            return [], "Only able to parse up to #{data[0..p]}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mail/parsers/ragel/ruby/parser.rb.rl.erb

@@ -0,0 +1,37 @@
+%%{
+  machine <%= parser_name %>;
+
+  include rb_actions "rb_actions.rl";
+  include common "../../common.rl";
+
+  getkey data_unpacked[p];
+
+  main := <%= parser_name %>;
+}%%
+
+module Mail
+  module Parsers
+    module Ragel
+      module <%= parser_name_cc %>
+        %%write data;
+
+        def self.parse(data)
+          p = 0
+          eof = data.length
+          stack = []
+
+          actions = []
+          data_unpacked = data.bytes.to_a
+          %%write init;
+          %%write exec;
+
+          if p == eof && cs >= %%{ write first_final; }%%
+            return actions, nil
+          else
+            return [], "Only able to parse up to #{data[0..p]}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mail/parsers/ragel/ruby.rb

@@ -0,0 +1,40 @@
+module Mail
+  module Parsers
+    module Ragel
+      module Ruby
+        def self.silence_warnings
+          old, $VERBOSE = $VERBOSE, nil
+          yield
+        ensure
+          $VERBOSE = old
+        end
+
+        # Ragel-generated parsers give a lot of warnings
+        # and may cause logs to balloon in size
+        silence_warnings do
+          Mail::Parsers::Ragel::FIELD_PARSERS.each do |field_parser|
+            require "mail/parsers/ragel/ruby/machines/#{field_parser}_machine"
+          end
+        end
+
+        MACHINE_LIST = {
+          :address_lists => AddressListsMachine,
+          :phrase_lists => PhraseListsMachine,
+          :date_time => DateTimeMachine,
+          :received => ReceivedMachine,
+          :message_ids => MessageIdsMachine,
+          :envelope_from => EnvelopeFromMachine,
+          :mime_version => MimeVersionMachine,
+          :content_type => ContentTypeMachine,
+          :content_disposition => ContentDispositionMachine,
+          :content_transfer_encoding => ContentTransferEncodingMachine,
+          :content_location => ContentLocationMachine
+        }
+
+        def self.parse(machine, string)
+          MACHINE_LIST[machine].parse(string)
+        end
+      end
+    end
+  end
+end

data/lib/mail/parsers/ragel.rb

@@ -0,0 +1,17 @@
+module Mail
+  module Parsers
+    module Ragel
+      require 'mail/parsers/ragel/parser_info'
+      require "mail/parsers/ragel/ruby"
+
+      def self.parse(machine, string)
+        @machine_module ||= Ruby
+        @machine_module.parse(machine, string)
+      end
+
+      def self.machine_module=(m)
+        @machine_module = m
+      end
+    end
+  end
+end

data/lib/mail/parsers/received_parser.rb

@@ -0,0 +1,47 @@
+module Mail::Parsers
+  class ReceivedParser
+
+    def parse(s)
+      actions, error = Ragel.parse(:received, s)
+      if error
+        raise Mail::Field::ParseError.new(Mail::ReceivedElement, s, error)
+      end
+
+      received = ReceivedStruct.new
+
+      received_tokens_s = date_s = time_s = nil
+      actions.each_slice(2) do |action_id, p|
+        action = Mail::Parsers::Ragel::ACTIONS[action_id]
+        case action
+
+        # Received Tokens:
+        when :received_tokens_s then received_tokens_s = p
+        when :received_tokens_e
+          received.info = s[received_tokens_s..(p-1)]
+
+        # Date
+        when :date_s then date_s = p
+        when :date_e
+          received.date = s[date_s..(p-1)].strip
+
+        # Time
+        when :time_s then time_s = p
+        when :time_e
+          received.time = s[time_s..(p-1)]
+
+        when :angle_addr_s, :comment_e, :comment_s,
+             :domain_e, :domain_s, :local_dot_atom_e,
+             :local_dot_atom_pre_comment_e,
+             :local_dot_atom_pre_comment_s,
+             :local_dot_atom_s, :qstr_e, :qstr_s,
+             :local_quoted_string_s, :local_quoted_string_e
+          # ignored actions
+
+        else
+          raise Mail::Field::ParseError.new(Mail::ReceivedElement, s, "Failed to process unknown action: #{action}")
+        end
+      end
+      received
+    end
+  end
+end

data/lib/mail/parsers.rb

@@ -0,0 +1,26 @@
+module Mail
+  module Parsers
+
+    # Low-level ragel based parsers
+    require 'mail/parsers/ragel'
+
+    AddressListStruct = Struct.new(:addresses, :group_names, :error)
+    AddressStruct = Struct.new(:raw, :domain, :comments, :local,
+                             :obs_domain_list, :display_name, :group, :error)
+    ContentDispositionStruct = Struct.new(:disposition_type, :parameters, :error)
+    ContentLocationStruct = Struct.new(:location, :error)
+    ContentTransferEncodingStruct = Struct.new(:encoding, :error)
+    ContentTypeStruct = Struct.new(:main_type, :sub_type, :parameters, :error)
+    DateTimeStruct = Struct.new(:date_string, :time_string, :error)
+    EnvelopeFromStruct = Struct.new(:address, :ctime_date, :error)
+    MessageIdsStruct = Struct.new(:message_ids, :error)
+    MimeVersionStruct = Struct.new(:major, :minor, :error)
+    PhraseListsStruct = Struct.new(:phrases, :error)
+    ReceivedStruct = Struct.new(:date, :time, :info, :error)
+
+    require 'mail/parsers/ragel/parser_info'
+    Ragel::FIELD_PARSERS.each do |field_parser|
+      require "mail/parsers/#{field_parser}_parser"
+    end
+  end
+end

data/lib/mail/part.rb

@@ -38,8 +38,12 @@ module Mail
     end
     
     def add_required_fields
-      add_content_id unless has_content_id?
       super
+      add_content_id if !has_content_id? && inline?
+    end
+
+    def add_required_message_fields
+      # Override so we don't add Date, MIME-Version, or Message-ID.
     end
     
     def delivery_status_report_part?
@@ -113,4 +117,4 @@ module Mail
 
   end
   
-end
+end

data/lib/mail/parts_list.rb

@@ -31,11 +31,13 @@ module Mail
     end
 
     def sort!(order)
-      sorted = self.sort do |a, b|
+      # stable sort should be used to maintain the relative order as the parts are added
+      i = 0;
+      sorted = self.sort_by do |a|
         # OK, 10000 is arbitrary... if anyone actually wants to explicitly sort 10000 parts of a
         # single email message... please show me a use case and I'll put more work into this method,
         # in the meantime, it works :)
-        get_order_value(a, order) <=> get_order_value(b, order)
+        [get_order_value(a, order), i += 1]
       end
       self.clear
       sorted.each { |p| self << p }
@@ -44,7 +46,7 @@ module Mail
   private
 
     def get_order_value(part, order)
-      if part.respond_to?(:content_type)
+      if part.respond_to?(:content_type) && !part[:content_type].nil?
         order.index(part[:content_type].string.downcase) || 10000
       else
         10000

data/lib/mail/utilities.rb

@@ -1,27 +1,29 @@
 # encoding: utf-8
 module Mail
   module Utilities
-    include Patterns
-    
+    include Constants
+
     # Returns true if the string supplied is free from characters not allowed as an ATOM
     def atom_safe?( str )
       not ATOM_UNSAFE === str
     end
 
-    # If the string supplied has ATOM unsafe characters in it, will return the string quoted 
+    # If the string supplied has ATOM unsafe characters in it, will return the string quoted
     # in double quotes, otherwise returns the string unmodified
     def quote_atom( str )
       atom_safe?( str ) ? str : dquote(str)
     end
 
-    # If the string supplied has PHRASE unsafe characters in it, will return the string quoted 
+    # If the string supplied has PHRASE unsafe characters in it, will return the string quoted
     # in double quotes, otherwise returns the string unmodified
     def quote_phrase( str )
       if RUBY_VERSION >= '1.9'
         original_encoding = str.encoding
         str.force_encoding('ASCII-8BIT')
         if (PHRASE_UNSAFE === str)
-          dquote(str).force_encoding(original_encoding)
+          quoted_str = dquote(str).force_encoding(original_encoding)
+          str.force_encoding(original_encoding)
+          quoted_str
         else
           str.force_encoding(original_encoding)
         end
@@ -35,150 +37,158 @@ module Mail
       not TOKEN_UNSAFE === str
     end
 
-    # If the string supplied has TOKEN unsafe characters in it, will return the string quoted 
+    # If the string supplied has TOKEN unsafe characters in it, will return the string quoted
     # in double quotes, otherwise returns the string unmodified
     def quote_token( str )
       token_safe?( str ) ? str : dquote(str)
     end
 
-    # Wraps supplied string in double quotes unless it is already wrapped.
-    # 
-    # Additionally will escape any double quotation marks in the string with a single
-    # backslash in front of the '"' character.
+    # Wraps supplied string in double quotes and applies \-escaping as necessary,
+    # unless it is already wrapped.
+    #
+    # Example:
+    #
+    #  string = 'This is a string'
+    #  dquote(string) #=> '"This is a string"'
+    #
+    #  string = 'This is "a string"'
+    #  dquote(string #=> '"This is \"a string\"'
     def dquote( str )
-      match = str.match(/^"(.*)?"$/)
-      str = match[1] if match
-      # First remove all escaped double quotes:
-      str = str.gsub(/\\"/, '"')
-      # Then wrap and re-escape all double quotes
-      '"' + str.gsub(/["]/n) {|s| '\\' + s } + '"'
-    end
-    
-    # Unwraps supplied string from inside double quotes.
-    # 
+      '"' + unquote(str).gsub(/[\\"]/n) {|s| '\\' + s } + '"'
+    end
+
+    # Unwraps supplied string from inside double quotes and
+    # removes any \-escaping.
+    #
     # Example:
-    # 
+    #
     #  string = '"This is a string"'
     #  unquote(string) #=> 'This is a string'
+    #
+    #  string = '"This is \"a string\""'
+    #  unqoute(string) #=> 'This is "a string"'
     def unquote( str )
-      match = str.match(/^"(.*?)"$/)
-      match ? match[1] : str
+      if str =~ /^"(.*?)"$/
+        $1.gsub(/\\(.)/, '\1')
+      else
+        str
+      end
     end
-    
+
     # Wraps a string in parenthesis and escapes any that are in the string itself.
-    # 
+    #
     # Example:
-    # 
+    #
     #  paren( 'This is a string' ) #=> '(This is a string)'
     def paren( str )
       RubyVer.paren( str )
     end
-    
+
     # Unwraps a string from being wrapped in parenthesis
-    # 
+    #
     # Example:
-    # 
+    #
     #  str = '(This is a string)'
     #  unparen( str ) #=> 'This is a string'
     def unparen( str )
       match = str.match(/^\((.*?)\)$/)
       match ? match[1] : str
     end
-    
+
     # Wraps a string in angle brackets and escapes any that are in the string itself
-    # 
+    #
     # Example:
-    # 
+    #
     #  bracket( 'This is a string' ) #=> '<This is a string>'
     def bracket( str )
       RubyVer.bracket( str )
     end
-    
+
     # Unwraps a string from being wrapped in parenthesis
-    # 
+    #
     # Example:
-    # 
+    #
     #  str = '<This is a string>'
     #  unbracket( str ) #=> 'This is a string'
     def unbracket( str )
       match = str.match(/^\<(.*?)\>$/)
       match ? match[1] : str
     end
-    
+
     # Escape parenthesies in a string
-    # 
+    #
     # Example:
-    # 
+    #
     #  str = 'This is (a) string'
     #  escape_paren( str ) #=> 'This is \(a\) string'
     def escape_paren( str )
       RubyVer.escape_paren( str )
     end
-    
+
     def uri_escape( str )
       uri_parser.escape(str)
     end
-    
+
     def uri_unescape( str )
       uri_parser.unescape(str)
     end
-    
+
     def uri_parser
       @uri_parser ||= URI.const_defined?(:Parser) ? URI::Parser.new : URI
     end
-    
+
     # Matches two objects with their to_s values case insensitively
-    # 
+    #
     # Example:
-    # 
+    #
     #  obj2 = "This_is_An_object"
     #  obj1 = :this_IS_an_object
     #  match_to_s( obj1, obj2 ) #=> true
     def match_to_s( obj1, obj2 )
-      obj1.to_s.downcase == obj2.to_s.downcase
+      obj1.to_s.casecmp(obj2.to_s) == 0
     end
-    
+
     # Capitalizes a string that is joined by hyphens correctly.
-    # 
+    #
     # Example:
-    # 
+    #
     #  string = 'resent-from-field'
     #  capitalize_field( string ) #=> 'Resent-From-Field'
     def capitalize_field( str )
       str.to_s.split("-").map { |v| v.capitalize }.join("-")
     end
-    
+
     # Takes an underscored word and turns it into a class name
-    # 
+    #
     # Example:
-    # 
+    #
     #  constantize("hello") #=> "Hello"
     #  constantize("hello-there") #=> "HelloThere"
     #  constantize("hello-there-mate") #=> "HelloThereMate"
     def constantize( str )
       str.to_s.split(/[-_]/).map { |v| v.capitalize }.to_s
     end
-    
+
     # Swaps out all underscores (_) for hyphens (-) good for stringing from symbols
     # a field name.
-    # 
+    #
     # Example:
-    # 
+    #
     #  string = :resent_from_field
     #  dasherize ( string ) #=> 'resent_from_field'
     def dasherize( str )
-      str.to_s.gsub('_', '-')
+      str.to_s.tr(UNDERSCORE, HYPHEN)
     end
 
     # Swaps out all hyphens (-) for underscores (_) good for stringing to symbols
     # a field name.
-    # 
+    #
     # Example:
-    # 
+    #
     #  string = :resent_from_field
     #  underscoreize ( string ) #=> 'resent_from_field'
     def underscoreize( str )
-      str.to_s.downcase.gsub('-', '_')
+      str.to_s.downcase.tr(HYPHEN, UNDERSCORE)
     end
 
     if RUBY_VERSION <= '1.8.6'
@@ -190,7 +200,7 @@ module Mail
         end
         results
       end
-  
+
       def map_with_index( enum, &block )
         results = []
         enum.each_with_index do |token, i|
@@ -198,7 +208,7 @@ module Mail
         end
         results
       end
-      
+
     else
 
       def map_lines( str, &block )

data/lib/mail/version.rb

@@ -1,24 +1,16 @@
-# encoding: utf-8
 module Mail
   module VERSION
-    
-    version = {}
-    File.read(File.join(File.dirname(__FILE__), '../', 'VERSION')).each_line do |line|
-      type, value = line.chomp.split(":")
-      next if type =~ /^\s+$/  || value =~ /^\s+$/
-      version[type] = value
-    end
-    
-    MAJOR = version['major']
-    MINOR = version['minor']
-    PATCH = version['patch']
-    BUILD = version['build']
+
+    MAJOR = 2
+    MINOR = 6
+    PATCH = 3
+    BUILD = nil
 
     STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.')
-    
+
     def self.version
       STRING
     end
-    
+
   end
 end

data/lib/mail/version_specific/ruby_1_8.rb

@@ -3,6 +3,7 @@
 module Mail
   class Ruby18
     require 'base64'
+    require 'iconv'
 
     # Escapes any parenthesis in a string that are unescaped. This can't
     # use the Ruby 1.9.1 regexp feature of negative look behind so we have
@@ -57,14 +58,15 @@ module Mail
       # Ruby 1.8 requires an encoding to work
       raise ArgumentError, "Must supply an encoding" if encoding.nil?
       encoding = encoding.to_s.upcase.gsub('_', '-')
-      [Encodings::Base64.encode(str), encoding]
+      [Encodings::Base64.encode(str), fix_encoding(encoding)]
     end
 
     def Ruby18.b_value_decode(str)
-      match = str.match(/\=\?(.+)?\?[Bb]\?(.+)?\?\=/m)
+      match = str.match(/\=\?(.+)?\?[Bb]\?(.*)\?\=/m)
       if match
         encoding = match[1]
         str = Ruby18.decode_base64(match[2])
+        str = Iconv.conv('UTF-8//IGNORE', fix_encoding(encoding), str)
       end
       str
     end
@@ -77,10 +79,14 @@ module Mail
     end
 
     def Ruby18.q_value_decode(str)
-      match = str.match(/\=\?(.+)?\?[Qq]\?(.+)?\?\=/m)
+      match = str.match(/\=\?(.+)?\?[Qq]\?(.*)\?\=/m)
       if match
         encoding = match[1]
-        str = Encodings::QuotedPrintable.decode(match[2].gsub(/_/, '=20'))
+        string = match[2].gsub(/_/, '=20')
+        # Remove trailing = if it exists in a Q encoding
+        string = string.sub(/\=$/, '')
+        str = Encodings::QuotedPrintable.decode(string)
+        str = Iconv.conv('UTF-8//IGNORE', fix_encoding(encoding), str)
       end
       str
     end
@@ -94,5 +100,20 @@ module Mail
       language = Configuration.instance.param_encode_language
       "#{encoding}'#{language}'#{URI.escape(str)}"
     end
+
+    private
+
+    def Ruby18.fix_encoding(encoding)
+      case encoding.upcase
+      when 'UTF8', 'UTF_8'
+        'UTF-8'
+      when 'UTF16', 'UTF-16'
+        'UTF-16BE'
+      when 'UTF32', 'UTF-32'
+        'UTF-32BE'
+      else
+        encoding
+      end
+    end
   end
 end