tdiary 5.4.0 → 5.5.0.beta1

data/vendor/bundle/ruby/3.4.0/gems/mail-2.9.1/lib/mail/attachments_list.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+module Mail
+  class AttachmentsList < Array
+
+    def initialize(parts_list)
+      @parts_list = parts_list
+      @content_disposition_type = 'attachment'
+      parts_list.map { |p|
+        if p.mime_type == 'message/rfc822'
+          parts = []
+          parts << p if p.attachment?
+          parts.concat Mail.new(p.body.encoded).attachments
+        elsif p.parts.empty?
+          p if p.attachment?
+        else
+          p.attachments
+        end
+      }.flatten.compact.each { |a| self << a }
+      self
+    end
+
+    def inline
+      @content_disposition_type = 'inline'
+      self
+    end
+
+    # Returns the attachment by filename or at index.
+    #
+    # mail.attachments['test.png'] = File.read('test.png')
+    # mail.attachments['test.jpg'] = File.read('test.jpg')
+    #
+    # mail.attachments['test.png'].filename #=> 'test.png'
+    # mail.attachments[1].filename          #=> 'test.jpg'
+    def [](index_value)
+      if index_value.is_a?(Integer)
+        self.fetch(index_value)
+      else
+        self.select { |a| a.filename == index_value }.first
+      end
+    end
+
+    def []=(name, value)
+      encoded_name = Mail::Encodings.decode_encode name, :encode
+      default_values = { :content_type => "#{set_mime_type(name)}; filename=\"#{encoded_name}\"",
+                         :content_transfer_encoding => "#{guess_encoding}",
+                         :content_disposition => "#{@content_disposition_type}; filename=\"#{encoded_name}\"" }
+
+      if value.is_a?(Hash)
+        if path = value.delete(:filename)
+          value[:content] ||= File.open(path, 'rb') { |f| f.read }
+        end
+
+        default_values[:body] = value.delete(:content) if value[:content]
+
+        default_values[:body] = value.delete(:data) if value[:data]
+
+        encoding = value.delete(:transfer_encoding) || value.delete(:encoding)
+        if encoding
+          if Mail::Encodings.defined? encoding
+            default_values[:content_transfer_encoding] = encoding
+          else
+            raise "Do not know how to handle Content Transfer Encoding #{encoding}, please choose either quoted-printable or base64"
+          end
+        end
+
+        if value[:mime_type]
+          default_values[:content_type] = value.delete(:mime_type)
+          @mime_type = MiniMime.lookup_by_content_type(default_values[:content_type])
+          default_values[:content_transfer_encoding] ||= guess_encoding
+        end
+
+        hash = default_values.merge(value)
+      else
+        default_values[:body] = value
+        hash = default_values
+      end
+
+      if hash[:body].respond_to? :force_encoding and hash[:body].respond_to? :valid_encoding?
+        if not hash[:body].valid_encoding? and default_values[:content_transfer_encoding].casecmp('binary').zero?
+          hash[:body] = hash[:body].dup if hash[:body].frozen?
+          hash[:body].force_encoding("BINARY")
+        end
+      end
+
+      attachment = Part.new(hash)
+      attachment.add_content_id(hash[:content_id])
+
+      @parts_list << attachment
+    end
+
+    # Uses the mime type to try and guess the encoding, if it is a binary type, or unknown, then we
+    # set it to binary, otherwise as set to plain text
+    def guess_encoding
+      if @mime_type && !@mime_type.binary?
+        "7bit"
+      else
+        "binary"
+      end
+    end
+
+    def set_mime_type(filename)
+      filename = filename.encode(Encoding::UTF_8) if filename.respond_to?(:encode)
+
+      @mime_type = MiniMime.lookup_by_filename(filename)
+      @mime_type && @mime_type.content_type
+    end
+
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/mail-2.9.1/lib/mail/body.rb

@@ -0,0 +1,305 @@
+# encoding: utf-8
+# frozen_string_literal: true
+module Mail
+
+  # = Body
+  #
+  # The body is where the text of the email is stored.  Mail treats the body
+  # as a single object.  The body itself has no information about boundaries
+  # used in the MIME standard, it just looks at its content as either a single
+  # block of text, or (if it is a multipart message) as an array of blocks of text.
+  #
+  # A body has to be told to split itself up into a multipart message by calling
+  # #split with the correct boundary.  This is because the body object has no way
+  # of knowing what the correct boundary is for itself (there could be many
+  # boundaries in a body in the case of a nested MIME text).
+  #
+  # Once split is called, Mail::Body will slice itself up on this boundary,
+  # assigning anything that appears before the first part to the preamble, and
+  # anything that appears after the closing boundary to the epilogue, then
+  # each part gets initialized into a Mail::Part object.
+  #
+  # The boundary that is used to split up the Body is also stored in the Body
+  # object for use on encoding itself back out to a string.  You can
+  # overwrite this if it needs to be changed.
+  #
+  # On encoding, the body will return the preamble, then each part joined by
+  # the boundary, followed by a closing boundary string and then the epilogue.
+  class Body
+
+    def initialize(string = '')
+      @boundary = nil
+      @preamble = nil
+      @epilogue = nil
+      @charset  = nil
+      @part_sort_order = [ "text/plain", "text/enriched", "text/html", "multipart/alternative" ]
+      @parts = Mail::PartsList.new
+      if Utilities.blank?(string)
+        @raw_source = ''
+      else
+        # Do join first incase we have been given an Array in Ruby 1.9
+        if string.respond_to?(:join)
+          @raw_source = string.join('')
+        elsif string.respond_to?(:to_s)
+          @raw_source = string.to_s
+        else
+          raise "You can only assign a string or an object that responds_to? :join or :to_s to a body."
+        end
+      end
+      @encoding = default_encoding
+      set_charset
+    end
+
+    def init_with(coder)
+      coder.map.each { |k, v| instance_variable_set(:"@#{k}", v) }
+      @parts = Mail::PartsList.new(coder['parts'])
+    end
+
+    # Matches this body with another body.  Also matches the decoded value of this
+    # body with a string.
+    #
+    # Examples:
+    #
+    #   body = Mail::Body.new('The body')
+    #   body == body #=> true
+    #
+    #   body = Mail::Body.new('The body')
+    #   body == 'The body' #=> true
+    #
+    #   body = Mail::Body.new("VGhlIGJvZHk=\n")
+    #   body.encoding = 'base64'
+    #   body == "The body" #=> true
+    def ==(other)
+      if other.class == String
+        self.decoded == other
+      else
+        super
+      end
+    end
+
+    # Accepts a string and performs a regular expression against the decoded text
+    #
+    # Examples:
+    #
+    #   body = Mail::Body.new('The body')
+    #   body =~ /The/ #=> 0
+    #
+    #   body = Mail::Body.new("VGhlIGJvZHk=\n")
+    #   body.encoding = 'base64'
+    #   body =~ /The/ #=> 0
+    def =~(regexp)
+      self.decoded =~ regexp
+    end
+
+    # Accepts a string and performs a regular expression against the decoded text
+    #
+    # Examples:
+    #
+    #   body = Mail::Body.new('The body')
+    #   body.match(/The/) #=> #<MatchData "The">
+    #
+    #   body = Mail::Body.new("VGhlIGJvZHk=\n")
+    #   body.encoding = 'base64'
+    #   body.match(/The/) #=> #<MatchData "The">
+    def match(regexp)
+      self.decoded.match(regexp)
+    end
+
+    # Accepts anything that responds to #to_s and checks if it's a substring of the decoded text
+    #
+    # Examples:
+    #
+    #   body = Mail::Body.new('The body')
+    #   body.include?('The') #=> true
+    #
+    #   body = Mail::Body.new("VGhlIGJvZHk=\n")
+    #   body.encoding = 'base64'
+    #   body.include?('The') #=> true
+    def include?(other)
+      self.decoded.include?(other.to_s)
+    end
+
+    # Allows you to set the sort order of the parts, overriding the default sort order.
+    # Defaults to 'text/plain', then 'text/enriched', then 'text/html', then 'multipart/alternative'
+    # with any other content type coming after.
+    def set_sort_order(order)
+      @part_sort_order = order
+    end
+
+    # Allows you to sort the parts according to the default sort order, or the sort order you
+    # set with :set_sort_order.
+    #
+    # sort_parts! is also called from :encode, so there is no need for you to call this explicitly
+    def sort_parts!
+      @parts.each do |p|
+        p.body.set_sort_order(@part_sort_order)
+        p.body.sort_parts!
+      end
+      @parts.sort!(@part_sort_order)
+    end
+
+    def negotiate_best_encoding(message_encoding, allowed_encodings = nil)
+      Mail::Encodings::TransferEncoding.negotiate(message_encoding, encoding, raw_source, allowed_encodings)
+    end
+
+    # Returns a body encoded using transfer_encoding.  Multipart always uses an
+    # identiy encoding (i.e. no encoding).
+    # Calling this directly is not a good idea, but supported for compatibility
+    # TODO: Validate that preamble and epilogue are valid for requested encoding
+    def encoded(transfer_encoding = nil)
+      if multipart?
+        self.sort_parts!
+        encoded_parts = parts.map { |p| p.encoded }
+        ([preamble] + encoded_parts).join(crlf_boundary) + end_boundary + epilogue.to_s
+      else
+        dec = Mail::Encodings.get_encoding(encoding)
+        enc =
+          if Utilities.blank?(transfer_encoding)
+            dec
+          else
+            negotiate_best_encoding(transfer_encoding)
+          end
+
+        if dec.nil?
+          # Cannot decode, so skip normalization
+          raw_source
+        else
+          # Decode then encode to normalize and allow transforming
+          # from base64 to Q-P and vice versa
+          decoded = dec.decode(raw_source)
+          if defined?(Encoding) && charset && charset != "US-ASCII"
+            decoded = decoded.encode(charset)
+            decoded.force_encoding('BINARY') unless Encoding.find(charset).ascii_compatible?
+          end
+          enc.encode(decoded)
+        end
+      end
+    end
+
+    def decoded
+      if !Encodings.defined?(encoding)
+        raise UnknownEncodingType, "Don't know how to decode #{encoding}, please call #encoded and decode it yourself."
+      else
+        Encodings.get_encoding(encoding).decode(raw_source)
+      end
+    end
+
+    def to_s
+      decoded
+    end
+
+    def encoding(val = nil)
+      if val
+        self.encoding = val
+      else
+        @encoding
+      end
+    end
+
+    def encoding=( val )
+      @encoding =
+        if val == "text" || Utilities.blank?(val)
+          default_encoding
+        else
+          val
+        end
+    end
+
+    # Returns the raw source that the body was initialized with, without
+    # any tampering
+    attr_reader :raw_source
+
+    # Returns parts of the body
+    attr_reader :parts
+
+    # Returns and sets the original character encoding
+    attr_accessor :charset
+
+    # Returns and sets the preamble as a string (any text that is before the first MIME boundary)
+    attr_accessor :preamble
+
+    # Returns and sets the epilogue as a string (any text that is after the last MIME boundary)
+    attr_accessor :epilogue
+
+    # Returns and sets the boundary used by the body
+    # Allows you to change the boundary of this Body object
+    attr_accessor :boundary
+
+    # Returns true if there are parts defined in the body
+    def multipart?
+      true unless parts.empty?
+    end
+
+    def <<( val )
+      if @parts
+        @parts << val
+      else
+        @parts = Mail::PartsList.new[val]
+      end
+    end
+
+    def split!(boundary)
+      self.boundary = boundary
+      parts = extract_parts
+
+      # Make the preamble equal to the preamble (if any)
+      self.preamble = parts[0].to_s.strip
+      # Make the epilogue equal to the epilogue (if any)
+      self.epilogue = parts[-1].to_s.strip
+      parts[1...-1].to_a.each { |part| @parts << Mail::Part.new(part) }
+      self
+    end
+
+    def ascii_only?
+      unless defined? @ascii_only
+        @ascii_only = raw_source.ascii_only?
+      end
+      @ascii_only
+    end
+
+    def empty?
+      !!raw_source.to_s.empty?
+    end
+
+    def default_encoding
+      ascii_only? ? '7bit' : '8bit'
+    end
+
+    private
+
+    # split parts by boundary, ignore first part if empty, append final part when closing boundary was missing
+    def extract_parts
+      parts_regex = /
+        (?:                    # non-capturing group
+          \A                |  # start of string OR
+          \r?\n                # line break with optional CR
+         )
+        (
+          --#{Regexp.escape(boundary || "")}  # boundary delimiter
+          (?:--)?                             # with non-capturing optional closing
+        )
+        (?=\s*$)                              # lookahead matching zero or more spaces followed by line-ending
+      /x
+      parts = raw_source.split(parts_regex).each_slice(2).to_a
+      parts.each_with_index { |(part, _), index| parts.delete_at(index) if index > 0 && Utilities.blank?(part) }
+
+      if parts.size > 1
+        final_separator = parts[-2][1]
+        parts << [""] if final_separator != "--#{boundary}--"
+      end
+      parts.map(&:first)
+    end
+
+    def crlf_boundary
+      "\r\n--#{boundary}\r\n"
+    end
+
+    def end_boundary
+      "\r\n--#{boundary}--\r\n"
+    end
+
+    def set_charset
+      @charset = ascii_only? ? 'US-ASCII' : nil
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/mail-2.9.1/lib/mail/configuration.rb

@@ -0,0 +1,78 @@
+# encoding: utf-8
+# frozen_string_literal: true
+#
+# Thanks to Nicolas Fouché for this wrapper
+#
+require 'singleton'
+
+module Mail
+
+  # The Configuration class is a Singleton used to hold the default
+  # configuration for all Mail objects.
+  #
+  # Each new mail object gets a copy of these values at initialization
+  # which can be overwritten on a per mail object basis.
+  class Configuration
+    include Singleton
+
+    def initialize
+      @delivery_method  = nil
+      @retriever_method = nil
+      super
+    end
+
+    def delivery_method(method = nil, settings = {})
+      return @delivery_method if @delivery_method && method.nil?
+      @delivery_method = lookup_delivery_method(method).new(settings)
+    end
+
+    def lookup_delivery_method(method)
+      case method.is_a?(String) ? method.to_sym : method
+      when nil
+        Mail::SMTP
+      when :smtp
+        Mail::SMTP
+      when :sendmail
+        Mail::Sendmail
+      when :exim
+        Mail::Exim
+      when :file
+        Mail::FileDelivery
+      when :smtp_connection
+        Mail::SMTPConnection
+      when :test
+        Mail::TestMailer
+      when :logger
+        Mail::LoggerDelivery
+      else
+        method
+      end
+    end
+
+    def retriever_method(method = nil, settings = {})
+      return @retriever_method if @retriever_method && method.nil?
+      @retriever_method = lookup_retriever_method(method).new(settings)
+    end
+
+    def lookup_retriever_method(method)
+      case method
+      when nil
+        Mail::POP3
+      when :pop3
+        Mail::POP3
+      when :imap
+        Mail::IMAP
+      when :test
+        Mail::TestRetriever
+      else
+        method
+      end
+    end
+
+    def param_encode_language(value = nil)
+      value ? @encode_language = value : @encode_language ||= 'en'
+    end
+
+  end
+
+end

data/vendor/bundle/ruby/3.4.0/gems/mail-2.9.1/lib/mail/constants.rb

@@ -0,0 +1,79 @@
+# encoding: us-ascii
+# frozen_string_literal: true
+module Mail
+  module Constants
+    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.dup.force_encoding(Encoding::BINARY)
+    end
+
+    LAX_CRLF      = /\r?\n/
+    WSP           = /[#{white_space}]/
+    FWS           = /#{LAX_CRLF}#{WSP}*/
+    UNFOLD_WS     = /#{LAX_CRLF}(#{WSP})/m
+    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  = /#{LAX_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
+
+    ENCODED_VALUE = %r{
+      \=\?     # literal =?
+      ([^?]+)  #
+      \?       # literal ?
+      ([QB])   # either a "Q" or a "B"
+      \?       # literal ?
+      .*?      # lazily match all characters
+      \?\=     # literal ?=
+    }mix # m is multi-line, i is case-insensitive, x is free-spacing
+
+    FULL_ENCODED_VALUE = %r{ # Identical to ENCODED_VALUE but captures the whole rather than components of
+      (
+        \=\?    # literal =?
+        [^?]+   #
+        \?      # literal ?
+        [QB]    # either a "Q" or a "B"
+        \?      # literal ?
+        .*?     # lazily match all characters
+        \?\=    # literal ?=
+      )
+    }mix # m is multi-line, i is case-insensitive, x is free-spacing
+
+    EMPTY          = ''
+    SPACE          = ' '
+    UNDERSCORE     = '_'
+    HYPHEN         = '-'
+    COLON          = ':'
+    ASTERISK       = '*'
+    CRLF           = "\r\n"
+    CR             = "\r"
+    LF             = "\n"
+    CR_ENCODED     = "=0D"
+    LF_ENCODED     = "=0A"
+    CAPITAL_M      = 'M'
+    EQUAL_LF       = "=\n"
+    NULL_SENDER    = '<>'
+
+    Q_VALUES       = ['Q','q']
+    B_VALUES       = ['B','b']
+  end
+end