nano-fast-tool 0.0.1

data/mail-2.9.1/lib/mail/elements/address.rb

@@ -0,0 +1,258 @@
+# encoding: utf-8
+# frozen_string_literal: true
+require 'mail/parsers/address_lists_parser'
+require 'mail/constants'
+require 'mail/utilities'
+
+module Mail
+  # Mail::Address handles all email addresses in Mail.  It takes an email address string
+  # and parses it, breaking it down into its component parts and allowing you to get the
+  # address, comments, display name, name, local part, domain part and fully formatted
+  # address.
+  #
+  # Mail::Address requires a correctly formatted email address per RFC2822 or RFC822.  It
+  # handles all obsolete versions including obsolete domain routing on the local part.
+  #
+  #  a = Address.new('Mikel Lindsaar (My email address) <mikel@test.lindsaar.net>')
+  #  a.format       #=> 'Mikel Lindsaar <mikel@test.lindsaar.net> (My email address)'
+  #  a.address      #=> 'mikel@test.lindsaar.net'
+  #  a.display_name #=> 'Mikel Lindsaar'
+  #  a.local        #=> 'mikel'
+  #  a.domain       #=> 'test.lindsaar.net'
+  #  a.comments     #=> ['My email address']
+  #  a.to_s         #=> 'Mikel Lindsaar <mikel@test.lindsaar.net> (My email address)'
+  class Address
+    def initialize(value = nil)
+      if value.nil?
+        @parsed = false
+        @data = nil
+      else
+        parse(value)
+      end
+    end
+
+    # Returns the raw input of the passed in string, this is before it is passed
+    # by the parser.
+    def raw
+      @data.raw
+    end
+
+    # Returns a correctly formatted address for the email going out.  If given
+    # an incorrectly formatted address as input, Mail::Address will do its best
+    # to format it correctly.  This includes quoting display names as needed and
+    # putting the address in angle brackets etc.
+    #
+    #  a = Address.new('Mikel Lindsaar (My email address) <mikel@test.lindsaar.net>')
+    #  a.format #=> 'Mikel Lindsaar <mikel@test.lindsaar.net> (My email address)'
+    def format(output_type = :decode)
+      parse unless @parsed
+      if @data.nil?
+        Constants::EMPTY
+      elsif name = display_name(output_type)
+        [Utilities.quote_phrase(name), "<#{address(output_type)}>", format_comments].compact.join(Constants::SPACE)
+      elsif a = address(output_type)
+        [a, format_comments].compact.join(Constants::SPACE)
+      else
+        raw
+      end
+    end
+
+    # Returns the address that is in the address itself.  That is, the
+    # local@domain string, without any angle brackets or the like.
+    #
+    #  a = Address.new('Mikel Lindsaar (My email address) <mikel@test.lindsaar.net>')
+    #  a.address #=> 'mikel@test.lindsaar.net'
+    def address(output_type = :decode)
+      parse unless @parsed
+      if d = domain(output_type)
+        "#{local(output_type)}@#{d}"
+      else
+        local(output_type)
+      end
+    end
+
+    # Provides a way to assign an address to an already made Mail::Address object.
+    #
+    #  a = Address.new
+    #  a.address = 'Mikel Lindsaar (My email address) <mikel@test.lindsaar.net>'
+    #  a.address #=> 'mikel@test.lindsaar.net'
+    def address=(value)
+      parse(value)
+    end
+
+    # Returns the display name of the email address passed in.
+    #
+    #  a = Address.new('Mikel Lindsaar (My email address) <mikel@test.lindsaar.net>')
+    #  a.display_name #=> 'Mikel Lindsaar'
+    def display_name(output_type = :decode)
+      parse unless @parsed
+      @display_name ||= get_display_name
+      Encodings.decode_encode(@display_name.to_s, output_type) if @display_name
+    end
+
+    # Provides a way to assign a display name to an already made Mail::Address object.
+    #
+    #  a = Address.new
+    #  a.address = 'mikel@test.lindsaar.net'
+    #  a.display_name = 'Mikel Lindsaar'
+    #  a.format #=> 'Mikel Lindsaar <mikel@test.lindsaar.net>'
+    def display_name=( str )
+      @display_name = str.nil? ? nil : str.dup # in case frozen
+    end
+
+    # Returns the local part (the left hand side of the @ sign in the email address) of
+    # the address
+    #
+    #  a = Address.new('Mikel Lindsaar (My email address) <mikel@test.lindsaar.net>')
+    #  a.local #=> 'mikel'
+    def local(output_type = :decode)
+      parse unless @parsed
+      Encodings.decode_encode("#{@data.obs_domain_list}#{get_local.strip}", output_type) if get_local
+    end
+
+    # Returns the domain part (the right hand side of the @ sign in the email address) of
+    # the address
+    #
+    #  a = Address.new('Mikel Lindsaar (My email address) <mikel@test.lindsaar.net>')
+    #  a.domain #=> 'test.lindsaar.net'
+    def domain(output_type = :decode)
+      parse unless @parsed
+      Encodings.decode_encode(strip_all_comments(get_domain), output_type) if get_domain
+    end
+
+    # Returns an array of comments that are in the email, or nil if there
+    # are no comments
+    #
+    #  a = Address.new('Mikel Lindsaar (My email address) <mikel@test.lindsaar.net>')
+    #  a.comments #=> ['My email address']
+    #
+    #  b = Address.new('Mikel Lindsaar <mikel@test.lindsaar.net>')
+    #  b.comments #=> nil
+
+    def comments
+      parse unless @parsed
+      comments = get_comments
+      if comments.nil? || comments.none?
+        nil
+      else
+        comments.map { |c| c.squeeze(Constants::SPACE) }
+      end
+    end
+
+    # Sometimes an address will not have a display name, but might have the name
+    # as a comment field after the address.  This returns that name if it exists.
+    #
+    #  a = Address.new('mikel@test.lindsaar.net (Mikel Lindsaar)')
+    #  a.name #=> 'Mikel Lindsaar'
+    def name
+      parse unless @parsed
+      get_name
+    end
+
+    # Returns the format of the address, or returns nothing
+    #
+    #  a = Address.new('Mikel Lindsaar (My email address) <mikel@test.lindsaar.net>')
+    #  a.format #=> 'Mikel Lindsaar <mikel@test.lindsaar.net> (My email address)'
+    def to_s
+      parse unless @parsed
+      format
+    end
+
+    # Shows the Address object basic details, including the Address
+    #  a = Address.new('Mikel (My email) <mikel@test.lindsaar.net>')
+    #  a.inspect #=> "#<Mail::Address:14184910 Address: |Mikel <mikel@test.lindsaar.net> (My email)| >"
+    def inspect
+      parse unless @parsed
+      "#<#{self.class}:#{self.object_id} Address: |#{to_s}| >"
+    end
+
+    def encoded
+      format :encode
+    end
+
+    def decoded
+      format :decode
+    end
+
+    def group
+      @data && @data.group
+    end
+
+    private
+
+    def parse(value = nil)
+      @parsed = true
+      @data = nil
+
+      case value
+      when Mail::Parsers::AddressListsParser::AddressStruct
+        @data = value
+      when String
+        unless Utilities.blank?(value)
+          address_list = Mail::Parsers::AddressListsParser.parse(value)
+          @data = address_list.addresses.first
+        end
+      end
+    end
+
+    def strip_all_comments(string)
+      unless Utilities.blank?(comments)
+        comments.each do |comment|
+          string = string.gsub("(#{comment})", Constants::EMPTY)
+        end
+      end
+      string.strip
+    end
+
+    def strip_domain_comments(value)
+      unless Utilities.blank?(comments)
+        comments.each do |comment|
+          if @data.domain && @data.domain.include?("(#{comment})")
+            value = value.gsub("(#{comment})", Constants::EMPTY)
+          end
+        end
+      end
+      value.to_s.strip
+    end
+
+    def get_display_name
+      if @data && @data.display_name
+        str = strip_all_comments(@data.display_name.to_s)
+      elsif @data && @data.comments && @data.domain
+        str = strip_domain_comments(format_comments)
+      end
+      str unless Utilities.blank?(str)
+    end
+
+    def get_name
+      if display_name
+        str = display_name
+      elsif comments
+        str = "(#{comments.join(Constants::SPACE).squeeze(Constants::SPACE)})"
+      end
+
+      Utilities.unparen(str) unless Utilities.blank?(str)
+    end
+
+    def format_comments
+      if comments
+        comment_text = comments.map {|c| Utilities.escape_paren(c) }.join(Constants::SPACE).squeeze(Constants::SPACE)
+        @format_comments ||= "(#{comment_text})"
+      else
+        nil
+      end
+    end
+
+    def get_local
+      @data && @data.local
+    end
+
+    def get_domain
+      @data && @data.domain
+    end
+
+    def get_comments
+      @data && @data.comments
+    end
+  end
+end

data/mail-2.9.1/lib/mail/elements/address_list.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+# frozen_string_literal: true
+require 'mail/parsers/address_lists_parser'
+
+module Mail
+  class AddressList #:nodoc:
+    attr_reader :addresses, :group_names
+
+    # Mail::AddressList is the class that parses To, From and other address fields from
+    # emails passed into Mail.
+    #
+    # AddressList provides a way to query the groups and mailbox lists of the passed in
+    # string.
+    #
+    # It can supply all addresses in an array, or return each address as an address object.
+    #
+    # Mail::AddressList requires a correctly formatted group or mailbox list per RFC2822 or
+    # RFC822.  It also handles all obsolete versions in those RFCs.
+    #
+    #  list = 'ada@test.lindsaar.net, My Group: mikel@test.lindsaar.net, Bob <bob@test.lindsaar.net>;'
+    #  a = AddressList.new(list)
+    #  a.addresses    #=> [#<Mail::Address:14943130 Address: |ada@test.lindsaar.net...
+    #  a.group_names  #=> ["My Group"]
+    def initialize(string)
+      address_list = Parsers::AddressListsParser.parse(string)
+      @addresses = address_list.addresses.map { |a| Address.new(a) }
+      @group_names = address_list.group_names
+    end
+
+    def addresses_grouped_by_group
+      addresses.select(&:group).group_by(&:group)
+    end
+  end
+end

data/mail-2.9.1/lib/mail/elements/content_disposition_element.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+# frozen_string_literal: true
+require 'mail/parsers/content_disposition_parser'
+
+module Mail
+  class ContentDispositionElement #:nodoc:
+    attr_reader :disposition_type, :parameters
+
+    def initialize(string)
+      content_disposition = Mail::Parsers::ContentDispositionParser.parse(cleaned(string))
+      @disposition_type = content_disposition.disposition_type
+      @parameters = content_disposition.parameters
+    end
+
+    private
+    def cleaned(string)
+      string =~ /(.+);\s*$/ ? $1 : string
+    end
+  end
+end

data/mail-2.9.1/lib/mail/elements/content_location_element.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+# frozen_string_literal: true
+require 'mail/parsers/content_location_parser'
+
+module Mail
+  class ContentLocationElement #:nodoc:
+    attr_reader :location
+
+    def initialize(string)
+      @location = Mail::Parsers::ContentLocationParser.parse(string).location
+    end
+
+    def to_s(*args)
+      location.to_s
+    end
+  end
+end

data/mail-2.9.1/lib/mail/elements/content_transfer_encoding_element.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+# frozen_string_literal: true
+require 'mail/parsers/content_transfer_encoding_parser'
+
+module Mail
+  class ContentTransferEncodingElement #:nodoc:
+    attr_reader :encoding
+
+    def initialize(string)
+      @encoding = Mail::Parsers::ContentTransferEncodingParser.parse(string).encoding
+    end
+  end
+end

data/mail-2.9.1/lib/mail/elements/content_type_element.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+# frozen_string_literal: true
+require 'mail/parsers/content_type_parser'
+
+module Mail
+  class ContentTypeElement #:nodoc:
+    attr_reader :main_type, :sub_type, :parameters
+
+    def initialize(string)
+      content_type = Mail::Parsers::ContentTypeParser.parse(cleaned(string))
+      @main_type = content_type.main_type
+      @sub_type = content_type.sub_type
+      @parameters = content_type.parameters
+    end
+
+    private
+      def cleaned(string)
+        if string =~ /;\s*$/
+          $`
+        else
+          string
+        end
+      end
+  end
+end

data/mail-2.9.1/lib/mail/elements/date_time_element.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+# frozen_string_literal: true
+require 'mail/parsers/date_time_parser'
+
+module Mail
+  class DateTimeElement #:nodoc:
+    attr_reader :date_string, :time_string
+
+    def initialize(string)
+      date_time = Mail::Parsers::DateTimeParser.parse(string)
+      @date_string = date_time.date_string
+      @time_string = date_time.time_string
+    end
+  end
+end

data/mail-2.9.1/lib/mail/elements/envelope_from_element.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+# frozen_string_literal: true
+require 'mail/parsers/envelope_from_parser'
+require 'date'
+
+module Mail
+  class EnvelopeFromElement #:nodoc:
+    attr_reader :date_time, :address
+
+    def initialize(string)
+      envelope_from = Mail::Parsers::EnvelopeFromParser.parse(string)
+      @address = envelope_from.address
+      @date_time = ::DateTime.parse(envelope_from.ctime_date) if envelope_from.ctime_date
+    end
+
+    # RFC 4155:
+    #   a timestamp indicating the UTC date and time when the message
+    #   was originally received, conformant with the syntax of the
+    #   traditional UNIX 'ctime' output sans timezone (note that the
+    #   use of UTC precludes the need for a timezone indicator);
+    def formatted_date_time
+      if date_time
+        if date_time.respond_to?(:ctime)
+          date_time.ctime
+        else
+          date_time.strftime '%a %b %e %T %Y'
+        end
+      end
+    end
+
+    def to_s
+      if date_time
+        "#{address} #{formatted_date_time}"
+      else
+        address
+      end
+    end
+  end
+end

data/mail-2.9.1/lib/mail/elements/message_ids_element.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+# frozen_string_literal: true
+require 'mail/parsers/message_ids_parser'
+require 'mail/utilities'
+
+module Mail
+  class MessageIdsElement #:nodoc:
+    def self.parse(string)
+      new(string).tap(&:message_ids)
+    end
+
+    attr_reader :message_ids
+
+    def initialize(string)
+      @message_ids = parse(string)
+    end
+
+    def message_id
+      message_ids.first
+    end
+
+    private
+      def parse(string)
+        if Utilities.blank? string
+          []
+        else
+          Mail::Parsers::MessageIdsParser.parse(string).message_ids
+        end
+      end
+  end
+end

data/mail-2.9.1/lib/mail/elements/mime_version_element.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+# frozen_string_literal: true
+require 'mail/parsers/mime_version_parser'
+
+module Mail
+  class MimeVersionElement #:nodoc:
+    attr_reader :major, :minor
+
+    def initialize(string)
+      mime_version = Mail::Parsers::MimeVersionParser.parse(string)
+      @major = mime_version.major
+      @minor = mime_version.minor
+    end
+  end
+end

data/mail-2.9.1/lib/mail/elements/phrase_list.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+# frozen_string_literal: true
+require 'mail/parsers/phrase_lists_parser'
+require 'mail/utilities'
+
+module Mail
+  class PhraseList #:nodoc:
+    attr_reader :phrases
+
+    def initialize(string)
+      @phrases =
+        if Utilities.blank? string
+          []
+        else
+          Mail::Parsers::PhraseListsParser.parse(string).phrases.map { |p| Mail::Utilities.unquote(p) }
+        end
+    end
+  end
+end

data/mail-2.9.1/lib/mail/elements/received_element.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+# frozen_string_literal: true
+require 'mail/parsers/received_parser'
+require 'mail/utilities'
+require 'date'
+
+module Mail
+  class ReceivedElement #:nodoc:
+    attr_reader :info, :date_time
+
+    def initialize(string)
+      if Utilities.blank? string
+        @date_time = nil
+        @info = nil
+      else
+        received = Mail::Parsers::ReceivedParser.parse(string)
+        @date_time = datetime_for(received)
+        @info = received.info
+      end
+    end
+
+    def to_s(*args)
+      "#{info}; #{date_time.to_s(*args)}"
+    end
+
+    private
+      def datetime_for(received)
+        ::DateTime.parse("#{received.date} #{received.time}")
+      rescue ArgumentError => e
+        raise e unless e.message == 'invalid date'
+        warn "WARNING: Invalid date field for received element (#{received.date} #{received.time}): #{e.class}: #{e.message}"
+        nil
+      end
+  end
+end

data/mail-2.9.1/lib/mail/elements.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+module Mail
+  register_autoload :Address, 'mail/elements/address'
+  register_autoload :AddressList, 'mail/elements/address_list'
+  register_autoload :ContentDispositionElement, 'mail/elements/content_disposition_element'
+  register_autoload :ContentLocationElement, 'mail/elements/content_location_element'
+  register_autoload :ContentTransferEncodingElement, 'mail/elements/content_transfer_encoding_element'
+  register_autoload :ContentTypeElement, 'mail/elements/content_type_element'
+  register_autoload :DateTimeElement, 'mail/elements/date_time_element'
+  register_autoload :EnvelopeFromElement, 'mail/elements/envelope_from_element'
+  register_autoload :MessageIdsElement, 'mail/elements/message_ids_element'
+  register_autoload :MimeVersionElement, 'mail/elements/mime_version_element'
+  register_autoload :PhraseList, 'mail/elements/phrase_list'
+  register_autoload :ReceivedElement, 'mail/elements/received_element'
+end

data/mail-2.9.1/lib/mail/encodings/7bit.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+# frozen_string_literal: true
+require 'mail/encodings/8bit'
+
+module Mail
+  module Encodings
+    # 7bit and 8bit are equivalent. 7bit encoding is for text only.
+    class SevenBit < EightBit
+      NAME = '7bit'
+      PRIORITY = 1
+      Encodings.register(NAME, self)
+
+      def self.decode(str)
+        ::Mail::Utilities.binary_unsafe_to_lf str
+      end
+
+      def self.encode(str)
+        ::Mail::Utilities.binary_unsafe_to_crlf str
+      end
+
+      # Per RFC 2045 2.7. 7bit Data, No octets with decimal values greater than 127 are allowed.
+      def self.compatible_input?(str)
+        str.ascii_only? && super
+      end
+    end
+  end
+end

data/mail-2.9.1/lib/mail/encodings/8bit.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+# frozen_string_literal: true
+require 'mail/encodings/binary'
+
+module Mail
+  module Encodings
+    class EightBit < Binary
+      NAME = '8bit'
+      PRIORITY = 4
+      Encodings.register(NAME, self)
+
+      # Per RFC 2821 4.5.3.1, SMTP lines may not be longer than 1000 octets including the <CRLF>.
+      def self.compatible_input?(str)
+        !str.lines.find { |line| line.bytesize > 998 }
+      end
+    end
+  end
+end

data/mail-2.9.1/lib/mail/encodings/base64.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+# frozen_string_literal: true
+require 'mail/encodings/7bit'
+
+module Mail
+  module Encodings
+    # Base64 encoding handles binary content at the cost of 4 output bytes
+    # per input byte.
+    class Base64 < SevenBit
+      NAME = 'base64'
+      PRIORITY = 3
+      Encodings.register(NAME, self)
+
+      def self.can_encode?(enc)
+        true
+      end
+
+      def self.decode(str)
+        Utilities.decode_base64(str)
+      end
+
+      def self.encode(str)
+        ::Mail::Utilities.binary_unsafe_to_crlf(Utilities.encode_base64(str))
+      end
+
+      # 3 bytes in -> 4 bytes out
+      def self.cost(str)
+        4.0 / 3
+      end
+
+      # Ruby Base64 inserts newlines automatically, so it doesn't exceed
+      # SMTP line length limits.
+      def self.compatible_input?(str)
+        true
+      end
+    end
+  end
+end

data/mail-2.9.1/lib/mail/encodings/binary.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+# frozen_string_literal: true
+require 'mail/encodings/identity'
+
+module Mail
+  module Encodings
+    class Binary < Identity
+      NAME = 'binary'
+      PRIORITY = 5
+      Encodings.register(NAME, self)
+    end
+  end
+end

data/mail-2.9.1/lib/mail/encodings/identity.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+# frozen_string_literal: true
+require 'mail/encodings/transfer_encoding'
+
+module Mail
+  module Encodings
+    # Identity encodings do no encoding/decoding and have a fixed cost:
+    # 1 byte in -> 1 byte out.
+    class Identity < TransferEncoding #:nodoc:
+      def self.decode(str)
+        str
+      end
+
+      def self.encode(str)
+        str
+      end
+
+      # 1 output byte per input byte.
+      def self.cost(str)
+        1.0
+      end
+    end
+  end
+end