nano-fast-tool 0.0.1

data/mail-2.9.1/lib/mail/network/delivery_methods/sendmail.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+require 'mail/smtp_envelope'
+
+module Mail
+  # A delivery method implementation which sends via sendmail.
+  #
+  # To use this, first find out where the sendmail binary is on your computer,
+  # if you are on a mac or unix box, it is usually in /usr/sbin/sendmail, this will
+  # be your sendmail location.
+  #
+  #   Mail.defaults do
+  #     delivery_method :sendmail
+  #   end
+  #
+  # Or if your sendmail binary is not at '/usr/sbin/sendmail'
+  #
+  #   Mail.defaults do
+  #     delivery_method :sendmail, :location => '/absolute/path/to/your/sendmail'
+  #   end
+  #
+  # Then just deliver the email as normal:
+  #
+  #   Mail.deliver do
+  #     to 'mikel@test.lindsaar.net'
+  #     from 'ada@test.lindsaar.net'
+  #     subject 'testing sendmail'
+  #     body 'testing sendmail'
+  #   end
+  #
+  # Or by calling deliver on a Mail message
+  #
+  #   mail = Mail.new do
+  #     to 'mikel@test.lindsaar.net'
+  #     from 'ada@test.lindsaar.net'
+  #     subject 'testing sendmail'
+  #     body 'testing sendmail'
+  #   end
+  #
+  #   mail.deliver!
+  class Sendmail
+    DEFAULTS = {
+      :location   => '/usr/sbin/sendmail',
+      :arguments  => %w[ -i ]
+    }
+
+    attr_accessor :settings
+
+    class DeliveryError < StandardError
+    end
+
+    def initialize(values)
+      self.settings = self.class::DEFAULTS.merge(values)
+      raise ArgumentError, ":arguments expected to be an Array of individual string args" if settings[:arguments].is_a?(String)
+    end
+
+    def destinations_for(envelope)
+      envelope.to
+    end
+
+    def deliver!(mail)
+      envelope = Mail::SmtpEnvelope.new(mail)
+
+      command = [settings[:location]]
+      command.concat Array(settings[:arguments])
+      command.concat [ '-f', envelope.from ] if envelope.from
+
+      if destinations = destinations_for(envelope)
+        command.push '--'
+        command.concat destinations
+      end
+
+      popen(command) do |io|
+        io.puts ::Mail::Utilities.binary_unsafe_to_lf(envelope.message)
+        io.flush
+      end
+    end
+
+    private
+      def popen(command, &block)
+        IO.popen(command, 'w+', :err => :out, &block).tap do
+          if $?.exitstatus != 0
+            raise DeliveryError, "Delivery failed with exitstatus #{$?.exitstatus}: #{command.inspect}"
+          end
+        end
+      end
+  end
+end

data/mail-2.9.1/lib/mail/network/delivery_methods/smtp.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+require 'mail/smtp_envelope'
+
+module Mail
+  # == Sending Email with SMTP
+  #
+  # Mail allows you to send emails using SMTP.  This is done by wrapping Net::SMTP in
+  # an easy to use manner.
+  #
+  # === Sending via SMTP server on Localhost
+  #
+  # Sending locally (to a postfix or sendmail server running on localhost) requires
+  # no special setup.  Just to Mail.deliver &block or message.deliver! and it will
+  # be sent in this method.
+  #
+  # === Sending via MobileMe
+  #
+  #   Mail.defaults do
+  #     delivery_method :smtp, { :address              => "smtp.me.com",
+  #                              :port                 => 587,
+  #                              :domain               => 'your.host.name',
+  #                              :user_name            => '<username>',
+  #                              :password             => '<password>',
+  #                              :authentication       => 'plain',
+  #                              :enable_starttls      => :auto  }
+  #   end
+  #
+  # === Sending via GMail
+  #
+  #   Mail.defaults do
+  #     delivery_method :smtp, { :address              => "smtp.gmail.com",
+  #                              :port                 => 587,
+  #                              :domain               => 'your.host.name',
+  #                              :user_name            => '<username>',
+  #                              :password             => '<password>',
+  #                              :authentication       => 'plain',
+  #                              :enable_starttls      => :auto  }
+  #   end
+  #
+  # === Configuring TLS/SSL and STARTTLS
+  #
+  # A few remarks:
+  # - when enabling `tls` (or `ssl`), setting (truthy values for) either `enable_starttls` or `enable_starttls_auto` will raise an ArgumentError as TLS and STARTTLS are mutually exclusive.
+  # - to configure STARTTLS, use the `enable_starttls`-flag (instead of a combination of `enable_starttls` and `enable_starttls_auto`). Acceptable values are `:always`, `:auto` and `false`.
+  # - when providing a truthy value for `enable_starttls`, the `enable_starttls_auto`-flag will be ignored.
+  # - when none of `tls`, `ssl`, `enable_starttls` or `enable_starttls_auto` is set, the fallback will be `enable_starttls` `:auto`.
+  #
+  # === Certificate verification
+  #
+  # When using TLS, some mail servers provide certificates that are self-signed
+  # or whose names do not exactly match the hostname given in the address.
+  # OpenSSL will reject these by default. The best remedy is to use the correct
+  # hostname or update the certificate authorities trusted by your ruby. If
+  # that isn't possible, you can control this behavior with
+  # an :openssl_verify_mode setting. Its value may be either an OpenSSL
+  # verify mode constant (OpenSSL::SSL::VERIFY_NONE, OpenSSL::SSL::VERIFY_PEER),
+  # or a string containing the name of an OpenSSL verify mode (none, peer).
+  #
+  # === Others
+  #
+  # Feel free to send me other examples that were tricky
+  #
+  # === Delivering the email
+  #
+  # Once you have the settings right, sending the email is done by:
+  #
+  #   Mail.deliver do
+  #     to 'mikel@test.lindsaar.net'
+  #     from 'ada@test.lindsaar.net'
+  #     subject 'testing sendmail'
+  #     body 'testing sendmail'
+  #   end
+  #
+  # Or by calling deliver on a Mail message
+  #
+  #   mail = Mail.new do
+  #     to 'mikel@test.lindsaar.net'
+  #     from 'ada@test.lindsaar.net'
+  #     subject 'testing sendmail'
+  #     body 'testing sendmail'
+  #   end
+  #
+  #   mail.deliver!
+  class SMTP
+    attr_accessor :settings
+
+    DEFAULTS = {
+      :address              => 'localhost',
+      :port                 => 25,
+      :domain               => 'localhost.localdomain',
+      :user_name            => nil,
+      :password             => nil,
+      :authentication       => nil,
+      :enable_starttls      => nil,
+      :enable_starttls_auto => nil,
+      :openssl_verify_mode  => nil,
+      :ssl                  => nil,
+      :tls                  => nil,
+      :open_timeout         => 5,
+      :read_timeout         => 5
+    }
+
+    def initialize(values)
+      self.settings = DEFAULTS.merge(values)
+    end
+
+    def deliver!(mail)
+      response = start_smtp_session do |smtp|
+        Mail::SMTPConnection.new(:connection => smtp, :return_response => true).deliver!(mail)
+      end
+
+      settings[:return_response] ? response : self
+    end
+
+    private
+      # `k` is said to be provided when `settings` has a non-nil value for `k`.
+      def setting_provided?(k)
+        !settings[k].nil?
+      end
+
+      # Yields one of `:always`, `:auto` or `false` based on `enable_starttls` and `enable_starttls_auto` flags.
+      # Yields `false` when `smtp_tls?`.
+      # Else defaults to `:auto` when neither `enable_starttls*` flag is provided.
+      # Providing a truthy value for `enable_starttls` will ignore `enable_starttls_auto`.
+      def smtp_starttls
+        return false if smtp_tls?
+
+        if setting_provided?(:enable_starttls) && settings[:enable_starttls]
+          # enable_starttls: provided and truthy
+          case settings[:enable_starttls]
+          when :auto then :auto
+          when :always then :always
+          else
+            :always
+          end
+        else
+          # enable_starttls: not provided or false
+          if setting_provided?(:enable_starttls_auto)
+            settings[:enable_starttls_auto] ? :auto : false
+          else
+            # enable_starttls_auto: not provided
+            # enable_starttls: when provided then false
+            # use :auto when neither enable_starttls* provided
+            setting_provided?(:enable_starttls) ? false : :auto
+          end
+        end
+      end
+
+      def smtp_tls?
+        (setting_provided?(:tls) && settings[:tls]) || (setting_provided?(:ssl) && settings[:ssl])
+      end
+
+      def start_smtp_session(&block)
+        build_smtp_session.start(settings[:domain], settings[:user_name], settings[:password], settings[:authentication], &block)
+      end
+
+      def build_smtp_session
+        if smtp_tls? && (settings[:enable_starttls] || settings[:enable_starttls_auto])
+          raise ArgumentError, ":enable_starttls and :tls are mutually exclusive. Set :tls if you're on an SMTPS connection. Set :enable_starttls if you're on an SMTP connection and using STARTTLS for secure TLS upgrade."
+        end
+
+        Net::SMTP.new(settings[:address], settings[:port]).tap do |smtp|
+          if smtp_tls?
+            smtp.disable_starttls
+            smtp.enable_tls(ssl_context)
+          else
+            smtp.disable_tls
+
+            case smtp_starttls
+            when :always
+              smtp.enable_starttls(ssl_context)
+            when :auto
+              smtp.enable_starttls_auto(ssl_context)
+            else
+              smtp.disable_starttls
+            end
+          end
+
+          smtp.open_timeout = settings[:open_timeout] if settings[:open_timeout]
+          smtp.read_timeout = settings[:read_timeout] if settings[:read_timeout]
+        end
+      end
+
+      # Allow SSL context to be configured via settings, for Ruby >= 1.9
+      # Just returns openssl verify mode for Ruby 1.8.x
+      def ssl_context
+        openssl_verify_mode = settings[:openssl_verify_mode]
+
+        if openssl_verify_mode.kind_of?(String)
+          openssl_verify_mode = OpenSSL::SSL.const_get("VERIFY_#{openssl_verify_mode.upcase}")
+        end
+
+        context = Net::SMTP.default_ssl_context
+        context.verify_mode = openssl_verify_mode if openssl_verify_mode
+        context.ca_path = settings[:ca_path] if settings[:ca_path]
+        context.ca_file = settings[:ca_file] if settings[:ca_file]
+        context
+      end
+  end
+end

data/mail-2.9.1/lib/mail/network/delivery_methods/smtp_connection.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+require 'mail/smtp_envelope'
+
+module Mail
+  # == Sending Email with SMTP
+  #
+  # Mail allows you to send emails using an open SMTP connection.  This is done by
+  # passing a created Net::SMTP object.  This way we can get better performance to
+  # our local mail server by reducing the number of connections at any one time.
+  #
+  # === Sending via SMTP server on Localhost
+  #
+  # To send mail open a connection with Net::Smtp using any options you like
+  # === Delivering the email
+  #
+  # Once you have the settings right, sending the email is done by:
+  #
+  #   smtp_conn = Net::SMTP.start(settings[:address], settings[:port])
+  #   Mail.defaults do
+  #     delivery_method :smtp_connection, { :connection => smtp_conn }
+  #   end
+  #
+  #   Mail.deliver do
+  #     to 'mikel@test.lindsaar.net'
+  #     from 'ada@test.lindsaar.net'
+  #     subject 'testing sendmail'
+  #     body 'testing sendmail'
+  #   end
+  #
+  # Or by calling deliver on a Mail message
+  #
+  #   mail = Mail.new do
+  #     to 'mikel@test.lindsaar.net'
+  #     from 'ada@test.lindsaar.net'
+  #     subject 'testing sendmail'
+  #     body 'testing sendmail'
+  #   end
+  #
+  #   mail.deliver!
+  class SMTPConnection
+    attr_accessor :smtp, :settings
+
+    def initialize(values)
+      raise ArgumentError.new('A Net::SMTP object is required for this delivery method') if values[:connection].nil?
+      self.smtp = values[:connection]
+      self.settings = values
+    end
+
+    # Send the message via SMTP.
+    # The from and to attributes are optional. If not set, they are retrieve from the Message.
+    def deliver!(mail)
+      envelope = Mail::SmtpEnvelope.new(mail)
+      response = smtp.sendmail(envelope.message, envelope.from, envelope.to)
+      settings[:return_response] ? response : self
+    end
+  end
+end

data/mail-2.9.1/lib/mail/network/delivery_methods/test_mailer.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+require 'mail/smtp_envelope'
+
+module Mail
+  # The TestMailer is a bare bones mailer that does nothing.  It is useful
+  # when you are testing.
+  #
+  # It also provides a template of the minimum methods you require to implement
+  # if you want to make a custom mailer for Mail
+  class TestMailer
+    # Provides a store of all the emails sent with the TestMailer so you can check them.
+    def self.deliveries
+      @@deliveries ||= []
+    end
+
+    # Allows you to over write the default deliveries store from an array to some
+    # other object.  If you just want to clear the store,
+    # call TestMailer.deliveries.clear.
+    #
+    # If you place another object here, please make sure it responds to:
+    #
+    # * << (message)
+    # * clear
+    # * length
+    # * size
+    # * and other common Array methods
+    def self.deliveries=(val)
+      @@deliveries = val
+    end
+
+    attr_accessor :settings
+
+    def initialize(values)
+      @settings = values.dup
+    end
+
+    def deliver!(mail)
+      # Create the envelope to validate it
+      Mail::SmtpEnvelope.new(mail)
+
+      Mail::TestMailer.deliveries << mail
+    end
+  end
+end

data/mail-2.9.1/lib/mail/network/retriever_methods/base.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Mail
+
+  class Retriever
+
+    # Get the oldest received email(s)
+    #
+    # Possible options:
+    #   count: number of emails to retrieve. The default value is 1.
+    #   order: order of emails returned. Possible values are :asc or :desc. Default value is :asc.
+    #
+    def first(options = nil, &block)
+      options = options ? Hash[options] : {}
+      options[:what] = :first
+      options[:count] ||= 1
+      find(options, &block)
+    end
+
+    # Get the most recent received email(s)
+    #
+    # Possible options:
+    #   count: number of emails to retrieve. The default value is 1.
+    #   order: order of emails returned. Possible values are :asc or :desc. Default value is :asc.
+    #
+    def last(options = nil, &block)
+      options = options ? Hash[options] : {}
+      options[:what] = :last
+      options[:count] ||= 1
+      find(options, &block)
+    end
+
+    # Get all emails.
+    #
+    # Possible options:
+    #   order: order of emails returned. Possible values are :asc or :desc. Default value is :asc.
+    #
+    def all(options = nil, &block)
+      options = options ? Hash[options] : {}
+      options[:count] = :all
+      find(options, &block)
+    end
+
+    # Find emails in the mailbox, and then deletes them. Without any options, the
+    # five last received emails are returned.
+    #
+    # Possible options:
+    #   what:  last or first emails. The default is :first.
+    #   order: order of emails returned. Possible values are :asc or :desc. Default value is :asc.
+    #   count: number of emails to retrieve. The default value is 10. A value of 1 returns an
+    #          instance of Message, not an array of Message instances.
+    #   delete_after_find: flag for whether to delete each retreived email after find. Default
+    #           is true. Call #find if you would like this to default to false.
+    #
+    def find_and_delete(options = nil, &block)
+      options = options ? Hash[options] : {}
+      options[:delete_after_find] ||= true
+      find(options, &block)
+    end
+
+  end
+
+end

data/mail-2.9.1/lib/mail/network/retriever_methods/imap.rb

@@ -0,0 +1,190 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Mail
+  # The IMAP retriever allows to get the last, first or all emails from a IMAP server.
+  # Each email retrieved (RFC2822) is given as an instance of +Message+.
+  #
+  # While being retrieved, emails can be yielded if a block is given.
+  #
+  # === Example of retrieving Emails from GMail:
+  #
+  #   Mail.defaults do
+  #     retriever_method :imap, { :address             => "imap.googlemail.com",
+  #                               :port                => 993,
+  #                               :user_name           => '<username>',
+  #                               :password            => '<password>',
+  #                               :enable_ssl          => true }
+  #   end
+  #
+  #   Mail.all    #=> Returns an array of all emails
+  #   Mail.first  #=> Returns the first unread email
+  #   Mail.last   #=> Returns the last unread email
+  #
+  # You can also pass options into Mail.find to locate an email in your imap mailbox
+  # with the following options:
+  #
+  #   mailbox: name of the mailbox used for email retrieval. The default is 'INBOX'.
+  #   what:    last or first emails. The default is :first.
+  #   order:   order of emails returned. Possible values are :asc or :desc. Default value is :asc.
+  #   count:   number of emails to retrieve. The default value is 10. A value of 1 returns an
+  #            instance of Message, not an array of Message instances.
+  #   keys:    are passed as criteria to the SEARCH command.  They can either be a string holding the entire search string,
+  #            or a single-dimension array of search keywords and arguments.  Refer to  [IMAP] section 6.4.4 for a full list
+  #            The default is 'ALL'
+  #
+  #   Mail.find(:what => :first, :count => 10, :order => :asc, :keys=>'ALL')
+  #   #=> Returns the first 10 emails in ascending order
+  #
+  class IMAP < Retriever
+    require 'net/imap' unless defined?(Net::IMAP)
+
+    def initialize(values)
+      self.settings = { :address              => "localhost",
+                        :port                 => 143,
+                        :user_name            => nil,
+                        :password             => nil,
+                        :authentication       => nil,
+                        :enable_ssl           => false,
+                        :enable_starttls      => false }.merge!(values)
+    end
+
+    attr_accessor :settings
+
+    # Find emails in a IMAP mailbox. Without any options, the 10 last received emails are returned.
+    #
+    # Possible options:
+    #   mailbox: mailbox to search the email(s) in. The default is 'INBOX'.
+    #   what:    last or first emails. The default is :first.
+    #   order:   order of emails returned. Possible values are :asc or :desc. Default value is :asc.
+    #   count:   number of emails to retrieve. The default value is 10. A value of 1 returns an
+    #            instance of Message, not an array of Message instances.
+    #   read_only: will ensure that no writes are made to the inbox during the session.  Specifically, if this is
+    #              set to true, the code will use the EXAMINE command to retrieve the mail.  If set to false, which
+    #              is the default, a SELECT command will be used to retrieve the mail
+    #              This is helpful when you don't want your messages to be set to read automatically. Default is false.
+    #   delete_after_find: flag for whether to delete each retreived email after find. Default
+    #           is false. Use #find_and_delete if you would like this to default to true.
+    #   keys:   are passed as criteria to the SEARCH command.  They can either be a string holding the entire search string,
+    #           or a single-dimension array of search keywords and arguments.  Refer to  [IMAP] section 6.4.4 for a full list
+    #           The default is 'ALL'
+    #   search_charset: charset to pass to IMAP server search. Omitted by default. Example: 'UTF-8' or 'ASCII'.
+    #
+    def find(options=nil, &block)
+      options = validate_options(options)
+
+      start do |imap|
+        options[:read_only] ? imap.examine(options[:mailbox]) : imap.select(options[:mailbox])
+
+        uids = imap.uid_search(options[:keys], options[:search_charset])
+          .to_a # older net-imap may return nil, newer may return ESearchResult struct
+          .sort # RFC3501 does _not_ require UIDs to be returned in order
+        uids.reverse! if options[:what].to_sym == :last
+        uids = uids.first(options[:count]) if options[:count].is_a?(Integer)
+        uids.reverse! if (options[:what].to_sym == :last && options[:order].to_sym == :asc) ||
+                                (options[:what].to_sym != :last && options[:order].to_sym == :desc)
+
+        if block_given?
+          uids.each do |uid|
+            uid = options[:uid].to_i unless options[:uid].nil?
+            fetchdata = imap.uid_fetch(uid, ['RFC822', 'FLAGS'])[0]
+            new_message = Mail.new(fetchdata.attr['RFC822'])
+            new_message.mark_for_delete = true if options[:delete_after_find]
+
+            if block.arity == 4
+              yield new_message, imap, uid, fetchdata.attr['FLAGS']
+            elsif block.arity == 3
+              yield new_message, imap, uid
+            else
+              yield new_message
+            end
+
+            imap.uid_store(uid, "+FLAGS", [Net::IMAP::DELETED]) if options[:delete_after_find] && new_message.is_marked_for_delete?
+            break unless options[:uid].nil?
+          end
+          imap.expunge if options[:delete_after_find]
+        else
+          emails = []
+          uids.each do |uid|
+            uid = options[:uid].to_i unless options[:uid].nil?
+            fetchdata = imap.uid_fetch(uid, ['RFC822'])[0]
+            emails << Mail.new(fetchdata.attr['RFC822'])
+            imap.uid_store(uid, "+FLAGS", [Net::IMAP::DELETED]) if options[:delete_after_find]
+            break unless options[:uid].nil?
+          end
+          imap.expunge if options[:delete_after_find]
+          emails.size == 1 && options[:count] == 1 ? emails.first : emails
+        end
+      end
+    end
+
+    # Delete all emails from a IMAP mailbox
+    def delete_all(mailbox='INBOX')
+      mailbox ||= 'INBOX'
+      mailbox = Net::IMAP.encode_utf7(mailbox)
+
+      start do |imap|
+        imap.select(mailbox)
+        imap.uid_search(['ALL']).each do |uid|
+          imap.uid_store(uid, "+FLAGS", [Net::IMAP::DELETED])
+        end
+        imap.expunge
+      end
+    end
+
+    # Returns the connection object of the retrievable (IMAP or POP3)
+    def connection(&block)
+      raise ArgumentError.new('Mail::Retrievable#connection takes a block') unless block_given?
+
+      start do |imap|
+        yield imap
+      end
+    end
+
+    private
+
+      # Set default options
+      def validate_options(options)
+        options = options ? Hash[options] : {}
+        options[:mailbox] ||= 'INBOX'
+        options[:count]   ||= 10
+        options[:order]   ||= :asc
+        options[:what]    ||= :first
+        options[:keys]    ||= 'ALL'
+        options[:uid]     ||= nil
+        options[:delete_after_find] ||= false
+        options[:mailbox] = Net::IMAP.encode_utf7(options[:mailbox])
+        options[:read_only] ||= false
+
+        options
+      end
+
+      # Start an IMAP session and ensures that it will be closed in any case.
+      def start(config=Mail::Configuration.instance, &block)
+        raise ArgumentError.new("Mail::Retrievable#imap_start takes a block") unless block_given?
+
+        if settings[:enable_starttls] && settings[:enable_ssl]
+          raise ArgumentError, ":enable_starttls and :enable_ssl are mutually exclusive. Set :enable_ssl if you're on an IMAPS connection. Set :enable_starttls if you're on an IMAP connection and using STARTTLS for secure TLS upgrade."
+        end
+
+        imap = Net::IMAP.new(settings[:address], settings[:port], settings[:enable_ssl], nil, false)
+
+        imap.starttls if settings[:enable_starttls]
+
+        if settings[:authentication].nil?
+          imap.login(settings[:user_name], settings[:password])
+        else
+          # Note that Net::IMAP#authenticate('LOGIN', ...) is not equal with Net::IMAP#login(...)!
+          # (see also http://www.ensta.fr/~diam/ruby/online/ruby-doc-stdlib/libdoc/net/imap/rdoc/classes/Net/IMAP.html#M000718)
+          imap.authenticate(settings[:authentication], settings[:user_name], settings[:password])
+        end
+
+        yield imap
+      ensure
+        if defined?(imap) && imap && !imap.disconnected?
+          imap.disconnect
+        end
+      end
+
+  end
+end