mailhandler 1.0.36 → 1.0.37

data/lib/mailhandler/receiving/filelist/filter/base.rb

@@ -2,107 +2,65 @@ require_relative '../base'
 require_relative '../../../errors'
 
 module MailHandler
-
   module Receiving
-
     class FileList
-
       module Filter
-
         class Base
-
           attr_accessor :files, :fast_check
 
           def initialize(files)
-
-            @files=files
-
+            @files = files
           end
 
           def get
-
             files.select { |file| ignore_exception { meets_expectation?(file) } }
-
           end
 
           protected
 
-          def meet_expectation?(file)
-
+          def meet_expectation?(_file)
             raise MailHandler::InterfaceError, 'Interface not implemented.'
-
           end
 
           def read_file(file)
-
             File.read(file)
-
           end
 
           private
 
           def ignore_exception
-
-            begin
-
-              yield
-
-            rescue
-
-              false
-
-            end
-
+            yield
+          rescue StandardError
+            false
           end
-
         end
 
         module ByDate
 
-          class Since < Base
-
+          class BaseDate < Base
             def initialize(files, date)
-
               super(files)
               @date = date
-
             end
+          end
 
+          class Since < BaseDate
             private
 
             def meets_expectation?(file)
-
-              (File.exists? file)? (File.ctime file) > @date : false
-
+              File.exist?(file)? (File.ctime file) > @date : false
             end
-
           end
 
           class Before < Base
-
-            def initialize(files, date)
-
-              super(files)
-              @date = date
-
-            end
-
             private
 
             def meets_expectation?(file)
-
-              (File.exists? file)? (File.ctime file) < @date : false
-
+              File.exist?(file)? (File.ctime file) < @date : false
             end
-
           end
-
         end
-
       end
-
     end
-
   end
-
 end

data/lib/mailhandler/receiving/filelist/filter/email.rb

@@ -2,72 +2,50 @@ require 'mail'
 require_relative 'base'
 
 module MailHandler
-
   module Receiving
-
     class FileList
-
       module Filter
-
         # filtering file content by its email properties
         class Email < Base
-
           def initialize(files)
-
-            @fast_check=true
+            @fast_check = true
             super(files)
-
           end
 
           protected
 
           def read_email_from_file(file)
-
             Mail.read(file)
-
           end
 
           def meets_expectation?(file)
-
             # fast content checks search for content by file reading
             # slow content checks search for content by reconstructing email from file and then searching for content
-            (fast_check)? check_content_fast(file) : check_content_slow(file)
-
+            fast_check ? check_content_fast(file) : check_content_slow(file)
           end
 
-          def check_content_fast(file)
-
+          def check_content_fast(_file)
             raise MailHandler::InterfaceError, 'Interface not implemented.'
-
           end
 
-          def check_content_slow(file)
-
+          def check_content_slow(_file)
             raise MailHandler::InterfaceError, 'Interface not implemented.'
-
           end
-
         end
 
         class ByEmailContent < Email
-
           def initialize(files, content)
-
             super(files)
             @content = content
-
           end
 
           private
 
           def check_content_fast(file)
-
             read_file(file).include? @content
-
           end
 
           def check_content_slow(file)
-
             email = read_email_from_file(file)
 
             if email.multipart?
@@ -79,52 +57,34 @@ module MailHandler
               email.decoded.include? @content
 
             end
-
           end
-
         end
 
         class ByEmailSubject < ByEmailContent
-
           private
 
           def check_content_fast(file)
-
             read_file(file).include? @content
-
           end
 
           def check_content_slow(file)
-
             read_email_from_file(file).subject.to_s.include? @content
-
           end
-
         end
 
         class ByEmailRecipient < Email
-
           def initialize(files, recipient)
-
             super(files)
             @recipient = recipient
-
           end
 
           private
 
           def meets_expectation?(file)
-
             read_email_from_file(file)[@recipient.keys.first].to_s.include? @recipient.values.first
-
           end
-
         end
-
       end
-
     end
-
   end
-
 end

data/lib/mailhandler/receiving/folder.rb

@@ -6,11 +6,8 @@ require_relative 'filelist/filter/base.rb'
 require_relative 'filelist/filter/email.rb'
 
 module MailHandler
-
   module Receiving
-
     class FolderChecker < Checker
-
       include FileHandling
 
       # folders in which emails will be searched for and managed
@@ -18,36 +15,28 @@ module MailHandler
                     :archive_folder
 
       def initialize(inbox_folder = nil, archive_folder = nil)
-
         super()
 
         @inbox_folder = inbox_folder
         @archive_folder = archive_folder
-
       end
 
       # check whether email is received by checking for an email in folder
       def find(options)
-
         verify_and_set_search_options(options)
         verify_mailbox_folders
         email_files = find_files(search_options)
 
         unless email_files.empty?
-
           @found_emails = parse_email_from_files(email_files, search_options[:count])
           move_files(email_files) if search_options[:archive]
-
         end
 
         search_result
-
       end
 
       def start
-
         verify_mailbox_folders
-
       end
 
       private
@@ -55,94 +44,67 @@ module MailHandler
       # filter options which need to be done by searching files
       FILE_SEARCH_CLASSES = {
 
-          :by_subject => FileList::Filter::ByEmailSubject,
-          :by_content => FileList::Filter::ByEmailContent,
-          :since => FileList::Filter::ByDate::Since,
-          :before => FileList::Filter::ByDate::Before,
-          :by_recipient => FileList::Filter::ByEmailRecipient
-      }
+        by_subject: FileList::Filter::ByEmailSubject,
+        by_content: FileList::Filter::ByEmailContent,
+        since: FileList::Filter::ByDate::Since,
+        before: FileList::Filter::ByDate::Before,
+        by_recipient: FileList::Filter::ByEmailRecipient
+      }.freeze
 
       def search_pattern
-
         @inbox_folder + '/*.*'
-
       end
 
       # find files by FILE_SEARCH_CLASSES options
       # this will ignore filter criteria options which can't be done on files directly
       def find_files(options)
-
         file_list = FileList.new
         files = filter_files(file_list.get(search_pattern), options)
         file_list.sort(files)
-
       end
 
       def filter_files(files, options)
-
         options.each do |key, value|
+          next if FILE_SEARCH_CLASSES[key].nil?
 
-          if FILE_SEARCH_CLASSES[key] != nil
-
-            filter = FILE_SEARCH_CLASSES[key].new(files, value)
-            filter.fast_check = options[:fast_check] unless options[:fast_check].nil?
-            files = filter.get
-
-          end
-
+          filter = FILE_SEARCH_CLASSES[key].new(files, value)
+          filter.fast_check = options[:fast_check] unless options[:fast_check].nil?
+          files = filter.get
         end
 
         files
-
       end
 
       def move_files(files)
-
-        files.each { |file| (inbox_folder == archive_folder)? delete_file(file) : archive_file(file) }
-
+        files.each { |file| (inbox_folder == archive_folder) ? delete_file(file) : archive_file(file) }
       end
 
       def parse_email_from_files(files, count)
-
         read_files(files, count).map { |email_string| Mail.read_from_string(email_string) }
-
       end
 
       def read_files(files, count)
-
         file_contents = []
         files.first(count).each do |file|
-
-          file_content = access_file(file, nil) { File.read(file ) }
+          file_content = access_file(file, nil) { File.read(file) }
           file_contents << file_content unless file_content.nil?
-
         end
 
         file_contents
-
       end
 
       def archive_file(file)
-
         access_file(file) { FileUtils.mv("#{inbox_folder}/#{File.basename(file)}", "#{archive_folder}/#{File.basename(file)}") }
-
       end
 
       def delete_file(file)
-
-        access_file(file) { FileUtils.rm_r "#{inbox_folder}/#{File.basename(file)}", :force => false }
-
+        access_file(file) { FileUtils.rm_r "#{inbox_folder}/#{File.basename(file)}", force: false }
       end
 
       def verify_mailbox_folders
-
-        raise MailHandler::Error, 'Folder variables are not set.' if inbox_folder.nil? or archive_folder.nil?
-        raise MailHandler::FileError, 'Mailbox folders do not exist.' unless File.directory? inbox_folder and File.directory? archive_folder
-
+        raise MailHandler::Error, 'Folder variables are not set.' if inbox_folder.nil? || archive_folder.nil?
+        raise MailHandler::FileError, 'Mailbox folders do not exist.' unless File.directory?(inbox_folder) && File.directory?(archive_folder)
       end
-
     end
-
   end
-
-end
+end

data/lib/mailhandler/receiving/imap.rb

@@ -1,15 +1,10 @@
-# encoding: utf-8
-
 require 'mail'
 require_relative 'base.rb'
 require_relative '../errors'
 
 module MailHandler
-
   module Receiving
-
     class IMAPChecker < Checker
-
       attr_accessor :address,
                     :port,
                     :username,
@@ -22,83 +17,61 @@ module MailHandler
       attr_accessor :manual_connection_manage
 
       def initialize
-
         super
         @manual_connection_manage = false
         @available_search_options = AVAILABLE_SEARCH_OPTIONS
-
       end
 
       def find(options)
-
         verify_and_set_search_options(options)
         @found_emails = find_emails(search_options)
 
         search_result
-
       end
 
       def start
-
         unless manual_connection_manage
           init_retriever
           connect
         end
-
       end
 
       def stop
-
-        unless manual_connection_manage
-          disconnect
-        end
-
+        disconnect unless manual_connection_manage
       end
 
       def connect
-
         mailer.connect
-
       end
 
       def disconnect
-
         mailer.disconnect unless mailer.imap_connection.disconnected?
-
       end
 
       # delegate retrieval details to Mail library
       def init_retriever
-
         # set imap settings if they are not set
         unless retriever_set?
 
           imap_settings = retriever_settings
 
           Mail.defaults do
-
             retriever_method :imap,
                              imap_settings
-
           end
 
         end
-
       end
 
       private
 
       def mailer
-
         @mailer ||= Mail.retriever_method
-
       end
 
       def reconnect
-
         disconnect
         connect
-
       end
 
       # search options:
@@ -107,55 +80,46 @@ module MailHandler
       # count - Int, number of found emails to return
       # archive - Boolean
       # by_recipient - Hash, accepts a hash like: :to => 'igor@example.com'
-      AVAILABLE_SEARCH_OPTIONS = [
-
-          :by_subject,
-          :by_content,
-          :since,
-          :before,
-          :count,
-          :archive,
-          :by_recipient,
-          :fast_check
-
-      ]
+      AVAILABLE_SEARCH_OPTIONS = %i[
+
+        by_subject
+        by_content
+        since
+        before
+        count
+        archive
+        by_recipient
+        fast_check
+      ].freeze
 
       RETRY_ON_ERROR_COUNT = 3
 
       def retriever_set?
-
         Mail.retriever_method.settings == retriever_settings
-
       end
 
       def retriever_settings
-
         {
-            :address => address,
-            :port => port,
-            :user_name => username,
-            :password => password,
-            :authentication => authentication,
-            :enable_ssl => use_ssl
+          address: address,
+          port: port,
+          user_name: username,
+          password: password,
+          authentication: authentication,
+          enable_ssl: use_ssl
         }
-
       end
 
       def find_emails(options)
-
         imap_search(RETRY_ON_ERROR_COUNT, options)
-
       end
 
       def imap_search(retry_count, options)
-
-        result = mailer.find_emails(:what => :last, :count => search_options[:count], :order => :desc, :keys => imap_filter_keys(options), :delete_after_find => options[:archive])
-        (result.kind_of? Array)? result : [result]
+        result = mailer.find_emails(what: :last, count: search_options[:count], order: :desc, keys: imap_filter_keys(options), delete_after_find: options[:archive])
+        result.is_a? Array ? result : [result]
 
       # Silently ignore IMAP search errors, [RETRY_ON_ERROR_COUNT] times
       rescue Net::IMAP::ResponseError, EOFError, NoMethodError => e
-
-        if (retry_count -=1) >= 0
+        if (retry_count -= 1) >= 0
 
           puts e
           reconnect
@@ -166,51 +130,43 @@ module MailHandler
           raise e
 
         end
-
       end
 
       def imap_filter_keys(options)
-
         keys = []
 
         options.keys.each do |filter_option|
-
           case filter_option
 
-            when :by_recipient
+          when :by_recipient
 
-              keys << options[:by_recipient].keys.first.to_s.upcase << options[:by_recipient].values.first
+            keys << options[:by_recipient].keys.first.to_s.upcase << options[:by_recipient].values.first
 
-            when :by_subject
+          when :by_subject
 
-              keys << 'SUBJECT' << options[:by_subject].to_s
+            keys << 'SUBJECT' << options[:by_subject].to_s
 
-            when :by_content
+          when :by_content
 
-              keys << 'BODY' << options[:by_content].to_s
+            keys << 'BODY' << options[:by_content].to_s
 
-            when :since
+          when :since
 
-              keys << 'SINCE' << Net::IMAP.format_date(options[:since])
+            keys << 'SINCE' << Net::IMAP.format_date(options[:since])
 
-            when :before
+          when :before
 
-              keys << 'BEFORE' << Net::IMAP.format_date(options[:before])
+            keys << 'BEFORE' << Net::IMAP.format_date(options[:before])
 
-            else
+          else
 
-              # do nothing
+            # do nothing
 
           end
-
         end
 
-        (keys.empty?)? nil : keys
-
+        keys.empty? ? nil : keys
       end
-
     end
-
   end
-
 end