imap-backup 1.0.5 → 1.0.6

data/lib/imap/backup/downloader.rb

@@ -2,22 +2,19 @@
 require 'rubygems' if RUBY_VERSION < '1.9'
 require 'json'
 
-module Imap
-  module Backup
-    class Downloader
-      def initialize(folder, serializer)
-        @folder, @serializer = folder, serializer
-      end
+module Imap::Backup
+  class Downloader
+    def initialize(folder, serializer)
+      @folder, @serializer = folder, serializer
+    end
 
-      def run
-        uids = @folder.uids - @serializer.uids
-        uids.each do |uid|
-          message = @folder.fetch(uid)
-          next if message.nil?
-          @serializer.save(uid, message)
-        end
+    def run
+      uids = @folder.uids - @serializer.uids
+      uids.each do |uid|
+        message = @folder.fetch(uid)
+        next if message.nil?
+        @serializer.save(uid, message)
       end
     end
   end
 end
-

data/lib/imap/backup/serializer/base.rb

@@ -1,17 +1,14 @@
 # encoding: utf-8
 
-module Imap
-  module Backup
-    module Serializer
-      DIRECTORY_PERMISSIONS = 0700
-      FILE_PERMISSIONS      = 0600
-      class Base
-        def initialize(path, folder)
-          @path, @folder = path, folder
-          Imap::Backup::Utils.check_permissions(@path, DIRECTORY_PERMISSIONS)
-        end
+module Imap::Backup
+  module Serializer
+    DIRECTORY_PERMISSIONS = 0700
+    FILE_PERMISSIONS      = 0600
+    class Base
+      def initialize(path, folder)
+        @path, @folder = path, folder
+        Imap::Backup::Utils.check_permissions(@path, DIRECTORY_PERMISSIONS)
       end
     end
   end
 end
-

data/lib/imap/backup/serializer/directory.rb

@@ -1,47 +1,42 @@
 # encoding: utf-8
 require 'fileutils'
 
-module Imap
-  module Backup
-    module Serializer
-      class Directory < Base
-        def initialize(path, folder)
-          super
-          Imap::Backup::Utils.make_folder(@path, @folder, DIRECTORY_PERMISSIONS)
-        end
-
-        def uids
-          return [] if ! File.exist?(directory)
-
-          d = Dir.open(directory)
-          as_strings = d.map do |file|
-            file[/^0*(\d+).json$/, 1]
-          end.compact
-          as_strings.map(&:to_i).sort
-        end
-
-        def exist?(uid)
-          message_filename = filename(uid)
-          File.exist?(message_filename)
-        end
-
-        def save(uid, message)
-          message_filename = filename(uid)
-          File.open(message_filename, 'w') { |f| f.write message.to_json }
-          FileUtils.chmod 0600, message_filename
-        end
-
-        private
-
-        def directory
-          File.join(@path, @folder)
-        end
-
-        def filename(uid)
-          "#{directory}/%012u.json" % uid.to_i
-        end
-      end
+module Imap::Backup::Serializer
+  class Directory < Base
+    def initialize(path, folder)
+      super
+      Imap::Backup::Utils.make_folder(@path, @folder, DIRECTORY_PERMISSIONS)
+    end
+
+    def uids
+      return [] if ! File.exist?(directory)
+
+      d = Dir.open(directory)
+      as_strings = d.map do |file|
+        file[/^0*(\d+).json$/, 1]
+      end.compact
+      as_strings.map(&:to_i).sort
+    end
+
+    def exist?(uid)
+      message_filename = filename(uid)
+      File.exist?(message_filename)
+    end
+
+    def save(uid, message)
+      message_filename = filename(uid)
+      File.open(message_filename, 'w') { |f| f.write message.to_json }
+      FileUtils.chmod 0600, message_filename
+    end
+
+    private
+
+    def directory
+      File.join(@path, @folder)
+    end
+
+    def filename(uid)
+      "#{directory}/%012u.json" % uid.to_i
     end
   end
 end
-

data/lib/imap/backup/serializer/mbox.rb

@@ -2,95 +2,90 @@
 require 'csv'
 require 'email/mboxrd/message'
 
-module Imap
-  module Backup
-    module Serializer
-      class Mbox < Base
-        def initialize(path, folder)
-          super
-          create_containing_directory
-          assert_files
-        end
-
-        # TODO: cleanup locks, close file handles
-
-        def uids
-          return @uids if @uids
-
-          @uids = []
-          return @uids if not exist?
-
-          CSV.foreach(imap_pathname) do |row|
-            @uids << row[0]
-          end
-          @uids
-        end
-
-        def save(uid, message)
-          uid = uid.to_s
-          return if uids.include?(uid)
-          message = Email::Mboxrd::Message.new(message['RFC822'])
-          mbox = imap = nil
-          begin
-            mbox = File.open(mbox_pathname, 'ab')
-            imap = File.open(imap_pathname, 'ab')
-            mbox.write message.to_s
-            imap.write uid + "\n"
-          ensure
-            mbox.close if mbox
-            imap.close if imap
-          end
-        end
-
-        private
-
-        def assert_files
-          mbox = mbox_exist?
-          imap = imap_exist?
-          raise '.imap file missing' if mbox and not imap
-          raise '.mbox file missing' if imap and not mbox
-        end
-
-        def create_containing_directory
-          mbox_relative_path = File.dirname(mbox_relative_pathname)
-          return if mbox_relative_path == '.'
-          Imap::Backup::Utils.make_folder(@path, mbox_relative_path, DIRECTORY_PERMISSIONS)
-        end
-
-        def exist?
-          mbox_exist? and imap_exist?
-        end
-
-        def mbox_exist?
-          File.exist?(mbox_pathname)
-        end
-
-        def imap_exist?
-          File.exist?(imap_pathname)
-        end
-
-        def mbox_relative_pathname
-          @folder + '.mbox'
-        end
-
-        def mbox_pathname
-          File.join(@path, mbox_relative_pathname)
-        end
-
-        def imap_pathname
-          filename = @folder + '.imap'
-          File.join(@path, filename)
-        end
-
-        def lock
-          # lock mbox and imap files
-          # create both empty if missing
-        end
-
-        def unlock
-        end
+module Imap::Backup::Serializer
+  class Mbox < Base
+    def initialize(path, folder)
+      super
+      create_containing_directory
+      assert_files
+    end
+
+    # TODO: cleanup locks, close file handles
+
+    def uids
+      return @uids if @uids
+
+      @uids = []
+      return @uids if not exist?
+
+      CSV.foreach(imap_pathname) do |row|
+        @uids << row[0]
+      end
+      @uids
+    end
+
+    def save(uid, message)
+      uid = uid.to_s
+      return if uids.include?(uid)
+      message = Email::Mboxrd::Message.new(message['RFC822'])
+      mbox = imap = nil
+      begin
+        mbox = File.open(mbox_pathname, 'ab')
+        imap = File.open(imap_pathname, 'ab')
+        mbox.write message.to_s
+        imap.write uid + "\n"
+      ensure
+        mbox.close if mbox
+        imap.close if imap
       end
     end
+
+    private
+
+    def assert_files
+      mbox = mbox_exist?
+      imap = imap_exist?
+      raise '.imap file missing' if mbox and not imap
+      raise '.mbox file missing' if imap and not mbox
+    end
+
+    def create_containing_directory
+      mbox_relative_path = File.dirname(mbox_relative_pathname)
+      return if mbox_relative_path == '.'
+      Imap::Backup::Utils.make_folder(@path, mbox_relative_path, DIRECTORY_PERMISSIONS)
+    end
+
+    def exist?
+      mbox_exist? and imap_exist?
+    end
+
+    def mbox_exist?
+      File.exist?(mbox_pathname)
+    end
+
+    def imap_exist?
+      File.exist?(imap_pathname)
+    end
+
+    def mbox_relative_pathname
+      @folder + '.mbox'
+    end
+
+    def mbox_pathname
+      File.join(@path, mbox_relative_pathname)
+    end
+
+    def imap_pathname
+      filename = @folder + '.imap'
+      File.join(@path, filename)
+    end
+
+    def lock
+      # lock mbox and imap files
+      # create both empty if missing
+    end
+
+    def unlock
+    end
   end
 end
-

data/lib/imap/backup/utils.rb

@@ -4,7 +4,6 @@ require 'fileutils'
 module Imap
   module Backup
     module Utils
-
       def self.check_permissions(filename, limit)
         actual = stat(filename)
         mask   = ~limit & 0777
@@ -37,8 +36,6 @@ module Imap
       def self.oct(permissions)
         "0%o" % permissions
       end
-
     end
   end
 end
-

data/lib/imap/backup/version.rb

@@ -2,8 +2,7 @@ module Imap
   module Backup
     MAJOR    = 1
     MINOR    = 0
-    REVISION = 5
+    REVISION = 6
     VERSION  = [MAJOR, MINOR, REVISION].map(&:to_s).join('.')
   end
 end
-

data/spec/gather_rspec_coverage.rb

@@ -1,2 +1 @@
 GATHER_RSPEC_COVERAGE = 1
-

data/spec/spec_helper.rb

@@ -4,7 +4,7 @@ if RUBY_VERSION < '1.9'
   require 'rspec/autorun'
 else
   require 'simplecov'
-  if defined?( GATHER_RSPEC_COVERAGE )
+  if defined?(GATHER_RSPEC_COVERAGE)
     SimpleCov.start do
       add_filter "/spec/"
       add_filter "/vendor/"
@@ -12,10 +12,9 @@ else
   end
 end
 
-require File.expand_path( File.dirname(__FILE__) + '/../lib/imap/backup' )
+require File.expand_path(File.dirname(__FILE__) + '/../lib/imap/backup')
 
 module HighLineTestHelpers
-
   def prepare_highline
     @input  = stub('stdin', :eof? => false)
     # default gets stub
@@ -24,11 +23,9 @@ module HighLineTestHelpers
     Imap::Backup::Configuration::Setup.highline = HighLine.new(@input, @output)
     [@input, @output]
   end
-
 end
 
 module InputOutputTestHelpers
-
   def capturing_output
     output = StringIO.new
     $stdout = output
@@ -37,6 +34,4 @@ module InputOutputTestHelpers
   ensure
     $stdout = STDOUT
   end
-
 end
-

data/spec/unit/account/connection_spec.rb

@@ -142,4 +142,3 @@ describe Imap::Backup::Account::Connection do
     end
   end
 end
-

data/spec/unit/account/folder_spec.rb

@@ -74,4 +74,3 @@ describe Imap::Backup::Account::Folder do
     end
   end
 end
-

data/spec/unit/configuration/account_spec.rb

@@ -2,215 +2,286 @@
 require 'spec_helper'
 
 describe Imap::Backup::Configuration::Account do
-  include HighLineTestHelpers
-  include InputOutputTestHelpers
+  class MockHighlineMenu
+    attr_reader :choices
+    attr_accessor :header
 
-  def choose_menu_item(item)
-    @state = :initial
-    @input.should_receive(:gets) do
-      case @state
-      when :initial
-        @state = :done
-        "#{item}\n"
-      when :done
-        "quit\n"
-      end
+    def initialize
+      @choices = {}
+    end
+
+    def choice(name, &block)
+      choices[name] = block
+    end
+
+    def hidden(name, &block)
+      choices[name] = block
     end
   end
 
   context '#run' do
-    before :each do
-      @account1_path = '/backup/path'
-      @account1 = {
-        :username   => 'user@example.com',
-        :password   => 'secret',
-        :local_path => @account1_path,
-        :folders    => [ { :name => 'my_folder' }, { :name => 'another_folder' } ]
+    let(:highline) { double('Highline') }
+    let(:menu) { MockHighlineMenu.new }
+    let(:store) { double('Imap::Backup::Configuration::Store', :data => data) }
+    let(:data) { {:accounts => [account, account1]} }
+    let(:account) do
+      {
+        :username => existing_email,
+        :server => existing_server,
+        :local_path => '/backup/path',
+        :folders => [{:name => 'my_folder'}],
+        :password => existing_password,
       }
-      @other_account_path = '/existing/path'
-      @other_account = {
-        :username   => 'existing@example.com',
-        :password   => 'secret',
-        :local_path => @other_account_path,
-        :folders    => []
+    end
+    let(:account1) do
+      {
+        :username => other_email,
+        :local_path => other_existing_path,
       }
-      @data = {:accounts => [@account1, @other_account]}
-      @store = stub('Imap::Backup::Configuration::Store')
-      @store.stub!(:data => @data)
-      @input, @output = prepare_highline
-      subject.stub(:system => nil)
+    end
+    let(:existing_email) { 'user@example.com' }
+    let(:new_email) { 'foo@example.com' }
+    let(:existing_server) { 'imap.example.com' }
+    let(:existing_password) { 'password' }
+    let(:other_email) { 'other@example.com' }
+    let(:other_existing_path) { '/other/existing/path' }
+
+    before do
+      allow(subject).to receive(:system).and_return(nil)
+      allow(subject).to receive(:puts).and_return(nil)
+      allow(highline).to receive(:choose) do |&block|
+        block.call(menu)
+        throw :done
+      end
     end
 
-    subject { Imap::Backup::Configuration::Account.new(@store, @account1) }
+    subject { described_class.new(store, account, highline) }
 
-    context 'menu' do
-      it 'clears the screen' do
-        subject.should_receive(:system).with('clear')
+    context 'preparation' do
+      before { subject.run }
 
-        subject.run
+      it 'clears the screen' do
+        expect(subject).to have_received(:system).with('clear')
       end
 
-      it 'should show a menu' do
-        subject.run
-
-        @output.string.should =~ /modify email/
-        @output.string.should =~ /modify password/
-        @output.string.should =~ /modify backup path/
-        @output.string.should =~ /choose backup folders/
-        @output.string.should =~ /test authentication/
-        @output.string.should =~ /delete/
-        @output.string.should =~ /return to main/
+      context 'menu' do
+        it 'shows the menu' do
+          expect(highline).to have_received(:choose)
+        end
       end
+    end
 
-      it 'should show account details in the menu' do
-        subject.run
+    context 'menu' do
+      [
+        'modify email',
+        'modify password',
+        'modify server',
+        'modify backup path',
+        'choose backup folders',
+        'test connection',
+        'delete',
+        'return to main menu',
+        'quit', # TODO: quit is hidden
+      ].each do |item|
+        before { subject.run }
+
+        it "has a '#{item}' item" do
+          expect(menu.choices).to include(item)
+        end
+      end
+    end
 
-        @output.string.should =~ /email:\s+user@example.com/
-        @output.string.should =~ /password:\s+x+/
-        @output.string.should =~ %r{path:\s+/backup/path}
-        @output.string.should =~ /folders:\s+my_folder, another_folder/
+    context 'account details' do
+      [
+        ['email', /email:\s+user@example.com/],
+        ['server', /server:\s+imap.example.com/],
+        ['password', /password:\s+x+/],
+        ['path', %r(path:\s+/backup/path)],
+        ['folders', /folders:\s+my_folder/],
+      ].each do |attribute, value|
+        before { subject.run }
+
+        it "shows the #{attribute}" do
+          expect(menu.header).to match(value)
+        end
       end
 
-      it 'should indicate that a password is not set' do
-        @account1[:password] = ''
+      context 'with no password' do
+        let(:existing_password) { '' }
 
-        subject.run
+        before { subject.run }
 
-        @output.string.should =~ /password:\s+\(unset\)/
+        it 'indicates that a password is not set' do
+          expect(menu.header).to include('password: (unset)')
+        end
       end
-
     end
 
     context 'email' do
-      it 'should modify the email address' do
-        Imap::Backup::Configuration::Asker.should_receive(:email).once.and_return('new@example.com')
-
-        choose_menu_item 'modify email'
-
+      before do
+        allow(Imap::Backup::Configuration::Asker).to receive(:email).and_return(new_email)
         subject.run
+        menu.choices['modify email'].call
+      end
+
+      context 'if the server is blank' do
+        [
+          ['GMail', 'foo@gmail.com', 'imap.gmail.com'],
+          ['Fastmail', 'bar@fastmail.fm', 'mail.messagingengine.com'],
+        ].each do |service, email, expected|
+          context service do
+            let(:new_email) { email }
+
+            context 'with nil' do
+              let(:existing_server) { nil }
+
+              it 'sets a default server' do
+                expect(account[:server]).to eq(expected)
+              end
+            end
+
+            context 'with an empty string' do
+              let(:existing_server) { '' }
+
+              it 'sets a default server' do
+                expect(account[:server]).to eq(expected)
+              end
+            end
+          end
+        end
+      end
 
-        @output.string.should =~ /email:\s+new@example.com/
-        @account1[:username].should == 'new@example.com'
+      it 'modifies the email address' do
+        expect(account[:username]).to eq(new_email)
       end
 
-      it 'should do nothing if it creates a duplicate' do
-        Imap::Backup::Configuration::Asker.should_receive(:email).once.and_return('existing@example.com')
+      context 'the email already exists' do
+        let(:new_email) { other_email }
 
-        choose_menu_item 'modify email'
+        it 'indicates the error' do
+          expect(subject).to have_received(:puts).with('There is already an account set up with that email address')
+        end
 
-        capturing_output do
-          subject.run
-        end.should =~ /there is already an account set up with that email address/i
+        it "doesn't set the email" do
+          expect(account[:username]).to eq(existing_email)
+        end
       end
     end
 
     context 'password' do
-      it 'should update the password' do
-        Imap::Backup::Configuration::Asker.should_receive(:password).once.and_return('new_pwd')
-
-        choose_menu_item 'modify password'
+      let(:new_password) { 'new_password' }
 
+      before do
+        allow(Imap::Backup::Configuration::Asker).to receive(:password).and_return(new_password)
         subject.run
-
-        @account1[:password].should == 'new_pwd'
+        menu.choices['modify password'].call
       end
 
-      it 'should do nothing if the user cancels' do
-        Imap::Backup::Configuration::Asker.should_receive(:password).once.and_return(nil)
-
-        choose_menu_item 'modify password'
+      it 'updates the password' do
+        expect(account[:password]).to eq(new_password)
+      end
 
-        subject.run
+      context 'if the user cancels' do
+        let(:new_password) { nil }
 
-        @account1[:password].should == 'secret'
+        it 'does nothing' do
+          expect(account[:password]).to eq(existing_password)
+        end
       end
     end
 
-    context 'backup_path' do
-      it 'should update the path' do
-        Imap::Backup::Configuration::Asker.should_receive(:backup_path).once do |default, validator|
-          validator.call('new/path')
-          '/new/path'
-        end
+    context 'server' do
+      let(:server) { 'server' }
 
-        choose_menu_item 'modify backup path'
+      before do
+        allow(highline).to receive(:ask).with('server: ').and_return(server)
+      end
 
+      before do
         subject.run
+        menu.choices['modify server'].call
+      end
 
-        @account1[:local_path].should == '/new/path'
+      it 'updates the server' do
+        expect(account[:server]).to eq(server)
       end
+    end
 
-      it 'should validate that the path is not used by other backups' do
-        Imap::Backup::Configuration::Asker.should_receive(:backup_path) do |default, validator|
-          validator.call(@other_account_path)
-          '/path'
+    context 'backup_path' do
+      let(:new_backup_path) { '/new/path' }
+
+      before do
+        @validator = nil
+        allow(Imap::Backup::Configuration::Asker).to receive(:backup_path) do |path, validator|
+          @validator = validator
+          new_backup_path
         end
+        subject.run
+        menu.choices['modify backup path'].call
+      end
 
-        choose_menu_item 'modify backup path'
+      it 'updates the path' do
+        expect(account[:local_path]).to eq(new_backup_path)
+      end
 
-        capturing_output do
-          subject.run
-        end.should =~ %r{The path '/existing/path' is used to backup the account 'existing@example.com'}
+      it 'validates that the path is not used by other backups' do
+        expect(@validator.call(other_existing_path)).to be_false
       end
     end
 
-    it 'should add/remove folders' do
-      @chooser = stub('Imap::Backup::Configuration::FolderChooser')
-      Imap::Backup::Configuration::FolderChooser.should_receive(:new).with(@account1).and_return(@chooser)
-      @chooser.should_receive(:run).with().once
+    context 'folders' do
+      let(:chooser) { double(:run => nil) }
 
-      choose_menu_item 'choose backup folders'
+      before do
+        allow(Imap::Backup::Configuration::FolderChooser).to receive(:new).and_return(chooser)
+        subject.run
+        menu.choices['choose backup folders'].call
+      end
 
-      subject.run
+      it 'edits folders' do
+        expect(chooser).to have_received(:run)
+      end
     end
 
-    it 'should allow testing the connection' do
-      Imap::Backup::Configuration::ConnectionTester.should_receive(:test).with(@account1).and_return('All fine')
-
-      choose_menu_item 'test authentication'
-
-      capturing_output do
+    context 'connection test' do
+      before do
+        allow(Imap::Backup::Configuration::ConnectionTester).to receive(:test).and_return('All fine')
+        allow(highline).to receive(:ask)
         subject.run
-      end.should == "All fine\n"
+        menu.choices['test connection'].call
+      end
+
+      it 'tests the connection' do
+        expect(Imap::Backup::Configuration::ConnectionTester).to have_received(:test).with(account)
+      end
     end
 
     context 'deletion' do
-      it 'should confirm deletion' do
-        Imap::Backup::Configuration::Setup.highline.should_receive(:agree).with("Are you sure? (y/n) ").and_return(true)
-
-        choose_menu_item 'delete'
+      let(:confirmed) { true }
 
+      before do
+        allow(highline).to receive(:agree).and_return(confirmed)
         subject.run
+        catch :done do
+          menu.choices['delete'].call
+        end
       end
 
-      it 'should delete the account' do
-        Imap::Backup::Configuration::Setup.highline.stub!(:agree).with("Are you sure? (y/n) ").and_return(true)
-
-        choose_menu_item 'delete'
-
-        subject.run
-
-        @data[:accounts].should_not include(@account1)
+      it 'asks for confirmation' do
+        expect(highline).to have_received(:agree)
       end
 
-      it 'should not delete if confirmation is not given' do
-        Imap::Backup::Configuration::Setup.highline.stub!(:agree).with("Are you sure? (y/n) ").and_return(false)
-
-        choose_menu_item 'delete'
-
-        subject.run
-
-        @data[:accounts].should include(@account1)
+      it 'deletes the account' do
+        expect(data[:accounts].find{|a| a[:username] == existing_email}).to be_nil
       end
-    end
 
-    context 'return to main menu' do
-      it 'should return' do
-        @input.stub!(:gets).with().and_return("return\n")
+      context 'without confirmation' do
+        let(:confirmed) { false }
 
-        subject.run.should be_nil
+        it 'does nothing' do
+          expect(data[:accounts].find{|a| a[:username] == existing_email}).to eq(account)
+        end
       end
     end
   end
 end
-