mail 2.5.2 → 2.6.4

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,18 @@
+# frozen_string_literal: true
+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,49 @@
+# frozen_string_literal: true
+module Mail::Parsers
+  class ReceivedParser
+
+    def parse(s)
+      raise Mail::Field::ParseError.new(Mail::ReceivedElement, s, 'nil is invalid') if s.nil?
+      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,27 @@
+# frozen_string_literal: true
+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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 module Mail
   class Part < Message
     
@@ -34,12 +35,16 @@ module Mail
     end
     
     def inline?
-      header[:content_disposition].disposition_type == 'inline' if header[:content_disposition]
+      header[:content_disposition].disposition_type == 'inline' if header[:content_disposition].respond_to?(:disposition_type)
     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?
@@ -90,8 +95,10 @@ module Mail
     def get_return_values(key)
       if delivery_status_data[key].is_a?(Array)
         delivery_status_data[key].map { |a| a.value }
-      else
+      elsif !delivery_status_data[key].nil?
         delivery_status_data[key].value
+      else
+        nil
       end
     end
     
@@ -113,4 +120,4 @@ module Mail
 
   end
   
-end
+end

data/lib/mail/parts_list.rb

@@ -1,8 +1,28 @@
+# frozen_string_literal: true
+require 'delegate'
+
 module Mail
-  class PartsList < Array
+  class PartsList < DelegateClass(Array)
+    attr_reader :parts
+
+    def initialize(*args)
+      @parts = Array.new(*args)
+      super @parts
+    end
+
+    # The #encode_with and #to_yaml methods are just implemented
+    # for the sake of backward compatibility ; the delegator does
+    # not correctly delegate these calls to the delegated object
+    def encode_with(coder) # :nodoc:
+      coder.represent_object(nil, @parts)
+    end
+
+    def to_yaml(options = {}) # :nodoc:
+      @parts.to_yaml(options)
+    end
 
     def attachments
-      Mail::AttachmentsList.new(self)
+      Mail::AttachmentsList.new(@parts)
     end
 
     def collect
@@ -14,8 +34,6 @@ module Mail
         to_a
       end
     end
-
-    undef :map
     alias_method :map, :collect
 
     def map!
@@ -27,24 +45,26 @@ module Mail
     end
 
     def sort
-      self.class.new(super)
+      self.class.new(@parts.sort)
     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 = @parts.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 }
+      @parts.clear
+      sorted.each { |p| @parts << p }
     end
 
   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,29 +1,34 @@
 # encoding: utf-8
+# frozen_string_literal: true
 module Mail
   module Utilities
-    include Patterns
-    
+
+    LF   = "\n"
+    CRLF = "\r\n"
+
+    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)
+        ascii_str = str.dup.force_encoding('ASCII-8BIT')
+        if (PHRASE_UNSAFE === ascii_str)
+          dquote(ascii_str).force_encoding(original_encoding)
         else
-          str.force_encoding(original_encoding)
+          str
         end
       else
         (PHRASE_UNSAFE === str) ? dquote(str) : str
@@ -35,150 +40,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 +203,7 @@ module Mail
         end
         results
       end
-  
+
       def map_with_index( enum, &block )
         results = []
         enum.each_with_index do |token, i|
@@ -198,7 +211,7 @@ module Mail
         end
         results
       end
-      
+
     else
 
       def map_lines( str, &block )
@@ -211,5 +224,56 @@ module Mail
 
     end
 
+    # Test String#encode works correctly with line endings.
+    # Some versions of Ruby (e.g. MRI <1.9, JRuby, Rubinius) line ending
+    # normalization does not work correctly or did not have #encode.
+    if ("\r".encode(:universal_newline => true) rescue nil) == LF &&
+      (LF.encode(:crlf_newline => true) rescue nil) == CRLF
+      # Using String#encode is better performing than Regexp
+
+      def self.to_lf(input)
+        input.kind_of?(String) ? input.to_str.encode(input.encoding, :universal_newline => true) : ''
+      end
+
+      def self.to_crlf(input)
+        input.kind_of?(String) ? input.to_str.encode(input.encoding, :universal_newline => true).encode!(input.encoding, :crlf_newline => true) : ''
+      end
+
+    else
+
+      def self.to_lf(input)
+        input.kind_of?(String) ? input.to_str.gsub(/\r\n|\r/, LF) : ''
+      end
+
+      if RUBY_VERSION >= '1.9'
+        # This 1.9 only regex can save a reasonable amount of time (~20%)
+        # by not matching "\r\n" so the string is returned unchanged in
+        # the common case.
+        CRLF_REGEX = Regexp.new("(?<!\r)\n|\r(?!\n)")
+      else
+        CRLF_REGEX = /\n|\r\n|\r/
+      end
+
+      def self.to_crlf(input)
+        input.kind_of?(String) ? input.to_str.gsub(CRLF_REGEX, CRLF) : ''
+      end
+
+    end
+
+    # Returns true if the object is considered blank.
+    # A blank includes things like '', '   ', nil,
+    # and arrays and hashes that have nothing in them.
+    #
+    # This logic is mostly shared with ActiveSupport's blank?
+    def self.blank?(value)
+      if value.kind_of?(NilClass)
+        true
+      elsif value.kind_of?(String)
+        value !~ /\S/
+      else
+        value.respond_to?(:empty?) ? value.empty? : !value
+      end
+    end
+
   end
 end

data/lib/mail/version.rb

@@ -1,24 +1,17 @@
-# encoding: utf-8
+# frozen_string_literal: true
 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 = 4
+    BUILD = nil
 
     STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.')
-    
+
     def self.version
       STRING
     end
-    
+
   end
 end