imapcli 1.0.5 → 2.0.0

data/lib/imapcli/cli.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module Imapcli
+  class Cli # rubocop:disable Metrics/ClassLength,Style/Documentation
+    extend GLI::App
+
+    program_desc 'Command-line interface for IMAP servers'
+
+    version Imapcli::VERSION
+
+    subcommand_option_handling :normal
+    arguments :strict
+    sort_help :manually
+    wrap_help_text :tty_only
+
+    desc 'Domain name (FQDN) of the IMAP server'
+    default_value ENV.fetch('IMAP_SERVER', nil)
+    arg_name 'imap.example.com'
+    flag %i[s server]
+
+    desc 'Log-in name (username/email)'
+    default_value ENV.fetch('IMAP_USER', nil)
+    arg_name 'user'
+    flag %i[u user]
+
+    desc 'Log-in password'
+    # default_value ENV['IMAP_PASS']
+    arg_name 'password'
+    flag %i[p password]
+
+    desc 'Prompt for password'
+    switch %i[P prompt], negatable: false
+
+    desc 'Verbose output (e.g., response values from Rubys Net::IMAP)'
+    switch %i[v verbose], negatable: false
+
+    desc 'Tests if the server is available and log-in succeeds with the credentials'
+    command :check do |c|
+      c.action do |_global_options, _options, _args|
+        @command.check ? @prompt.ok('login successful') : @prompt.error('login failed')
+      end
+    end
+
+    desc 'Prints information about the server'
+    command :info do |c|
+      c.action do |_global_options, _options, _args|
+        @command.info.each { |line| @prompt.say line }
+      end
+    end
+
+    desc 'Lists mailboxes (folders)'
+    command :list do |c|
+      c.action do |_global_options, _options, _args|
+        @command.list.each { |line| @prompt.say line }
+      end
+    end
+
+    desc 'Collects mailbox statistics'
+    arg_name :mailbox, optional: true, multiple: true
+    command :stats do |c| # rubocop:disable Metrics/BlockLength
+      c.switch %i[r recurse],
+        desc: 'Recurse into sub mailboxes',
+        negatable: false
+      c.switch %i[R no_recurse],
+        desc: 'Do not recurse into sub mailboxes',
+        negatable: false
+      c.switch %i[H human],
+        desc: 'Convert byte counts to human-friendly formats',
+        negatable: false
+      c.flag %i[o sort],
+        desc: 'Ordered (sorted) results',
+        arg_name: 'sort_property',
+        must_match: %w[count total_size median_size min_size q1_size q3_size max_size],
+        default: 'total_size'
+      c.switch %i[reverse], desc: 'Reverse sort order (largest first)', negatable: false
+      c.switch [:csv], desc: 'Output comma-separated values (CSV)'
+
+      c.action do |_global_options, options, args| # rubocop:disable Metrics/BlockLength
+        raise unless @validator.stats_options_valid?(options, args)
+
+        progress_bar = nil
+
+        head = ['Mailbox', 'Count', 'Total size', 'Min', 'Q1', 'Median', 'Q3', 'Max']
+        body = @command.stats(args, options) do |n|
+          if progress_bar
+            progress_bar.advance
+          else
+            @prompt.say "info: collecting stats for #{n} folders" if n > 1
+            progress_bar = TTY::ProgressBar.new(
+              'collecting stats... :current/:total (:percent, :eta remaining)',
+              total: n, clear: true
+            )
+          end
+        end
+        formatted_body = body.map do |row|
+          row[0..1] + row[2..].map { |cell| format_bytes(cell, options[:human]) }
+        end
+
+        if options[:csv]
+          unless options[:human]
+            @prompt.warn 'notice: BREAKING CHANGE IN VERSION 2: messages sizes in CSV output are now given in bytes, not kiB'
+          end
+          @prompt.say head.to_csv
+          last_mailbox_line = body.length == 1 ? -1 : -2 # skip grand total if present
+          formatted_body[0..last_mailbox_line].each { |row| @prompt.say row.to_csv }
+        else
+          formatted_body = formatted_body.insert(0, :separator).insert(-2, :separator)
+
+          if options[:human]
+            @prompt.say "notice: -H/--human flag present, message sizes are given with SI prefixes"
+          else
+            @prompt.say "notice: message sizes are given in bytes"
+          end
+
+          table = TTY::Table.new(head, formatted_body)
+          rendered_table = table.render(:unicode) do |renderer|
+            renderer.alignments =  [:left] + Array.new(7, :right)
+            renderer.border.style = :blue
+          end
+          @prompt.say rendered_table
+
+          # If any unknown mailboxes were requested, print an informative footer
+          if body.any? { |line| line[0].start_with? Imapcli::Command.unknown_mailbox_prefix }
+            @prompt.warn "#{Imapcli::Command.unknown_mailbox_prefix}unknown mailbox"
+          end
+        end
+      end
+    end
+
+    def self.format_bytes(bytes, human = false)
+      human ? ActiveSupport::NumberHelper.number_to_human_size(bytes) : bytes
+    end
+
+    pre do |global, _command, _options, _args|
+      @prompt = TTY::Prompt.new
+      @validator = Imapcli::OptionValidator.new
+      raise unless @validator.global_options_valid?(global)
+
+      global[:p] = @prompt.mask 'Enter password:' if global[:P]
+      global[:p] ||= ENV.fetch('IMAP_PASS', nil)
+
+      client = Imapcli::Client.new(global[:s], global[:u], global[:p])
+      @prompt.say "server: #{global[:s]}"
+      @prompt.say "user: #{global[:u]}"
+      raise 'invalid server name' unless client.server_valid?
+      raise 'invalid user name' unless client.user_valid?
+
+      @prompt.warn 'warning: no password was provided (missing -p/-P option)' unless global[:p]
+      raise 'unable to connect to server' unless client.connection
+
+      @command = Imapcli::Command.new(client)
+
+      true
+    end
+
+    post do |global, _command, _options, _args|
+      @client&.logout
+      if global[:v]
+        @prompt.say "\n>>> --verbose switch on, listing server responses <<<"
+        @client.responses.each do |response|
+          @prompt.say response
+        end
+      end
+    end
+
+    on_error do |exception|
+      @client&.logout
+      if @validator&.errors&.any?
+        @validator.errors.each { |error| @prompt.error error }
+      else
+        @prompt&.error "error: #{exception}"
+      end
+      @prompt.nil? # if we do not have a prompt yet, let GLI handle the exception
+    end
+
+    def print_warnings
+      @validator.warnings.each { |warning| @prompt.warn warning }
+    end
+  end
+end

data/lib/imapcli/client.rb

@@ -1,10 +1,8 @@
+# frozen_string_literal: true
+
 module Imapcli
   # Wrapper for Net::IMAP
-  class Client
-    require 'net/imap'
-    require 'filesize'
-    require 'descriptive_statistics'
-
+  class Client # rubocop:disable Metrics/ClassLength
     attr_accessor :port, :user, :pass
     attr_reader :responses
 
@@ -16,14 +14,14 @@ module Imapcli
     ## +pass+ is the password to log into the server.
     def initialize(server_with_optional_port, user, pass)
       @port = 993 # default
-      self.server, @user, @pass = server_with_optional_port, user, pass
+      self.server = server_with_optional_port
+      @user = user
+      @pass = pass
       clear_log
     end
 
     # Attribute reader for the server domain name
-    def server
-      @server
-    end
+    attr_reader :server
 
     # Attribute writer for the server domain name; a port may be appended with
     # a colon.
@@ -44,13 +42,13 @@ module Imapcli
     # Note that a propery regex for an FQDN is hard to achieve.
     # See https://stackoverflow.com/a/106223/270712 and elsewhere.
     def server_valid?
-      @server.match? '^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-]*[A-Za-z0-9])$'
+      @server.match? '^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-]*[A-Za-z0-9])$' # rubocop:disable Layout/LineLength
     end
 
     # Perform *very* basic sanity check on user name
     #
     def user_valid?
-      @user&.length > 0
+      @user&.length&.> 0
     end
 
     # Returns true if both server and user name are valid.
@@ -81,17 +79,18 @@ module Imapcli
     # credentials).
     def login
       raise('no connection to a server') unless connection
+
       begin
         response_ok? connection.login(@user, @pass)
-      rescue Net::IMAP::NoResponseError => error
-        log_error error
+      rescue Net::IMAP::NoResponseError => e
+        log_error e
       end
     end
 
     # Logs out of the server.
     def logout
       # access instance variable to avoid creating a new connection
-      @connection.logout if @connection
+      @connection&.logout
     end
 
     # Returns the server's greeting (which may reveal the server software name
@@ -118,12 +117,12 @@ module Imapcli
     # If the server +supports_quota+, returns an array containing the current
     # usage (in kiB), the total quota (in kiB), and the percent usage.
     def quota
-      if supports_quota
-        @quota ||= begin
-          info = query_server { @connection.getquotaroot('INBOX')[1] }
-          percent = info.quota.to_i > 0 ? info.usage.to_i.fdiv(info.quota.to_i) * 100 : nil
-          [ info.usage, info.quota, percent ]
-        end
+      return unless supports_quota
+
+      @quota ||= begin
+        info = query_server { @connection.getquotaroot('INBOX')[1] }
+        percent = info.quota.to_i.positive? ? info.usage.to_i.fdiv(info.quota.to_i) * 100 : nil
+        [info.usage, info.quota, percent]
       end
     end
 
@@ -146,17 +145,17 @@ module Imapcli
     # * :q3: Third quartile of messages sizes.
     # * :max: Size of largest message.
     def message_sizes(mailbox)
-      # Could use the EXAMINE command to get the number of messages in a mailbox,
-      # but we need to retrieve an array of message indexes anyway (to compute
-      # the total mailbox size), so we can save one roundtrip to the server.
-      # query_server { connection.examine(mailbox) }
-      # total = connection.responses['EXISTS'][0]
-      # unseen = query_server { connection.search('UNSEEN') }.length
       messages = messages(mailbox)
-      if messages.length > 0
-        query_server { connection.fetch(messages, 'RFC822.SIZE').map { |f| f.attr['RFC822.SIZE'] } }
-      else
+      if messages.empty?
         []
+      else
+        query_server do
+          messages.each_slice(1000).map do |some_messages|
+            connection.fetch(some_messages, 'RFC822.SIZE').map do |f|
+              f.attr['RFC822.SIZE']
+            end
+          end.flatten
+        end
       end
     end
 
@@ -204,12 +203,13 @@ module Imapcli
     # error if not. The code that queries the server must be contained in the
     # +block+, and the +block+'s return value is returned by this function.
     # The +connection+'s responses are logged.
-    def query_server(&block)
+    def query_server
       raise('no connection to a server') unless connection
+
       result = yield
       @log << connection.responses
       result
     end
 
-  end # class Client
-end # module Imapcli
+  end
+end

data/lib/imapcli/command.rb

@@ -1,10 +1,13 @@
+# frozen_string_literal: true
+
 module Imapcli
   # Provides entry points for Imapcli.
   #
   # Most of the methods in this class return
-  class Command
+  class Command # rubocop:disable Metrics/ClassLength
     def initialize(client)
-      raise ArgumentError, 'Imapcli::Client is required' unless client && client.is_a?(Imapcli::Client)
+      raise ArgumentError, 'Imapcli::Client is required' unless client.is_a?(Imapcli::Client)
+
       @client = client
     end
 
@@ -16,18 +19,18 @@ module Imapcli
     end
 
     # Collects basic information about the server.
-    def info
+    def info # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
       perform do
         output = []
         output << "greeting: #{@client.greeting}"
         output << "capability: #{@client.capability.join(' ')}"
         output << "hierarchy separator: #{@client.separator}"
         if @client.supports_quota
-          usage = Filesize.from(@client.quota[0] + ' kB').pretty
-          available = Filesize.from(@client.quota[1] + ' kB').pretty
+          usage = ActiveSupport::NumberHelper.number_to_human_size(@client.quota[0])
+          available = ActiveSupport::NumberHelper.number_to_human_size(@client.quota[1])
           output << "quota: #{usage} used, #{available} available (#{@client.quota[2].round(1)}%)"
         else
-          output << "quota: IMAP QUOTA extension not supported by this server"
+          output << 'quota: IMAP QUOTA extension not supported by this server'
         end
       end
     end
@@ -43,16 +46,16 @@ module Imapcli
     #
     # If a block is given, it is called with the current mailbox count and the
     # total mailbox count so that current progress can be computed.
-    def stats(mailbox_names = [], options = {})
+    def stats(mailbox_names = [], options = {}) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
       mailbox_names = [mailbox_names] unless mailbox_names.is_a? Array
       perform do
-        output = []
         # Map the command line arguments to Imapcli::Mailbox objects
         mailboxes = find_mailboxes(mailbox_names)
         list = mailboxes.inject([]) do |ary, mailbox|
           ary + mailbox.to_list(determine_max_level(mailbox, options))
         end
-        raise 'mailbox not found' unless list.count > 0
+        raise 'mailbox not found' unless list.count.positive?
+
         current_count = 0
         yield list.length if block_given?
         total_stats = Stats.new
@@ -65,10 +68,9 @@ module Imapcli
             yield current_count if block_given?
           end
         end
-        sorted_list(list, options).each do |mailbox|
-          output << stats_to_table(mailbox.full_name, mailbox.stats)
+        output = sorted_list(list, options).map do |mailbox|
+          stats_to_table(mailbox.full_name, mailbox.stats)
         end
-        # output << Array.new(8, '======')
         output << stats_to_table('Total', total_stats) if list.length > 1
         output
       end
@@ -81,15 +83,13 @@ module Imapcli
     private
 
     def perform
-      if @client.login
-        yield
-      else
-        raise 'unable to log into server'
-      end
+      raise 'unable to log into server' unless @client.login
+
+      yield
     end
 
     def traverse_mailbox_tree(mailbox, depth = 0)
-      this = mailbox.is_imap_mailbox? ? ["#{'  ' * [depth - 1, 0].max}- #{mailbox.name}"] : []
+      this = mailbox.imap_mailbox? ? ["#{'  ' * [depth - 1, 0].max}- #{mailbox.name}"] : []
       mailbox.children.inject(this) do |ary, child|
         ary + traverse_mailbox_tree(child, depth + 1)
       end
@@ -104,15 +104,15 @@ module Imapcli
         stats.quartile_1_size,
         stats.median_size,
         stats.quartile_3_size,
-        stats.max_size
+        stats.max_size,
       ]
     end
 
     # Finds and returns mailboxes based on mailbox names.
     def find_mailboxes(names)
-      if names && names.length > 0
+      if names&.length&.positive?
         Imapcli::Mailbox.consolidate(
-          names.map { |name| @client.find_mailbox(name) }.compact
+          names.filter_map { |name| @client.find_mailbox(name) }
         )
       else
         [@client.mailbox_root]
@@ -130,7 +130,7 @@ module Imapcli
     # Options:
     # * +:depth+ maximum depth of recursion
     def determine_max_level(mailbox, options = {})
-      if mailbox.is_root?
+      if mailbox.root?
         options[:depth]
       else
         depth = options[:depth] || 0
@@ -138,28 +138,28 @@ module Imapcli
       end
     end
 
-    def sorted_list(list, options = {})
-      sorted = case options[:sort]
-      when :count
-        list.sort_by { |mailbox| mailbox.stats.count }
-      when :total_size
-        list.sort_by { |mailbox| mailbox.stats.total_size }
-      when :median_size
-        list.sort_by { |mailbox| mailbox.stats.median_size }
-      when :min_size
-        list.sort_by { |mailbox| mailbox.stats.min_size }
-      when :q1
-        list.sort_by { |mailbox| mailbox.stats.q1 }
-      when :q3
-        list.sort_by { |mailbox| mailbox.stats.q3 }
-      when :max_size
-        list.sort_by { |mailbox| mailbox.stats.max_size }
-      when nil
-        list
-      else
-        raise "invalid sort option: #{options[:sort]}"
-      end
-      options[:sort_order] == :desc ? sorted.reverse : sorted
+    def sorted_list(list, options = {}) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+      sorted = case options[:sort]&.to_sym
+               when :count
+                 list.sort_by { |mailbox| mailbox.stats.count }
+               when :total_size
+                 list.sort_by { |mailbox| mailbox.stats.total_size }
+               when :median_size
+                 list.sort_by { |mailbox| mailbox.stats.median_size }
+               when :min_size
+                 list.sort_by { |mailbox| mailbox.stats.min_size }
+               when :q1_size
+                 list.sort_by { |mailbox| mailbox.stats.q1 }
+               when :q3_size
+                 list.sort_by { |mailbox| mailbox.stats.q3 }
+               when :max_size
+                 list.sort_by { |mailbox| mailbox.stats.max_size }
+               when nil
+                 list
+               else
+                 raise "invalid sort option: #{options[:sort]}"
+               end
+      options[:reverse] ? sorted.reverse : sorted
     end
 
   end

data/lib/imapcli/mailbox.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module Imapcli
   # In IMAP speak, a mailbox is what one would commonly call a 'folder'
-  class Mailbox
+  class Mailbox # rubocop:disable Metrics/ClassLength
     attr_accessor :options
-    attr_reader :level, :children, :imap_mailbox_list, :name, :stats
+    attr_reader :level, :imap_mailbox_list, :name, :stats
 
     # Creates a new root Mailbox object and optionally adds sub mailboxes from
     # an array of Net::IMAP::MailboxList items.
@@ -19,11 +21,11 @@ module Imapcli
 
     # Determines if this mailbox represents a dedicated IMAP mailbox with an
     # associated Net::IMAP::MailboxList structure.
-    def is_imap_mailbox?
-      not imap_mailbox_list.nil?
+    def imap_mailbox?
+      !imap_mailbox_list.nil?
     end
 
-    def is_root?
+    def root?
       name.respond_to?(:empty?) ? !!name.empty? : !name
     end
 
@@ -32,17 +34,17 @@ module Imapcli
     # The result includes the current mailbox.
     def count(max_level = nil)
       sum = 1
-      if max_level.nil? || level < max_level
-        @children.values.inject(sum) do |count, child|
-          count + child.count(max_level)
-        end
+      return unless max_level.nil? || level < max_level
+
+      @children.values.inject(sum) do |count, child|
+        count + child.count(max_level)
       end
     end
 
     # Determines the maximum level in the mailbox tree
-    def get_max_level
-      if has_children?
-        @children.values.map { |child| child.get_max_level }.max
+    def max_level
+      if children?
+        @children.values.map(&:max_level).max
       else
         level
       end
@@ -52,8 +54,8 @@ module Imapcli
       imap_mailbox_list&.name
     end
 
-    def has_children?
-      @children.length > 0
+    def children?
+      !@children.empty?
     end
 
     def children
@@ -67,7 +69,8 @@ module Imapcli
 
     # Adds a sub mailbox designated by the +name+ of a Net::IMAP::MailboxList.
     def add_mailbox(imap_mailbox_list)
-      return unless imap_mailbox_list&.name&.length > 0
+      return unless imap_mailbox_list&.name&.length&.> 0
+
       recursive_add(0, imap_mailbox_list, imap_mailbox_list.name)
     end
 
@@ -82,13 +85,13 @@ module Imapcli
     #
     # Returns nil of none exists with the given name.
     # Name must be relative to the current mailbox.
-    def find_sub_mailbox(relative_name, delimiter)
+    def find_sub_mailbox(relative_name, delimiter) # rubocop:disable Metrics/MethodLength
       if relative_name
         sub_mailbox_name, subs_subs = relative_name.split(delimiter, 2)
         key = normalize_key(sub_mailbox_name, level)
-        if sub_mailbox = @children[key]
+        if (sub_mailbox = @children[key])
           sub_mailbox.find_sub_mailbox(subs_subs, delimiter)
-        else
+        else # rubocop:disable Style/EmptyElse
           nil # no matching sub mailbox found, stop searching the tree
         end
       else
@@ -103,16 +106,15 @@ module Imapcli
     #
     # If a block is given, it is called with the Imapcli::Stats object for this
     # mailbox.
-    def collect_stats(client, max_level = nil)
+    def collect_stats(client, max_level = nil, &block)
       return if @stats
-      if full_name # proceed only if this is a mailbox of its own
-        @stats = Stats.new(client.message_sizes(full_name))
-      end
+
+      @stats = Stats.new(client.message_sizes(full_name)) if full_name # proceed only if this is a mailbox of its own
       yield @stats if block_given?
-      if max_level.nil? || level < max_level
-        @children.values.each do |child|
-          child.collect_stats(client, max_level) { |child_stats| yield child_stats}
-        end
+      return unless max_level.nil? || level < max_level
+
+      @children.each_value do |child|
+        child.collect_stats(client, max_level, &block)
       end
     end
 
@@ -121,11 +123,11 @@ module Imapcli
     # Mailbox objects that do not represent IMAP mailboxes (such as the root
     # mailbox) are not included.
     def to_list(max_level = nil)
-      me = is_imap_mailbox? ? [self] : []
+      me = imap_mailbox? ? [self] : []
       if max_level.nil? || level < max_level
         @children.values.inject(me) do |ary, child|
           ary + child.to_list(max_level)
-        end.sort_by { |e| e.full_name }
+        end.sort_by(&:full_name)
       else
         me
       end
@@ -143,21 +145,15 @@ module Imapcli
 
     protected
 
-    def level=(level)
-      @level = level
-    end
-
-    def name=(name)
-      @name = name
-    end
+    attr_writer :level, :name
 
-    def recursive_add(level, imap_mailbox_list, relative_name = nil)
+    def recursive_add(level, imap_mailbox_list, relative_name = nil) # rubocop:disable Metrics/MethodLength
       delimiter = options[:delimiter] || imap_mailbox_list.delim
       if relative_name
         sub_mailbox_name, subs_subs = relative_name.split(delimiter, 2)
         key = normalize_key(sub_mailbox_name, level)
         # Create a new mailbox if there does not exist one by the name
-        unless sub_mailbox = @children[key]
+        unless (sub_mailbox = @children[key])
           sub_mailbox = Mailbox.new
           sub_mailbox.level = level
           sub_mailbox.name = sub_mailbox_name
@@ -172,7 +168,7 @@ module Imapcli
 
     # Normalizes a mailbox name for use as the key in the children hash.
     def normalize_key(key, level)
-      if options[:case_insensitive] || (level == 0 && key.upcase == 'INBOX')
+      if options[:case_insensitive] || (level.zero? && key.upcase == 'INBOX')
         key.upcase
       else
         key

data/lib/imapcli/option_validator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Imapcli
   # Utility class to validate user options
   #
@@ -17,9 +19,7 @@ module Imapcli
       if global_options[:u].nil? || global_options[:u].empty?
         @errors << 'missing user name (use -u option or set IMAP_USER environment variable)'
       end
-      if global_options[:P] && global_options[:p]
-        @errors << '-p and -P options do not agree'
-      end
+      @errors << '-p and -P options do not agree' if global_options[:P] && global_options[:p]
 
       pass?
     end
@@ -27,7 +27,7 @@ module Imapcli
     # Validates options for the stats command.
     #
     # @return [true false] indicating success or failure; warnings can be accessed as attribute
-    def stats_options_valid?(options, args)
+    def stats_options_valid?(options, args) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
       @options = {}
       raise 'incompatible options -r/--recurse and -R/--no_recurse' if options[:r] && options[:R]
 
@@ -46,7 +46,7 @@ module Imapcli
       end
 
       if options[:sort]
-        available_sort_options = %w(count total_size min_size q1 median_size q3 max_size)
+        available_sort_options = %w[count total_size min_size q1 median_size q3 max_size]
         if available_sort_options.include? options[:sort].downcase
           @options[:sort] = options[:sort].to_sym
         else
@@ -63,7 +63,7 @@ module Imapcli
     end
 
     def warnings?
-      @warnings.count > 0
+      @warnings.count.positive?
     end
 
   end