nano-fast-tool 0.0.1

data/mail-2.9.1/lib/mail/fields/unstructured_field.rb

@@ -0,0 +1,189 @@
+# encoding: utf-8
+# frozen_string_literal: true
+require 'mail/utilities'
+
+module Mail
+  # Provides access to an unstructured header field
+  #
+  # ===Per RFC 2822:
+  #  2.2.1. Unstructured Header Field Bodies
+  #
+  #     Some field bodies in this standard are defined simply as
+  #     "unstructured" (which is specified below as any US-ASCII characters,
+  #     except for CR and LF) with no further restrictions.  These are
+  #     referred to as unstructured field bodies.  Semantically, unstructured
+  #     field bodies are simply to be treated as a single line of characters
+  #     with no further processing (except for header "folding" and
+  #     "unfolding" as described in section 2.2.3).
+  class UnstructuredField < CommonField #:nodoc:
+    def initialize(name, value, charset = nil)
+      if value.is_a?(Array)
+        # Probably has arrived here from a failed parse of an AddressList Field
+        value = value.join(', ')
+
+      # Mark UTF-8 strings parsed from ASCII-8BIT
+      elsif value.respond_to?(:force_encoding) && value.encoding == Encoding::ASCII_8BIT
+        utf8 = value.dup.force_encoding(Encoding::UTF_8)
+        value = utf8 if utf8.valid_encoding?
+      end
+
+      charset ||=
+        if value.respond_to?(:encoding)
+          value.encoding
+        end
+
+      super name, value.to_s, charset
+    end
+
+    # An unstructured field does not parse
+    def parse
+      self
+    end
+
+    private
+
+    def do_encode
+      if value && !value.empty?
+        "#{wrapped_value}\r\n"
+      else
+        ''
+      end
+    end
+
+    def do_decode
+      Utilities.blank?(value) ? nil : Encodings.decode_encode(value, :decode)
+    end
+
+    # 2.2.3. Long Header Fields
+    #
+    #  Each header field is logically a single line of characters comprising
+    #  the field name, the colon, and the field body.  For convenience
+    #  however, and to deal with the 998/78 character limitations per line,
+    #  the field body portion of a header field can be split into a multiple
+    #  line representation; this is called "folding".  The general rule is
+    #  that wherever this standard allows for folding white space (not
+    #  simply WSP characters), a CRLF may be inserted before any WSP.  For
+    #  example, the header field:
+    #
+    #          Subject: This is a test
+    #
+    #  can be represented as:
+    #
+    #          Subject: This
+    #           is a test
+    #
+    #  Note: Though structured field bodies are defined in such a way that
+    #  folding can take place between many of the lexical tokens (and even
+    #  within some of the lexical tokens), folding SHOULD be limited to
+    #  placing the CRLF at higher-level syntactic breaks.  For instance, if
+    #  a field body is defined as comma-separated values, it is recommended
+    #  that folding occur after the comma separating the structured items in
+    #  preference to other places where the field could be folded, even if
+    #  it is allowed elsewhere.
+    def wrapped_value # :nodoc:
+      wrap_lines(name, fold("#{name}: ".length))
+    end
+
+    # 6.2. Display of 'encoded-word's
+    #
+    #  When displaying a particular header field that contains multiple
+    #  'encoded-word's, any 'linear-white-space' that separates a pair of
+    #  adjacent 'encoded-word's is ignored.  (This is to allow the use of
+    #  multiple 'encoded-word's to represent long strings of unencoded text,
+    #  without having to separate 'encoded-word's where spaces occur in the
+    #  unencoded text.)
+    def wrap_lines(name, folded_lines)
+      result = ["#{name}: #{folded_lines.shift}"]
+      result.concat(folded_lines)
+      result.join("\r\n\s")
+    end
+
+    def fold(prepend = 0) # :nodoc:
+      encoding       = normalized_encoding
+      decoded_string = decoded.to_s
+      should_encode  = !decoded_string.ascii_only?
+      if should_encode
+        first = true
+        words = decoded_string.split(/[ \t]/).map do |word|
+          if first
+            first = !first
+          else
+            word = " #{word}"
+          end
+          if !word.ascii_only?
+            word
+          else
+            word.scan(/.{7}|.+$/)
+          end
+        end.flatten
+      else
+        words = decoded_string.split(/[ \t]/)
+      end
+
+      folded_lines   = []
+      while !words.empty?
+        limit = 78 - prepend
+        limit = limit - 7 - encoding.length if should_encode
+        line = String.new
+        first_word = true
+        while !words.empty?
+          break unless word = words.first.dup
+
+          # Convert on 1.9+ only since we aren't sure of the current
+          # charset encoding on 1.8. We'd need to track internal/external
+          # charset on each field.
+          if charset && word.respond_to?(:encoding)
+            word = Encodings.transcode_charset(word, word.encoding, charset)
+          end
+
+          word = encode(word) if should_encode
+          word = encode_crlf(word)
+          # Skip to next line if we're going to go past the limit
+          # Unless this is the first word, in which case we're going to add it anyway
+          # Note: This means that a word that's longer than 998 characters is going to break the spec. Please fix if this is a problem for you.
+          # (The fix, it seems, would be to use encoded-word encoding on it, because that way you can break it across multiple lines and
+          # the linebreak will be ignored)
+          break if !line.empty? && (line.length + word.length + 1 > limit)
+          # Remove the word from the queue ...
+          words.shift
+          # Add word separator
+          if first_word
+            first_word = false
+          else
+            line << " " if !should_encode
+          end
+
+          # ... add it in encoded form to the current line
+          line << word
+        end
+        # Encode the line if necessary
+        line = "=?#{encoding}?Q?#{line}?=" if should_encode
+        # Add the line to the output and reset the prepend
+        folded_lines << line
+        prepend = 0
+      end
+      folded_lines
+    end
+
+    def encode(value)
+      value = [value].pack(Constants::CAPITAL_M).gsub(Constants::EQUAL_LF, Constants::EMPTY)
+      value.gsub!(/"/,  '=22')
+      value.gsub!(/\(/, '=28')
+      value.gsub!(/\)/, '=29')
+      value.gsub!(/\?/, '=3F')
+      value.gsub!(/_/,  '=5F')
+      value.gsub!(/ /,  '_')
+      value
+    end
+
+    def encode_crlf(value)
+      value.gsub!(Constants::CR, Constants::CR_ENCODED)
+      value.gsub!(Constants::LF, Constants::LF_ENCODED)
+      value
+    end
+
+    def normalized_encoding
+      charset.to_s.upcase.gsub('_', '-')
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+module Mail
+  register_autoload :CommonField, 'mail/fields/common_field'
+  register_autoload :CommonAddressField, 'mail/fields/common_address_field'
+  register_autoload :CommonMessageIdField, 'mail/fields/common_message_id_field'
+  register_autoload :CommonDateField, 'mail/fields/common_date_field'
+
+  register_autoload :UnstructuredField, 'mail/fields/unstructured_field'
+  register_autoload :NamedUnstructuredField, 'mail/fields/named_unstructured_field'
+  register_autoload :StructuredField, 'mail/fields/structured_field'
+  register_autoload :OptionalField, 'mail/fields/optional_field'
+
+  register_autoload :BccField, 'mail/fields/bcc_field'
+  register_autoload :CcField, 'mail/fields/cc_field'
+  register_autoload :CommentsField, 'mail/fields/comments_field'
+  register_autoload :ContentDescriptionField, 'mail/fields/content_description_field'
+  register_autoload :ContentDispositionField, 'mail/fields/content_disposition_field'
+  register_autoload :ContentIdField, 'mail/fields/content_id_field'
+  register_autoload :ContentLocationField, 'mail/fields/content_location_field'
+  register_autoload :ContentTransferEncodingField, 'mail/fields/content_transfer_encoding_field'
+  register_autoload :ContentTypeField, 'mail/fields/content_type_field'
+  register_autoload :DateField, 'mail/fields/date_field'
+  register_autoload :FromField, 'mail/fields/from_field'
+  register_autoload :InReplyToField, 'mail/fields/in_reply_to_field'
+  register_autoload :KeywordsField, 'mail/fields/keywords_field'
+  register_autoload :MessageIdField, 'mail/fields/message_id_field'
+  register_autoload :MimeVersionField, 'mail/fields/mime_version_field'
+  register_autoload :NamedStructuredField, 'mail/fields/named_structured_field'
+  register_autoload :ReceivedField, 'mail/fields/received_field'
+  register_autoload :ReferencesField, 'mail/fields/references_field'
+  register_autoload :ReplyToField, 'mail/fields/reply_to_field'
+  register_autoload :ResentBccField, 'mail/fields/resent_bcc_field'
+  register_autoload :ResentCcField, 'mail/fields/resent_cc_field'
+  register_autoload :ResentDateField, 'mail/fields/resent_date_field'
+  register_autoload :ResentFromField, 'mail/fields/resent_from_field'
+  register_autoload :ResentMessageIdField, 'mail/fields/resent_message_id_field'
+  register_autoload :ResentSenderField, 'mail/fields/resent_sender_field'
+  register_autoload :ResentToField, 'mail/fields/resent_to_field'
+  register_autoload :ReturnPathField, 'mail/fields/return_path_field'
+  register_autoload :SenderField, 'mail/fields/sender_field'
+  register_autoload :SubjectField, 'mail/fields/subject_field'
+  register_autoload :ToField, 'mail/fields/to_field'
+
+  register_autoload :ParameterHash, 'mail/fields/parameter_hash'
+end

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

@@ -0,0 +1,237 @@
+# encoding: utf-8
+# frozen_string_literal: true
+require 'mail/constants'
+require 'mail/utilities'
+
+module Mail
+  # Provides access to a header object.
+  #
+  # ===Per RFC2822
+  #
+  #  2.2. Header Fields
+  #
+  #   Header fields are lines composed of a field name, followed by a colon
+  #   (":"), followed by a field body, and terminated by CRLF.  A field
+  #   name MUST be composed of printable US-ASCII characters (i.e.,
+  #   characters that have values between 33 and 126, inclusive), except
+  #   colon.  A field body may be composed of any US-ASCII characters,
+  #   except for CR and LF.  However, a field body may contain CRLF when
+  #   used in header "folding" and  "unfolding" as described in section
+  #   2.2.3.  All field bodies MUST conform to the syntax described in
+  #   sections 3 and 4 of this standard.
+  class Header
+    include Enumerable
+
+    @@maximum_amount = 1000
+
+    # Large amount of headers in Email might create extra high CPU load
+    # Use this parameter to limit number of headers that will be parsed by
+    # mail library.
+    # Default: 1000
+    def self.maximum_amount
+      @@maximum_amount
+    end
+
+    def self.maximum_amount=(value)
+      @@maximum_amount = value
+    end
+
+    attr_reader :raw_source, :charset
+
+    # Creates a new header object.
+    #
+    # Accepts raw text or nothing.  If given raw text will attempt to parse
+    # it and split it into the various fields, instantiating each field as
+    # it goes.
+    #
+    # If it finds a field that should be a structured field (such as content
+    # type), but it fails to parse it, it will simply make it an unstructured
+    # field and leave it alone.  This will mean that the data is preserved but
+    # no automatic processing of that field will happen.  If you find one of
+    # these cases, please make a patch and send it in, or at the least, send
+    # me the example so we can fix it.
+    def initialize(header_text = nil, charset = nil)
+      @charset = charset
+      @raw_source = ::Mail::Utilities.to_crlf(header_text).lstrip
+      split_header if header_text
+    end
+
+    def initialize_copy(original)
+      super
+      @fields = @fields.dup
+      @fields.map!(&:dup)
+    end
+
+    # Returns an array of all the fields in the header in order that they
+    # were read in.
+    def fields
+      @fields ||= FieldList.new
+    end
+
+    #  3.6. Field definitions
+    #
+    #   It is important to note that the header fields are not guaranteed to
+    #   be in a particular order.  They may appear in any order, and they
+    #   have been known to be reordered occasionally when transported over
+    #   the Internet.  However, for the purposes of this standard, header
+    #   fields SHOULD NOT be reordered when a message is transported or
+    #   transformed.  More importantly, the trace header fields and resent
+    #   header fields MUST NOT be reordered, and SHOULD be kept in blocks
+    #   prepended to the message.  See sections 3.6.6 and 3.6.7 for more
+    #   information.
+    #
+    # Populates the fields container with Field objects in the order it
+    # receives them in.
+    #
+    # Acceps an array of field string values, for example:
+    #
+    #  h = Header.new
+    #  h.fields = ['From: mikel@me.com', 'To: bob@you.com']
+    def fields=(unfolded_fields)
+      @fields = Mail::FieldList.new
+
+      if unfolded_fields.size > self.class.maximum_amount
+        Kernel.warn "WARNING: More than #{self.class.maximum_amount} header fields; only using the first #{self.class.maximum_amount} and ignoring the rest"
+        unfolded_fields = unfolded_fields.slice(0...self.class.maximum_amount)
+      end
+
+      unfolded_fields.each do |field|
+        if field = Field.parse(field, charset)
+          @fields.add_field field
+        end
+      end
+    end
+
+    def errors
+      @fields.map(&:errors).flatten(1)
+    end
+
+    #  3.6. Field definitions
+    #
+    #   The following table indicates limits on the number of times each
+    #   field may occur in a message header as well as any special
+    #   limitations on the use of those fields.  An asterisk next to a value
+    #   in the minimum or maximum column indicates that a special restriction
+    #   appears in the Notes column.
+    #
+    #   <snip table from 3.6>
+    #
+    # As per RFC, many fields can appear more than once, we will return a string
+    # of the value if there is only one header, or if there is more than one
+    # matching header, will return an array of values in order that they appear
+    # in the header ordered from top to bottom.
+    #
+    # Example:
+    #
+    #  h = Header.new
+    #  h.fields = ['To: mikel@me.com', 'X-Mail-SPAM: 15', 'X-Mail-SPAM: 20']
+    #  h['To']          #=> 'mikel@me.com'
+    #  h['X-Mail-SPAM'] #=> ['15', '20']
+    def [](name)
+      fields.get_field(Utilities.dasherize(name))
+    end
+
+    # Sets the FIRST matching field in the header to passed value, or deletes
+    # the FIRST field matched from the header if passed nil
+    #
+    # Example:
+    #
+    #  h = Header.new
+    #  h.fields = ['To: mikel@me.com', 'X-Mail-SPAM: 15', 'X-Mail-SPAM: 20']
+    #  h['To'] = 'bob@you.com'
+    #  h['To']    #=> 'bob@you.com'
+    #  h['X-Mail-SPAM'] = '10000'
+    #  h['X-Mail-SPAM'] # => ['15', '20', '10000']
+    #  h['X-Mail-SPAM'] = nil
+    #  h['X-Mail-SPAM'] # => nil
+    def []=(name, value)
+      name = name.to_s
+      if name.include?(Constants::COLON)
+        raise ArgumentError, "Header names may not contain a colon: #{name.inspect}"
+      end
+
+      name = Utilities.dasherize(name)
+
+      # Assign nil to delete the field
+      if value.nil?
+        fields.delete_field name
+      else
+        fields.add_field Field.new(name.to_s, value, charset)
+
+        # Update charset if specified in Content-Type
+        if name == 'content-type'
+          params = self[:content_type].parameters rescue nil
+          @charset = params[:charset] if params && params[:charset]
+        end
+      end
+    end
+
+    def charset=(val)
+      params = self[:content_type].parameters rescue nil
+      if params
+        if val
+          params[:charset] = val
+        else
+          params.delete(:charset)
+        end
+      end
+      @charset = val
+    end
+
+
+    def encoded
+      buffer = String.new
+      buffer.force_encoding('us-ascii') if buffer.respond_to?(:force_encoding)
+      fields.each do |field|
+        buffer << field.encoded
+      end
+      buffer
+    end
+
+    def to_s
+      encoded
+    end
+
+    def decoded
+      raise NoMethodError, 'Can not decode an entire header as there could be character set conflicts. Try calling #decoded on the various fields.'
+    end
+
+    def field_summary
+      fields.summary
+    end
+
+    # Returns true if the header has a Message-ID defined (empty or not)
+    def has_message_id?
+      fields.has_field? 'Message-ID'
+    end
+
+    # Returns true if the header has a Content-ID defined (empty or not)
+    def has_content_id?
+      fields.has_field? 'Content-ID'
+    end
+
+    # Returns true if the header has a Date defined (empty or not)
+    def has_date?
+      fields.has_field? 'Date'
+    end
+
+    # Returns true if the header has a MIME version defined (empty or not)
+    def has_mime_version?
+      fields.has_field? 'MIME-Version'
+    end
+
+    private
+
+    # Splits an unfolded and line break cleaned header into individual field
+    # strings.
+    def split_header
+      self.fields = @raw_source.split(Constants::HEADER_SPLIT)
+    end
+
+
+    # Enumerable support. Yield each field in order.
+    def each(&block)
+      fields.each(&block)
+    end
+  end
+end

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

@@ -0,0 +1,147 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+# This is an almost cut and paste from ActiveSupport v3.0.6, copied in here so that Mail
+# itself does not depend on ActiveSupport to avoid versioning conflicts
+
+module Mail
+  class IndifferentHash < Hash
+
+    def initialize(constructor = {})
+      if constructor.is_a?(Hash)
+        super()
+        update(constructor)
+      else
+        super(constructor)
+      end
+    end
+
+    def default(key = nil)
+      if key.is_a?(Symbol) && include?(key = key.to_s)
+        self[key]
+      else
+        super
+      end
+    end
+
+    def self.new_from_hash_copying_default(hash)
+      IndifferentHash.new(hash).tap do |new_hash|
+        new_hash.default = hash.default
+      end
+    end
+
+    alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
+    alias_method :regular_update, :update unless method_defined?(:regular_update)
+
+    # Assigns a new value to the hash:
+    #
+    #   hash = HashWithIndifferentAccess.new
+    #   hash[:key] = "value"
+    #
+    def []=(key, value)
+      regular_writer(convert_key(key), convert_value(value))
+    end
+
+    alias_method :store, :[]=
+
+    # Updates the instantized hash with values from the second:
+    #
+    #   hash_1 = HashWithIndifferentAccess.new
+    #   hash_1[:key] = "value"
+    #
+    #   hash_2 = HashWithIndifferentAccess.new
+    #   hash_2[:key] = "New Value!"
+    #
+    #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
+    #
+    def update(other_hash)
+      other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
+      self
+    end
+
+    alias_method :merge!, :update
+
+    # Checks the hash for a key matching the argument passed in:
+    #
+    #   hash = HashWithIndifferentAccess.new
+    #   hash["key"] = "value"
+    #   hash.key? :key  # => true
+    #   hash.key? "key" # => true
+    #
+    def key?(key)
+      super(convert_key(key))
+    end
+
+    alias_method :include?, :key?
+    alias_method :has_key?, :key?
+    alias_method :member?, :key?
+
+    # Fetches the value for the specified key, same as doing hash[key]
+    def fetch(key, *extras)
+      super(convert_key(key), *extras)
+    end
+
+    # Returns an array of the values at the specified indices:
+    #
+    #   hash = HashWithIndifferentAccess.new
+    #   hash[:a] = "x"
+    #   hash[:b] = "y"
+    #   hash.values_at("a", "b") # => ["x", "y"]
+    #
+    def values_at(*indices)
+      indices.collect {|key| self[convert_key(key)]}
+    end
+
+    # Returns an exact copy of the hash.
+    def dup
+      IndifferentHash.new(self)
+    end
+
+    # Merges the instantized and the specified hashes together, giving precedence to the values from the second hash
+    # Does not overwrite the existing hash.
+    def merge(hash)
+      self.dup.update(hash)
+    end
+
+    # Performs the opposite of merge, with the keys and values from the first hash taking precedence over the second.
+    # This overloaded definition prevents returning a regular hash, if reverse_merge is called on a HashWithDifferentAccess.
+    def reverse_merge(other_hash)
+      super self.class.new_from_hash_copying_default(other_hash)
+    end
+
+    def reverse_merge!(other_hash)
+      replace(reverse_merge( other_hash ))
+    end
+
+    # Removes a specified key from the hash.
+    def delete(key)
+      super(convert_key(key))
+    end
+
+    def stringify_keys!; self end
+    def stringify_keys; dup end
+    def symbolize_keys; to_hash.symbolize_keys end
+    def to_options!; self end
+
+    def to_hash
+      Hash.new(default).merge!(self)
+    end
+
+  protected
+
+    def convert_key(key)
+      key.kind_of?(Symbol) ? key.to_s : key
+    end
+
+    def convert_value(value)
+      if value.class == Hash
+        self.class.new_from_hash_copying_default(value)
+      elsif value.is_a?(Array)
+        value.dup.replace(value.map { |e| convert_value(e) })
+      else
+        value
+      end
+    end
+
+  end
+end