mail 2.6.1 → 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,39 +0,0 @@
-module Mail
-  module Parsers
-    module Ragel
-      module Ruby
-        def self.silence_warnings
-          original_verbose = $VERBOSE
-          $VERBOSE = nil
-          yield
-          $VERBOSE = original_verbose
-        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,17 +0,0 @@
-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/patterns.rb

@@ -1,37 +0,0 @@
-# encoding: us-ascii
-module Mail
-  module Patterns
-    white_space = %Q|\x9\x20|
-    text        = %Q|\x1-\x8\xB\xC\xE-\x7f|
-    field_name  = %Q|\x21-\x39\x3b-\x7e|
-    qp_safe     = %Q|\x20-\x3c\x3e-\x7e|
-    
-    aspecial     = %Q|()<>[]:;@\\,."| # RFC5322
-    tspecial     = %Q|()<>@,;:\\"/[]?=| # RFC2045
-    sp           = %Q| |
-    control      = %Q|\x00-\x1f\x7f-\xff|
-    
-    if control.respond_to?(:force_encoding)
-      control = control.force_encoding(Encoding::BINARY)
-    end
-    
-    CRLF          = /\r\n/
-    WSP           = /[#{white_space}]/
-    FWS           = /#{CRLF}#{WSP}*/
-    TEXT          = /[#{text}]/ # + obs-text
-    FIELD_NAME    = /[#{field_name}]+/
-    FIELD_PREFIX  = /\A(#{FIELD_NAME})/
-    FIELD_BODY    = /.+/m
-    FIELD_LINE    = /^[#{field_name}]+:\s*.+$/
-    FIELD_SPLIT   = /^(#{FIELD_NAME})\s*:\s*(#{FIELD_BODY})?$/
-    HEADER_LINE   = /^([#{field_name}]+:\s*.+)$/
-    HEADER_SPLIT  = /#{CRLF}(?!#{WSP})/
-
-    QP_UNSAFE     = /[^#{qp_safe}]/
-    QP_SAFE       = /[#{qp_safe}]/
-    CONTROL_CHAR  = /[#{control}]/n
-    ATOM_UNSAFE   = /[#{Regexp.quote aspecial}#{control}#{sp}]/n
-    PHRASE_UNSAFE = /[#{Regexp.quote aspecial}#{control}]/n
-    TOKEN_UNSAFE  = /[#{Regexp.quote tspecial}#{control}#{sp}]/n
-  end
-end

data/lib/mail/version_specific/ruby_1_8.rb

@@ -1,119 +0,0 @@
-# encoding: utf-8
-
-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.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), fix_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 = Iconv.conv('UTF-8//IGNORE', fix_encoding(encoding), str)
-      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 = Iconv.conv('UTF-8//IGNORE', fix_encoding(encoding), str)
-      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.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

data/lib/mail/version_specific/ruby_1_9.rb

@@ -1,159 +0,0 @@
-# encoding: utf-8
-
-module Mail
-  class Ruby19
-
-    # 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)
-      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.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.force_encoding(pick_encoding(charset))
-      end
-      decoded = str.encode("utf-8", :invalid => :replace, :replace => "")
-      decoded.valid_encoding? ? decoded : decoded.encode("utf-16le", :invalid => :replace, :replace => "").encode("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.force_encoding(pick_encoding(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('utf-8') if str.encoding == Encoding::ASCII_8BIT
-      end
-      decoded = str.encode("utf-8", :invalid => :replace, :replace => "")
-      decoded.valid_encoding? ? decoded : decoded.encode("utf-16le", :invalid => :replace, :replace => "").encode("utf-8")
-    rescue Encoding::UndefinedConversionError
-      str.dup.force_encoding("utf-8")
-    end
-
-    def Ruby19.param_decode(str, encoding)
-      string = uri_parser.unescape(str)
-      string.force_encoding(encoding) if encoding
-      string
-    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)
-      case charset
-
-      # ISO-8859-8-I etc. http://en.wikipedia.org/wiki/ISO-8859-8-I
-      when /^iso-?8859-(\d+)(-i)?$/i
-        "ISO-8859-#{$1}"
-
-      # ISO-8859-15, ISO-2022-JP and alike
-      when /iso-?(\d{4})-?(\w{1,2})/i
-        "ISO-#{$1}-#{$2}"
-
-      # "ISO-2022-JP-KDDI"  and alike
-      when /iso-?(\d{4})-?(\w{1,2})-?(\w*)/i
-        "ISO-#{$1}-#{$2}-#{$3}"
-
-      # UTF-8, UTF-32BE and alike
-      when /utf[\-_]?(\d{1,2})?(\w{1,2})/i
-        "UTF-#{$1}#{$2}".gsub(/\A(UTF-(?:16|32))\z/, '\\1BE')
-
-      # Windows-1252 and alike
-      when /Windows-?(.*)/i
-        "Windows-#{$1}"
-
-      when /^8bit$/
-        Encoding::ASCII_8BIT
-
-      # alternatives/misspellings of us-ascii seen in the wild
-      when /^iso-?646(-us)?$/i, /us=ascii/i
-        Encoding::ASCII
-
-      # Microsoft-specific alias for MACROMAN
-      when /^macintosh$/i
-        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/i
-        Encoding::GB18030
-
-      else
-        charset
-      end
-    end
-  end
-end