imapcli 1.0.5 → 2.0.0

data/lib/imapcli/stats.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Imapcli
   # Handles mailbox statistics.
   #
@@ -11,6 +13,7 @@ module Imapcli
     # Adds other statistics.
     def add(other_stats)
       return unless other_stats
+
       @message_sizes += other_stats.message_sizes
       invalidate
     end
@@ -20,27 +23,27 @@ module Imapcli
     end
 
     def total_size
-      @total_size ||= convert_bytes(@message_sizes.sum)
+      @total_size ||= @message_sizes.sum
     end
 
     def min_size
-      @min ||= convert_bytes(@message_sizes.min)
+      @min_size ||= @message_sizes.min
     end
 
     def quartile_1_size
-      @q1 ||= convert_bytes(@message_sizes.percentile(25))
+      @quartile_1_size ||= @message_sizes.percentile(25)
     end
 
     def median_size
-      @median ||= convert_bytes(@message_sizes.median)
+      @median_size ||= @message_sizes.median
     end
 
     def quartile_3_size
-      @q3 ||= convert_bytes(@message_sizes.percentile(75))
+      @quartile_3_size ||= @message_sizes.percentile(75)
     end
 
     def max_size
-      @max ||= convert_bytes(@message_sizes.max)
+      @max_size ||= @message_sizes.max
     end
 
     protected
@@ -49,11 +52,6 @@ module Imapcli
 
     private
 
-    # Converts a number of bytes to kiB.
-    def convert_bytes(bytes)
-      bytes.fdiv(1024).round if bytes
-    end
-
     def invalidate
       @count, @total_size, @min, @max, @q1, @q3, @median = nil # sets others to nil too
     end

data/lib/imapcli/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Imapcli
-  VERSION = '1.0.5'
+  VERSION = '2.0.0'
 end

data/lib/imapcli.rb

@@ -1,6 +1,20 @@
-require 'imapcli/version.rb'
-require 'imapcli/command.rb'
-require 'imapcli/client.rb'
-require 'imapcli/mailbox.rb'
-require 'imapcli/stats.rb'
-require 'imapcli/option_validator.rb'
+# frozen_string_literal: true
+
+require 'active_support'
+require 'csv'
+require 'descriptive_statistics'
+require 'dotenv'
+require 'gli'
+require 'net/imap'
+require 'tty-progressbar'
+require 'tty-prompt'
+require 'tty-table'
+require 'zeitwerk'
+
+# load zeitwerk
+Zeitwerk::Loader.for_gem.tap do |loader|
+  loader.setup
+end
+
+module Imapcli # rubocop:disable Style/Documentation
+end

data/spec/lib/imapcli/client_spec.rb

@@ -1,69 +1,81 @@
-require 'imapcli'
-require 'dotenv'
+# frozen_string_literal: true
+
+require 'spec_helper'
 
 RSpec.describe Imapcli::Client do
 
   context 'with mock credentials for a nonexistent server' do
-    let(:client) { Imapcli::Client.new('imap.example.com', 'username', 'password') }
+    let(:client) { described_class.new('imap.example.com', 'username', 'password') }
+
     it 'knows when a server name is invalid' do
       client.server = 'i n v a l i d'
-      expect(client.server_valid?).to eq false
+      expect(client.server_valid?).to be false
     end
+
     it 'knows when a server name is valid' do
       client.server = 'imap.gmail.com'
-      expect(client.server_valid?).to eq true
+      expect(client.server_valid?).to be true
     end
+
     it 'knows when a user name is invalid' do
       client.user = ''
-      expect(client.user_valid?).to eq false
+      expect(client.user_valid?).to be false
     end
+
     it 'knows when a user name is valid' do
       client.user = 'bovender@example.com'
-      expect(client.user_valid?).to eq true
+      expect(client.user_valid?).to be true
     end
+
     it 'uses port 993 by default' do
       expect(client.port).to eq 993
     end
+
     it 'extracts a port from the server info' do
       client.server = 'imap.example.com:143'
       expect(client.port).to eq 143
     end
+
     it 'extracts a server from the server string when a port is appended' do
       client.server = 'imap.example.com:143'
       expect(client.server).to eq 'imap.example.com'
     end
   end
 
-  context 'with valid credentials for an actual server', network: true do
-    before :all do
-      Dotenv.load
-    end
+  context 'with valid credentials for an actual server', :network do
+    before { Dotenv.load }
 
-    let(:client) { Imapcli::Client.new(ENV['IMAP_SERVER'], ENV['IMAP_USER'], ENV['IMAP_PASS']) }
+    let(:client) do
+      described_class.new(ENV.fetch('IMAP_SERVER', nil), ENV.fetch('IMAP_USER', nil), ENV.fetch('IMAP_PASS', nil))
+    end
 
     it 'the IMAP_SERVER variable must be set' do
-      expect(ENV['IMAP_SERVER']).to_not eq(nil)
+      expect(ENV.fetch('IMAP_SERVER', nil)).to_not be_nil
     end
+
     it 'the IMAP_USER variable must be set' do
-      expect(ENV['IMAP_USER']).to_not eq(nil)
+      expect(ENV.fetch('IMAP_USER', nil)).to_not be_nil
     end
+
     it 'the IMAP_PASS variable must be set' do
-      expect(ENV['IMAP_PASS']).to_not eq(nil)
+      expect(ENV.fetch('IMAP_PASS', nil)).to_not be_nil
     end
+
     it 'successfully logs in to the server' do
-      expect(client.login).to eq true
+      expect(client.login).to be true
     end
   end
 
-  context 'with invalid credentials for an actual server', network: true do
-    before :all do
-      Dotenv.load
-    end
+  context 'with invalid credentials for an actual server', :network do
+    before { Dotenv.load }
 
-    let(:client) { Imapcli::Client.new(ENV['IMAP_SERVER'], ENV['IMAP_USER'], "#{ENV['IMAP_PASS']}invalid") }
+    let(:client) do
+      described_class.new(ENV.fetch('IMAP_SERVER', nil), ENV.fetch('IMAP_USER', nil),
+                          "#{ENV.fetch('IMAP_PASS', nil)}invalid")
+    end
 
     it 'cannot log in to the server' do
-      expect(client.login).to eq false
+      expect(client.login).to be false
     end
   end
 

data/spec/lib/imapcli/command_spec.rb

@@ -1,10 +1,12 @@
-require 'imapcli'
+# frozen_string_literal: true
+
+require 'spec_helper'
 
 RSpec.describe Imapcli::Command do
 
   context 'without a client' do
     it 'cannot be instantiated' do
-      expect { Imapcli::Command.new('foobar') }.to raise_error(ArgumentError)
+      expect { described_class.new('foobar') }.to raise_error(ArgumentError)
     end
   end
 
@@ -14,32 +16,29 @@ RSpec.describe Imapcli::Command do
       allow(client).to receive(:login).and_return(true)
       client
     end
-    let(:command) { Imapcli::Command.new(client) }
+    let(:command) { described_class.new(client) }
     let(:mailbox_root) do
       Imapcli::Mailbox.new([
-        Net::IMAP::MailboxList.new(nil, '/', 'Inbox'),
-        Net::IMAP::MailboxList.new(nil, '/', 'Inbox/Foo'),
-        Net::IMAP::MailboxList.new(nil, '/', 'Inbox/Foo/Sub'),
-        Net::IMAP::MailboxList.new(nil, '/', 'Inbox/Bar'),
-        Net::IMAP::MailboxList.new(nil, '/', 'Inbox/Bar/Sub'),
-        Net::IMAP::MailboxList.new(nil, '/', 'Inbox/Bar/Sub/Subsub'),
-      ])
+                             Net::IMAP::MailboxList.new(nil, '/', 'Inbox'),
+                             Net::IMAP::MailboxList.new(nil, '/', 'Inbox/Foo'),
+                             Net::IMAP::MailboxList.new(nil, '/', 'Inbox/Foo/Sub'),
+                             Net::IMAP::MailboxList.new(nil, '/', 'Inbox/Bar'),
+                             Net::IMAP::MailboxList.new(nil, '/', 'Inbox/Bar/Sub'),
+                             Net::IMAP::MailboxList.new(nil, '/', 'Inbox/Bar/Sub/Subsub'),
+                           ])
     end
 
     it 'can be instantiated' do
-      expect { Imapcli::Command.new(client) }.to_not raise_error
+      expect { described_class.new(client) }.to_not raise_error
     end
 
     it 'logs in' do
-      expect(command.check).to eq true
+      expect(command.check).to be true
     end
 
     it 'collects information about the server' do
-      allow(client).to receive(:greeting).and_return 'hello'
-      allow(client).to receive(:capability).and_return ['lots', 'of', 'capabilities']
-      allow(client).to receive(:separator).and_return '/'
-      allow(client).to receive(:supports_quota).and_return true
-      allow(client).to receive(:quota).and_return [ '1024', '2048', 50.00 ]
+      allow(client).to receive_messages(greeting: 'hello', capability: %w[lots of capabilities], separator: '/',
+                                        supports_quota: true, quota: ['1024', '2048', 50.00])
       output = command.info
       expect(output).to be_a Array
       expect(output[0]).to eq 'greeting: hello'
@@ -52,10 +51,9 @@ RSpec.describe Imapcli::Command do
       expect(output[0]).to eq '- Inbox'
     end
 
-    context 'collecting statistics' do
-      before :each do
-        allow(client).to receive(:mailbox_root).and_return mailbox_root
-        allow(client).to receive(:separator).and_return '/'
+    context 'when collecting statistics' do
+      before do
+        allow(client).to receive_messages(mailbox_root: mailbox_root, separator: '/')
         allow(client).to receive(:message_sizes) do |mailbox|
           case mailbox
           when 'Inbox'
@@ -67,8 +65,8 @@ RSpec.describe Imapcli::Command do
           when 'Inbox/Bar'
             (1..2).map { |i| 1024 * i }
           when 'Inbox/Bar/Sub'
-            [ 1, 1024 * 20 ]
-          when 'Inbox/Bar/Sub/Subsub'
+            [1, 1024 * 20]
+          when 'Inbox/Bar/Sub/Subsub' # rubocop:disable Lint/DuplicateBranch
             (1..4).map { |i| 1024 * i }
           else
             [1024, 2048, 4096, 8192]
@@ -77,42 +75,48 @@ RSpec.describe Imapcli::Command do
       end
 
       it 'for all folders' do
-        output = command.stats()
+        output = command.stats
         expect(output).to be_a Array
-        expect(output.length).to eq 8 # including divider and summary line
+        expect(output.length).to eq 7
         expect(output[0][0]).to eq 'Inbox'
         expect(output[0][1]).to eq 4
       end
+
       it 'for a given folder' do
         output = command.stats('Inbox/Foo')
         expect(output).to be_a Array
-        expect(output.length).to eq 3 # including divider and summary line
+        expect(output.length).to eq 1
         expect(output[0][0]).to eq 'Inbox/Foo'
         expect(output[0][1]).to eq 8 # depends on message_sizes stub (see above)
       end
+
       it 'for a given folder and subfolders' do
         output = command.stats('Inbox/Foo', depth: -1)
         expect(output).to be_a Array
-        expect(output.length).to eq 4 # including divider and summary line
+        expect(output.length).to eq 3
         expect(output[1][0]).to eq 'Inbox/Foo/Sub'
       end
+
       it 'sorts by number of messages' do
-        output = command.stats('Inbox', depth: -1, sort: :count, sort_order: :desc)
+        output = command.stats('Inbox', depth: -1, sort: :count, reverse: true)
         expect(output).to be_a Array
         expect(output[0][0]).to eq 'Inbox/Foo/Sub'
       end
+
       it 'sorts by total message size' do
-        output = command.stats('Inbox', depth: -1, sort: :total_size, sort_order: :desc)
+        output = command.stats('Inbox', depth: -1, sort: :total_size, reverse: true)
         expect(output).to be_a Array
         expect(output[0][0]).to eq 'Inbox/Foo'
       end
+
       it 'sorts by largest message' do
-        output = command.stats('Inbox', depth: -1, sort: :max_size, sort_order: :desc)
+        output = command.stats('Inbox', depth: -1, sort: :max_size, reverse: true)
         expect(output).to be_a Array
         expect(output[0][0]).to eq 'Inbox/Bar/Sub'
       end
+
       it 'sorts by smallest message' do
-        output = command.stats('Inbox', depth: -1, sort: :min_size, sort_order: :desc)
+        output = command.stats('Inbox', depth: -1, sort: :min_size, reverse: true)
         expect(output).to be_a Array
         # binding.pry
         expect(output[0][0]).to eq 'Inbox/Foo'

data/spec/lib/imapcli/mailbox_spec.rb

@@ -1,41 +1,49 @@
-require 'imapcli'
-require 'net/imap'
+# frozen_string_literal: true
+
+require 'spec_helper'
 
 RSpec.describe Imapcli::Mailbox do
+
   let(:mailbox) do
-    Imapcli::Mailbox.new([
-      Net::IMAP::MailboxList.new(nil, '/', 'Inbox'),
-      Net::IMAP::MailboxList.new(nil, '/', 'Inbox/Foo'),
-      Net::IMAP::MailboxList.new(nil, '/', 'Inbox/Foo/Sub'),
-      Net::IMAP::MailboxList.new(nil, '/', 'Inbox/Bar'),
-      Net::IMAP::MailboxList.new(nil, '/', 'Inbox/Bar/Sub'),
-      Net::IMAP::MailboxList.new(nil, '/', 'Inbox/Bar/Sub/Subsub'),
-    ])
+    described_class.new([
+                          Net::IMAP::MailboxList.new(nil, '/', 'Inbox'),
+                          Net::IMAP::MailboxList.new(nil, '/', 'Inbox/Foo'),
+                          Net::IMAP::MailboxList.new(nil, '/', 'Inbox/Foo/Sub'),
+                          Net::IMAP::MailboxList.new(nil, '/', 'Inbox/Bar'),
+                          Net::IMAP::MailboxList.new(nil, '/', 'Inbox/Bar/Sub'),
+                          Net::IMAP::MailboxList.new(nil, '/', 'Inbox/Bar/Sub/Subsub'),
+                        ])
   end
+
   # it 'parses a mailbox list' do
   #   mailbox_list = Net::IMAP::MailboxList.new(attr: nil, delim: '/', name: 'Root/Subfolder')
   #   mailbox_root = Imapcli::MailboxTree.new(mailbox_list)
   #   expect(mailbox_root.tree.length).to eq 1
   # end
+
   it 'returns nil if a given sub mailbox does not exist' do
-    expect(mailbox.find_sub_mailbox('INBOX.does.not.exist', '.')).to eq nil
+    expect(mailbox.find_sub_mailbox('INBOX.does.not.exist', '.')).to be_nil
   end
+
   it 'adds and retrieves an existing sub mailbox' do
     name = 'Root/Subfolder/Subsubfolder'
     imap_mailbox_list = Net::IMAP::MailboxList.new(nil, '/', name)
-    mailbox = Imapcli::Mailbox.new
+    mailbox = described_class.new
     mailbox.add_mailbox(imap_mailbox_list)
     expect(mailbox.find_sub_mailbox(name, '/').imap_mailbox_list).to eq imap_mailbox_list
   end
+
   it 'counts the number of mailboxes' do
     expect(mailbox.count).to eq 7 # includes virtual root mailbox
   end
+
   it 'determines the maximum level in the subtree' do
-    expect(mailbox.get_max_level).to eq 3
+    expect(mailbox.max_level).to eq 3
   end
-  it 'converts a tree to a list' do
+
+  it 'converts a tree to a list' do # rubocop:disable RSpec/ExampleLength
     list = mailbox.to_list
-    list_names = list.map { |m| m.full_name }
+    list_names = list.map(&:full_name)
     expect(list_names).to eq [
       'Inbox',
       'Inbox/Bar',
@@ -45,34 +53,39 @@ RSpec.describe Imapcli::Mailbox do
       'Inbox/Foo/Sub',
     ]
   end
-  it 'converts a tree to a list up to a certain level' do
+
+  it 'converts a tree to a list up to a certain level' do # rubocop:disable RSpec/ExampleLength
     list = mailbox.to_list(1)
-    list_names = list.map { |m| m.full_name }
+    list_names = list.map(&:full_name)
     expect(list_names).to eq [
       'Inbox',
       'Inbox/Bar',
-      'Inbox/Foo'
+      'Inbox/Foo',
     ]
   end
 
-  context 'identification and consolidation' do
+  context 'with identification and consolidation' do
     let(:parent) { mailbox.find_sub_mailbox('Inbox', '/') }
     let(:child) { mailbox.find_sub_mailbox('Inbox/Bar/Sub/Subsub', '/') }
 
     it 'knows if it is contains another mailbox' do
-      expect(parent.contains? child).to eq true
+      expect(parent.contains?(child)).to be true
     end
+
     it 'knows if it is does not contain another mailbox' do
-      expect(child.contains? mailbox).to eq false
+      expect(child.contains?(mailbox)).to be false
     end
+
     # it 'consolidates several of the same mailboxes' do
     #  expect(Imapcli::Mailbox.consolidate([parent, parent])).to eq [ parent ]
     # end
+
     it 'consolidates several of the same mailbox' do
-     expect(Imapcli::Mailbox.consolidate([child, child])).to eq [ child ]
+      expect(described_class.consolidate([child, child])).to eq [child]
     end
+
     it 'consolidates several different mailboxes' do
-     expect(Imapcli::Mailbox.consolidate([child, parent])).to eq [ parent ]
+      expect(described_class.consolidate([child, parent])).to eq [parent]
     end
 
   end

data/spec/lib/imapcli/stats_spec.rb

@@ -1,41 +1,44 @@
-require 'imapcli'
+# frozen_string_literal: true
+
+require 'spec_helper'
 
 RSpec.describe Imapcli::Stats do
+
   let(:array) { (1..12).map { |i| i * 1024 } }
   let(:other_array) { (13..24).map { |i| i * 1024 } }
-  let(:stats) { Imapcli::Stats.new(array) }
-  let(:other_stats) { Imapcli::Stats.new(other_array) }
+  let(:stats) { described_class.new(array) }
+  let(:other_stats) { described_class.new(other_array) }
 
   it 'knows the number of items' do
     expect(stats.count).to eq 12
   end
 
   it 'computes the minimum' do
-    expect(stats.min_size).to eq 1
+    expect(stats.min_size).to eq 1 * 1024
   end
 
   it 'computes the maximum' do
-    expect(stats.max_size).to eq 12
+    expect(stats.max_size).to eq 12 * 1024
   end
 
   it 'computes the median' do
-    expect(stats.median_size).to eq 7 # response is rounded
+    expect(stats.median_size).to eq 6656
   end
 
   it 'computes the first quartile' do
-    expect(stats.quartile_1_size).to eq 4 # response is rounded
+    expect(stats.quartile_1_size).to eq 3840
   end
 
   it 'computes the third quartile' do
-    expect(stats.quartile_3_size).to eq 9 # response is rounded
+    expect(stats.quartile_3_size).to eq 9472
   end
 
   it 'adds nothing if other stats are nil' do
     expect { stats.add nil }.to_not raise_error
   end
 
-  context 'adding other stats' do
-    before :each do
+  context 'when adding other stats' do
+    before do
       stats.add other_stats
     end
 
@@ -44,25 +47,24 @@ RSpec.describe Imapcli::Stats do
     end
 
     it 'computes the minimum' do
-      expect(stats.min_size).to eq 1
+      expect(stats.min_size).to eq 1 * 1024
     end
 
     it 'computes the maximum' do
-      expect(stats.max_size).to eq 24
+      expect(stats.max_size).to eq 24 * 1024
     end
 
     it 'computes the median' do
-      expect(stats.median_size).to eq 13 # response is rounded
+      expect(stats.median_size).to eq 12800
     end
 
     it 'computes the first quartile' do
-      expect(stats.quartile_1_size).to eq 7 # response is rounded
+      expect(stats.quartile_1_size).to eq 6912
     end
 
     it 'computes the third quartile' do
-      expect(stats.quartile_3_size).to eq 18 # response is rounded
+      expect(stats.quartile_3_size).to eq 18688
     end
 
   end
-
 end

data/spec/spec_helper.rb

@@ -1,25 +1,25 @@
-# This file was generated by the `rspec --init` command. Conventionally, all
-# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
-# The generated `.rspec` file contains `--require spec_helper` which will cause
-# this file to always be loaded, without a need to explicitly require it in any
-# files.
-#
-# Given that it is always loaded, you are encouraged to keep this file as
-# light-weight as possible. Requiring heavyweight dependencies from this file
-# will add to the boot time of your test suite on EVERY test run, even for an
-# individual file that may not need all of that loaded. Instead, consider making
-# a separate helper file that requires the additional dependencies and performs
-# the additional setup, and require it from the spec files that actually need
-# it.
-#
-# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+# frozen_string_literal: true
+
+require 'simplecov'
+require 'rspec'
 require 'pry'
 
+# Start SimpleCov
+SimpleCov.start do
+  add_filter 'spec/'
+end
+
+# Configure RSpec
 RSpec.configure do |config|
-  # rspec-expectations config goes here. You can use an alternate
-  # assertion/expectation library such as wrong or the stdlib/minitest
-  # assertions if you prefer.
+  config.color = true
+  config.fail_fast = false
+
+  config.order = :random
+  Kernel.srand config.seed
+
   config.expect_with :rspec do |expectations|
+    expectations.syntax = :expect
+
     # This option will default to `true` in RSpec 4. It makes the `description`
     # and `failure_message` of custom matchers include text for helper methods
     # defined using `chain`, e.g.:
@@ -48,57 +48,9 @@ RSpec.configure do |config|
 
   config.filter_run_excluding network: true
 
-# The settings below are suggested to provide a good initial experience
-# with RSpec, but feel free to customize to your heart's content.
-=begin
-  # This allows you to limit a spec run to individual examples or groups
-  # you care about by tagging them with `:focus` metadata. When nothing
-  # is tagged with `:focus`, all examples get run. RSpec also provides
-  # aliases for `it`, `describe`, and `context` that include `:focus`
-  # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
-  config.filter_run_when_matching :focus
-
-  # Allows RSpec to persist some state between runs in order to support
-  # the `--only-failures` and `--next-failure` CLI options. We recommend
-  # you configure your source control system to ignore this file.
-  config.example_status_persistence_file_path = "spec/examples.txt"
-
-  # Limits the available syntax to the non-monkey patched syntax that is
-  # recommended. For more details, see:
-  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
-  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
-  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  # disable monkey patching
+  # see: https://relishapp.com/rspec/rspec-core/v/3-8/docs/configuration/zero-monkey-patching-mode
   config.disable_monkey_patching!
-
-  # This setting enables warnings. It's recommended, but in some cases may
-  # be too noisy due to issues in dependencies.
-  config.warnings = true
-
-  # Many RSpec users commonly either run the entire suite or an individual
-  # file, and it's useful to allow more verbose output when running an
-  # individual spec file.
-  if config.files_to_run.one?
-    # Use the documentation formatter for detailed output,
-    # unless a formatter has already been configured
-    # (e.g. via a command-line flag).
-    config.default_formatter = "doc"
-  end
-
-  # Print the 10 slowest examples and example groups at the
-  # end of the spec run, to help surface which specs are running
-  # particularly slow.
-  config.profile_examples = 10
-
-  # Run specs in random order to surface order dependencies. If you find an
-  # order dependency and want to debug it, you can fix the order by providing
-  # the seed, which is printed after each run.
-  #     --seed 1234
-  config.order = :random
-
-  # Seed global randomization in this process using the `--seed` CLI option.
-  # Setting this allows you to use `--seed` to deterministically reproduce
-  # test failures related to randomization by passing the same `--seed` value
-  # as the one that triggered the failure.
-  Kernel.srand config.seed
-=end
 end
+
+require 'imapcli'