mail 2.6.6 → 2.8.1

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

@@ -1,37 +0,0 @@
-%%{
-  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

@@ -1,37 +0,0 @@
-%%{
-  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

@@ -1,40 +0,0 @@
-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

@@ -1,18 +0,0 @@
-# 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/version_specific/ruby_1_8.rb

@@ -1,126 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-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
-    # to do two replacement, first unescape everything, then re-escape it
-    def Ruby18.escape_paren( str )
-      re = /\\\)/
-      str = str.gsub(re) { |s| ')'}
-      re = /\\\(/
-      str = str.gsub(re) { |s| '('}
-      re = /([\(\)])/          # Only match unescaped parens
-      str.gsub(re) { |s| '\\' + s }
-    end
-
-    def Ruby18.paren( str )
-      str = $1 if str =~ /^\((.*)?\)$/
-      str = escape_paren( str )
-      '(' + str + ')'
-    end
-
-    def Ruby18.escape_bracket( str )
-      re = /\\\>/
-      str = str.gsub(re) { |s| '>'}
-      re = /\\\</
-      str = str.gsub(re) { |s| '<'}
-      re = /([\<\>])/          # Only match unescaped parens
-      str.gsub(re) { |s| '\\' + s }
-    end
-
-    def Ruby18.bracket( str )
-      str = $1 if str =~ /^\<(.*)?\>$/
-      str = escape_bracket( str )
-      '<' + str + '>'
-    end
-
-    def Ruby18.decode_base64(str)
-      Base64.decode64(str) if str
-    end
-
-    def Ruby18.encode_base64(str)
-      Base64.encode64(str)
-    end
-
-    def Ruby18.has_constant?(klass, string)
-      klass.constants.include?( string )
-    end
-
-    def Ruby18.get_constant(klass, string)
-      klass.const_get( string )
-    end
-
-    def Ruby18.transcode_charset(str, from_encoding, to_encoding = 'UTF-8')
-      Iconv.conv("#{normalize_iconv_charset_encoding(to_encoding)}//IGNORE", normalize_iconv_charset_encoding(from_encoding), str)
-    end
-
-    def Ruby18.b_value_encode(str, encoding)
-      # 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), normalize_iconv_charset_encoding(encoding)]
-    end
-
-    def Ruby18.b_value_decode(str)
-      match = str.match(/\=\?(.+)?\?[Bb]\?(.*)\?\=/m)
-      if match
-        encoding = match[1]
-        str = Ruby18.decode_base64(match[2])
-        str = transcode_charset(str, encoding)
-      end
-      str
-    end
-
-    def Ruby18.q_value_encode(str, encoding)
-      # Ruby 1.8 requires an encoding to work
-      raise ArgumentError, "Must supply an encoding" if encoding.nil?
-      encoding = encoding.to_s.upcase.gsub('_', '-')
-      [Encodings::QuotedPrintable.encode(str), encoding]
-    end
-
-    def Ruby18.q_value_decode(str)
-      match = str.match(/\=\?(.+)?\?[Qq]\?(.*)\?\=/m)
-      if match
-        encoding = match[1]
-        string = match[2].gsub(/_/, '=20')
-        # Remove trailing = if it exists in a Q encoding
-        string = string.sub(/\=$/, '')
-        str = Encodings::QuotedPrintable.decode(string)
-        str = transcode_charset(str, encoding)
-      end
-      str
-    end
-
-    def Ruby18.param_decode(str, encoding)
-      URI.unescape(str)
-    end
-
-    def Ruby18.param_encode(str)
-      encoding = $KCODE.to_s.downcase
-      language = Configuration.instance.param_encode_language
-      "#{encoding}'#{language}'#{URI.escape(str)}"
-    end
-
-    private
-
-    def Ruby18.normalize_iconv_charset_encoding(encoding)
-      case encoding.upcase
-      when 'UTF8', 'UTF_8'
-        'UTF-8'
-      when 'UTF16', 'UTF-16'
-        'UTF-16BE'
-      when 'UTF32', 'UTF-32'
-        'UTF-32BE'
-      when 'KS_C_5601-1987'
-        'CP949'
-      else
-        encoding
-      end
-    end
-  end
-end

data/lib/mail/version_specific/ruby_1_9.rb

@@ -1,226 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-module Mail
-  class Ruby19
-    class StrictCharsetEncoder
-      def encode(string, charset)
-        string.force_encoding(Mail::Ruby19.pick_encoding(charset))
-      end
-    end
-
-    class BestEffortCharsetEncoder
-      def encode(string, charset)
-        string.force_encoding(pick_encoding(charset))
-      end
-
-      private
-
-      def pick_encoding(charset)
-        charset = case charset
-        when /ansi_x3.110-1983/
-          'ISO-8859-1'
-        when /Windows-?1258/i # Windows-1258 is similar to 1252
-          "Windows-1252"
-        else
-          charset
-        end
-        Mail::Ruby19.pick_encoding(charset)
-      end
-    end
-
-    class << self
-      attr_accessor :charset_encoder
-    end
-    self.charset_encoder = StrictCharsetEncoder.new
-
-    # Escapes any parenthesis in a string that are unescaped this uses
-    # a Ruby 1.9.1 regexp feature of negative look behind
-    def Ruby19.escape_paren( str )
-      re = /(?<!\\)([\(\)])/          # Only match unescaped parens
-      str.gsub(re) { |s| '\\' + s }
-    end
-
-    def Ruby19.paren( str )
-      str = $1 if str =~ /^\((.*)?\)$/
-      str = escape_paren( str )
-      '(' + str + ')'
-    end
-
-    def Ruby19.escape_bracket( str )
-      re = /(?<!\\)([\<\>])/          # Only match unescaped brackets
-      str.gsub(re) { |s| '\\' + s }
-    end
-
-    def Ruby19.bracket( str )
-      str = $1 if str =~ /^\<(.*)?\>$/
-      str = escape_bracket( str )
-      '<' + str + '>'
-    end
-
-    def Ruby19.decode_base64(str)
-      if !str.end_with?("=") && str.length % 4 != 0
-        str = str.ljust((str.length + 3) & ~3, "=")
-      end
-      str.unpack( 'm' ).first
-    end
-
-    def Ruby19.encode_base64(str)
-      [str].pack( 'm' )
-    end
-
-    def Ruby19.has_constant?(klass, string)
-      klass.const_defined?( string, false )
-    end
-
-    def Ruby19.get_constant(klass, string)
-      klass.const_get( string )
-    end
-
-    def Ruby19.transcode_charset(str, from_encoding, to_encoding = Encoding::UTF_8)
-      charset_encoder.encode(str.dup, from_encoding).encode(to_encoding, :undef => :replace, :invalid => :replace, :replace => '')
-    end
-
-    def Ruby19.b_value_encode(str, encoding = nil)
-      encoding = str.encoding.to_s
-      [Ruby19.encode_base64(str), encoding]
-    end
-
-    def Ruby19.b_value_decode(str)
-      match = str.match(/\=\?(.+)?\?[Bb]\?(.*)\?\=/m)
-      if match
-        charset = match[1]
-        str = Ruby19.decode_base64(match[2])
-        str = charset_encoder.encode(str, charset)
-      end
-      decoded = str.encode(Encoding::UTF_8, :invalid => :replace, :replace => "")
-      decoded.valid_encoding? ? decoded : decoded.encode(Encoding::UTF_16LE, :invalid => :replace, :replace => "").encode(Encoding::UTF_8)
-    rescue Encoding::UndefinedConversionError, ArgumentError, Encoding::ConverterNotFoundError
-      warn "Encoding conversion failed #{$!}"
-      str.dup.force_encoding(Encoding::UTF_8)
-    end
-
-    def Ruby19.q_value_encode(str, encoding = nil)
-      encoding = str.encoding.to_s
-      [Encodings::QuotedPrintable.encode(str), encoding]
-    end
-
-    def Ruby19.q_value_decode(str)
-      match = str.match(/\=\?(.+)?\?[Qq]\?(.*)\?\=/m)
-      if match
-        charset = match[1]
-        string = match[2].gsub(/_/, '=20')
-        # Remove trailing = if it exists in a Q encoding
-        string = string.sub(/\=$/, '')
-        str = Encodings::QuotedPrintable.decode(string)
-        str = charset_encoder.encode(str, charset)
-        # We assume that binary strings hold utf-8 directly to work around
-        # jruby/jruby#829 which subtly changes String#encode semantics.
-        str.force_encoding(Encoding::UTF_8) if str.encoding == Encoding::ASCII_8BIT
-      end
-      decoded = str.encode(Encoding::UTF_8, :invalid => :replace, :replace => "")
-      decoded.valid_encoding? ? decoded : decoded.encode(Encoding::UTF_16LE, :invalid => :replace, :replace => "").encode(Encoding::UTF_8)
-    rescue Encoding::UndefinedConversionError, ArgumentError, Encoding::ConverterNotFoundError
-      warn "Encoding conversion failed #{$!}"
-      str.dup.force_encoding(Encoding::UTF_8)
-    end
-
-    def Ruby19.param_decode(str, encoding)
-      str = uri_parser.unescape(str)
-      str = charset_encoder.encode(str, encoding) if encoding
-      str
-    end
-
-    def Ruby19.param_encode(str)
-      encoding = str.encoding.to_s.downcase
-      language = Configuration.instance.param_encode_language
-      "#{encoding}'#{language}'#{uri_parser.escape(str)}"
-    end
-
-    def Ruby19.uri_parser
-      @uri_parser ||= URI::Parser.new
-    end
-
-    # Pick a Ruby encoding corresponding to the message charset. Most
-    # charsets have a Ruby encoding, but some need manual aliasing here.
-    #
-    # TODO: add this as a test somewhere:
-    #   Encoding.list.map { |e| [e.to_s.upcase == pick_encoding(e.to_s.downcase.gsub("-", "")), e.to_s] }.select {|a,b| !b}
-    #   Encoding.list.map { |e| [e.to_s == pick_encoding(e.to_s), e.to_s] }.select {|a,b| !b}
-    def Ruby19.pick_encoding(charset)
-      charset = charset.to_s
-      encoding = case charset.downcase
-
-      # ISO-8859-8-I etc. http://en.wikipedia.org/wiki/ISO-8859-8-I
-      when /^iso[-_]?8859-(\d+)(-i)?$/
-        "ISO-8859-#{$1}"
-
-      # ISO-8859-15, ISO-2022-JP and alike
-      when /^iso[-_]?(\d{4})-?(\w{1,2})$/
-        "ISO-#{$1}-#{$2}"
-
-      # "ISO-2022-JP-KDDI"  and alike
-      when /^iso[-_]?(\d{4})-?(\w{1,2})-?(\w*)$/
-        "ISO-#{$1}-#{$2}-#{$3}"
-
-      # UTF-8, UTF-32BE and alike
-      when /^utf[\-_]?(\d{1,2})?(\w{1,2})$/
-        "UTF-#{$1}#{$2}".gsub(/\A(UTF-(?:16|32))\z/, '\\1BE')
-
-      # Windows-1252 and alike
-      when /^windows-?(.*)$/
-        "Windows-#{$1}"
-
-      when '8bit'
-        Encoding::ASCII_8BIT
-
-      # alternatives/misspellings of us-ascii seen in the wild
-      when /^iso[-_]?646(-us)?$/, 'us=ascii'
-        Encoding::ASCII
-
-      # Microsoft-specific alias for MACROMAN
-      when 'macintosh'
-        Encoding::MACROMAN
-
-      # Microsoft-specific alias for CP949 (Korean)
-      when 'ks_c_5601-1987'
-        Encoding::CP949
-
-      # Wrongly written Shift_JIS (Japanese)
-      when 'shift-jis'
-        Encoding::Shift_JIS
-
-      # GB2312 (Chinese charset) is a subset of GB18030 (its replacement)
-      when 'gb2312'
-        Encoding::GB18030
-
-      when 'cp-850'
-        Encoding::CP850
-
-      when 'latin2'
-        Encoding::ISO_8859_2
-
-      else
-        charset
-      end
-
-      convert_to_encoding(encoding)
-    end
-
-    class << self
-      private
-
-      def convert_to_encoding(encoding)
-        if encoding.is_a?(Encoding)
-          encoding
-        else
-          begin
-            Encoding.find(encoding)
-          rescue ArgumentError
-            Encoding::BINARY
-          end
-        end
-      end
-    end
-  end
-end