imap-backup 1.2.2 → 1.2.3

data/spec/unit/serializer/base_spec.rb

@@ -1,19 +1,17 @@
-# encoding: utf-8
-
-require 'spec_helper'
+require "spec_helper"
 
 describe Imap::Backup::Serializer::Base do
-  context '#initialize' do
-    let(:stat) { double('File::Stat', :mode => 0345) }
+  context "#initialize" do
+    let(:stat) { double("File::Stat", mode: 0345) }
 
     before do
-      allow(File).to receive(:exist?).with('/base/path').and_return(true)
-      allow(File).to receive(:stat).with('/base/path').and_return(stat)
+      allow(File).to receive(:exist?).with("/base/path").and_return(true)
+      allow(File).to receive(:stat).with("/base/path").and_return(stat)
     end
 
-    it 'should fail if file permissions are to lax' do
+    it "should fail if file permissions are to lax" do
       expect do
-        described_class.new('/base/path', 'my_folder')
+        described_class.new("/base/path", "my_folder")
       end.to raise_error(RuntimeError, "Permissions on '/base/path' should be 0700, not 0345")
     end
   end

data/spec/unit/serializer/directory_spec.rb

@@ -1,11 +1,10 @@
-# encoding: utf-8
-require 'spec_helper'
+require "spec_helper"
 
 describe Imap::Backup::Serializer::Directory do
-  let(:stat) { double('File::Stat', :mode => 0700) }
-  let(:files) { ['00000123.json', '000001.json'] }
-  let(:base) { '/base/path' }
-  let(:folder) { '/base/path/my_folder' }
+  let(:stat) { double("File::Stat", mode: 0700) }
+  let(:files) { ["00000123.json", "000001.json"] }
+  let(:base) { "/base/path" }
+  let(:folder) { "/base/path/my_folder" }
   let(:folder_exists) { true }
 
   before do
@@ -16,37 +15,37 @@ describe Imap::Backup::Serializer::Directory do
     allow(File).to receive(:exist?).with(folder).and_return(folder_exists)
   end
 
-  subject { described_class.new(base, 'my_folder') }
+  subject { described_class.new(base, "my_folder") }
 
-  context '#uids' do
+  context "#uids" do
     before do
       allow(Dir).to receive(:open).with(folder).and_return(files)
     end
 
-    it 'returns the backed-up uids' do
+    it "returns the backed-up uids" do
       expect(subject.uids).to eq([1, 123])
     end
 
-    context 'if the directory does not exist' do
+    context "if the directory does not exist" do
       let(:folder_exists) { false }
 
-      it 'returns an empty array' do
+      it "returns an empty array" do
         expect(subject.uids).to eq([])
       end
     end
   end
 
-  context '#exist?' do
-    it 'checks if the file exists' do
+  context "#exist?" do
+    it "checks if the file exists" do
       allow(File).to receive(:exist?).with(%r{/base/path/my_folder/0+123.json}).and_return(true)
 
       expect(subject.exist?(123)).to be_truthy
     end
   end
 
-  context '#save' do
-    let(:message) { {'RFC822' => 'the body', 'other'  => 'xxx'} }
-    let(:file) { double('File', :write => nil) }
+  context "#save" do
+    let(:message) { {"RFC822" => "the body", "other" => "xxx"} }
+    let(:file) { double("File", write: nil) }
 
     before do
       allow(File).to receive(:exist?).with(%r{/base/path/my_folder/0+1234.json}).and_return(true)
@@ -55,13 +54,13 @@ describe Imap::Backup::Serializer::Directory do
       end
     end
 
-    it 'saves messages' do
-      subject.save('1234', message)
+    it "saves messages" do
+      subject.save("1234", message)
 
       expect(file).to have_received(:write).with(message.to_json)
     end
 
-    it 'sets file permissions' do
+    it "sets file permissions" do
       subject.save(1234, message)
 
       expect(FileUtils).to have_received(:chmod).with(0600, /0+1234.json$/)

data/spec/unit/serializer/mbox_spec.rb

@@ -1,13 +1,11 @@
-# encoding: utf-8
-
-require 'spec_helper'
+require "spec_helper"
 
 describe Imap::Backup::Serializer::Mbox do
-  let(:stat) { double('File::Stat', :mode => 0700) }
-  let(:base_path) { '/base/path' }
-  let(:mbox_pathname) { '/base/path/my/folder.mbox' }
+  let(:stat) { double("File::Stat", mode: 0700) }
+  let(:base_path) { "/base/path" }
+  let(:mbox_pathname) { "/base/path/my/folder.mbox" }
   let(:mbox_exists) { true }
-  let(:imap_pathname) { '/base/path/my/folder.imap' }
+  let(:imap_pathname) { "/base/path/my/folder.imap" }
   let(:imap_exists) { true }
 
   before do
@@ -18,96 +16,96 @@ describe Imap::Backup::Serializer::Mbox do
     allow(File).to receive(:exist?).with(imap_pathname).and_return(imap_exists)
   end
 
-  context '#initialize' do
-    it 'creates the containing directory' do
-      described_class.new(base_path, 'my/folder')
+  context "#initialize" do
+    it "creates the containing directory" do
+      described_class.new(base_path, "my/folder")
 
-      expect(Imap::Backup::Utils).to have_received(:make_folder).with(base_path, 'my', 0700)
+      expect(Imap::Backup::Utils).to have_received(:make_folder).with(base_path, "my", 0700)
     end
 
-    context 'mbox and imap files' do
+    context "mbox and imap files" do
       context "if mbox exists and imap doesn't" do
         let(:imap_exists) { false }
 
-        it 'fails' do
+        it "fails" do
           expect {
-            described_class.new(base_path, 'my/folder')
-          }.to raise_error(RuntimeError, '.imap file missing')
+            described_class.new(base_path, "my/folder")
+          }.to raise_error(RuntimeError, ".imap file missing")
         end
       end
 
       context "if imap exists and mbox doesn't" do
         let(:mbox_exists) { false }
 
-        it 'fails' do
+        it "fails" do
           expect {
-            described_class.new(base_path, 'my/folder')
-          }.to raise_error(RuntimeError, '.mbox file missing')
+            described_class.new(base_path, "my/folder")
+          }.to raise_error(RuntimeError, ".mbox file missing")
         end
       end
     end
   end
 
-  context 'instance methods' do
+  context "instance methods" do
     let(:ids) { %w(3 2 1) }
 
     before do
       allow(CSV).to receive(:foreach) { |&b| ids.each { |id| b.call [id] } }
     end
 
-    subject { described_class.new(base_path, 'my/folder') }
+    subject { described_class.new(base_path, "my/folder") }
 
-    context '#uids' do
-      it 'returns the backed-up uids as sorted integers' do
+    context "#uids" do
+      it "returns the backed-up uids as sorted integers" do
         expect(subject.uids).to eq(ids.map(&:to_i).sort)
       end
 
-      context 'if the mbox does not exist' do
+      context "if the mbox does not exist" do
         let(:mbox_exists) { false }
         let(:imap_exists) { false }
 
-        it 'returns an empty Array' do
+        it "returns an empty Array" do
           expect(subject.uids).to eq([])
         end
       end
     end
 
-    context '#save' do
-      let(:mbox_formatted_message) { 'message in mbox format' }
-      let(:message_uid) { '999' }
-      let(:message) { double('Email::Mboxrd::Message', :to_s => mbox_formatted_message) }
-      let(:mbox_file) { double('File - mbox', :write => nil, :close => nil) }
-      let(:imap_file) { double('File - imap', :write => nil, :close => nil) }
+    context "#save" do
+      let(:mbox_formatted_message) { "message in mbox format" }
+      let(:message_uid) { "999" }
+      let(:message) { double("Email::Mboxrd::Message", to_s: mbox_formatted_message) }
+      let(:mbox_file) { double("File - mbox", write: nil, close: nil) }
+      let(:imap_file) { double("File - imap", write: nil, close: nil) }
 
       before do
         allow(Email::Mboxrd::Message).to receive(:new).and_return(message)
-        allow(File).to receive(:open).with(mbox_pathname, 'ab').and_return(mbox_file)
-        allow(File).to receive(:open).with(imap_pathname, 'ab').and_return(imap_file)
+        allow(File).to receive(:open).with(mbox_pathname, "ab").and_return(mbox_file)
+        allow(File).to receive(:open).with(imap_pathname, "ab").and_return(imap_file)
       end
 
-      it 'saves the message to the mbox' do
+      it "saves the message to the mbox" do
         subject.save(message_uid, "The\nemail\n")
 
         expect(mbox_file).to have_received(:write).with(mbox_formatted_message)
       end
 
-      it 'saves the uid to the imap file' do
+      it "saves the uid to the imap file" do
         subject.save(message_uid, "The\nemail\n")
 
         expect(imap_file).to have_received(:write).with(message_uid + "\n")
       end
 
-      context 'when the message causes parsing errors' do
+      context "when the message causes parsing errors" do
         before do
           allow(message).to receive(:to_s).and_raise(ArgumentError)
         end
 
-        it 'skips the message' do
+        it "skips the message" do
           subject.save(message_uid, "The\nemail\n")
           expect(mbox_file).to_not have_received(:write)
         end
 
-        it 'does not fail' do
+        it "does not fail" do
           expect do
             subject.save(message_uid, "The\nemail\n")
           end.to_not raise_error

data/spec/unit/utils_spec.rb

@@ -1,9 +1,8 @@
-# encoding: utf-8
-require 'spec_helper'
+require "spec_helper"
 
 describe Imap::Backup::Utils do
-  let(:filename) { 'foobar' }
-  let(:stat) { double('File::Stat', :mode => mode) }
+  let(:filename) { "foobar" }
+  let(:stat) { double("File::Stat", mode: mode) }
   let(:mode) { 0777 }
   let(:exists) { true }
 
@@ -12,24 +11,24 @@ describe Imap::Backup::Utils do
     allow(File).to receive(:exist?).with(filename).and_return(exists)
   end
 
-  context '.check_permissions' do
+  context ".check_permissions" do
     let(:requested) { 0345 }
 
-    context 'with existing files' do
+    context "with existing files" do
       [
-        [0100, 'less than the limit', true],
-        [0345, 'equal to the limit', true],
-        [0777, 'over the limit', false],
+        [0100, "less than the limit", true],
+        [0345, "equal to the limit", true],
+        [0777, "over the limit", false]
       ].each do |mode, description, success|
         context "when permissions are #{description}" do
           let(:mode) { mode }
 
           if success
-            it 'succeeds' do
+            it "succeeds" do
               described_class.check_permissions(filename, requested)
             end
           else
-            it 'fails' do
+            it "fails" do
               expect do
                 described_class.check_permissions(filename, requested)
               end.to raise_error(RuntimeError, format("Permissions on '%s' should be 0%o, not 0%o", filename, requested, mode))
@@ -39,56 +38,56 @@ describe Imap::Backup::Utils do
       end
     end
 
-    context 'with non-existent files' do
+    context "with non-existent files" do
       let(:exists) { false }
       let(:mode) { 0111 }
 
-      it 'succeeds' do
+      it "succeeds" do
         described_class.check_permissions(filename, requested)
       end
     end
   end
 
-  context '.stat' do
-    context 'with existing files' do
+  context ".stat" do
+    context "with existing files" do
       let(:mode) { 02345 }
 
-      it 'is the last 9 bits of the file mode' do
+      it "is the last 9 bits of the file mode" do
         expect(described_class.stat(filename)).to eq(0345)
       end
     end
 
-    context 'with non-existent files' do
+    context "with non-existent files" do
       let(:exists) { false }
 
-      it 'is nil' do
+      it "is nil" do
         expect(described_class.stat(filename)).to be_nil
       end
     end
   end
 
-  context '.make_folder' do
+  context ".make_folder" do
     before do
       allow(FileUtils).to receive(:mkdir_p)
       allow(FileUtils).to receive(:chmod)
     end
 
-    it 'does nothing if an empty path is supplied' do
-      described_class.make_folder('aaa', '', 0222)
+    it "does nothing if an empty path is supplied" do
+      described_class.make_folder("aaa", "", 0222)
 
       expect(FileUtils).to_not have_received(:mkdir_p)
     end
 
-    it 'creates the path' do
-      described_class.make_folder('/base/path', 'new/folder', 0222)
+    it "creates the path" do
+      described_class.make_folder("/base/path", "new/folder", 0222)
 
-      expect(FileUtils).to have_received(:mkdir_p).with('/base/path/new/folder')
+      expect(FileUtils).to have_received(:mkdir_p).with("/base/path/new/folder")
     end
 
-    it 'sets permissions on the path' do
-      described_class.make_folder('/base/path/new', 'folder', 0222)
+    it "sets permissions on the path" do
+      described_class.make_folder("/base/path/new", "folder", 0222)
 
-      expect(FileUtils).to have_received(:chmod).with(0222, '/base/path/new/folder')
+      expect(FileUtils).to have_received(:chmod).with(0222, "/base/path/new/folder")
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: imap-backup
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 1.2.3
 platform: ruby
 authors:
 - Joe Yates
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-13 00:00:00.000000000 Z
+date: 2018-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -80,6 +80,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -103,6 +117,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rubocop.yml"
 - ".travis.yml"
 - Gemfile
 - LICENSE