imap-backup 1.0.3 → 1.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 75e9eecc039c7cd2b76fc1fbc1acfbe2e07009fa
+  data.tar.gz: ce731fe2f0cc8db8af5fb70ce77d5464b46b7066
+SHA512:
+  metadata.gz: 4135cd6ab9a7bd60d5f2e8ea9be63aaad5754621f87b809b6ac611390f1a906faec4019f7289a953509c2d1785f0891018cbd83c2e64da8ae6a30bf6ca8515a4
+  data.tar.gz: 439df924e96c91c571dc9943f23ccd77a939a83f396e235bf4ca5b5f123a2b1abdffd28f11fb313e1d235625ac681027057b8ef6f3b544560c5d1a92d5688127

data/Gemfile

@@ -1,4 +1,4 @@
-source :rubygems
+source 'https://rubygems.org'
 
 gemspec
 

data/README.md

@@ -91,8 +91,8 @@ Altertatively, add it to your crontab.
 # Result
 
 Each folder is saved to an mbox file.
-Alongside each mbox is a fine *.imap which lists the source IMAP UIDs to allow
-a full restore.
+Alongside each mbox is a file with extension '.imap', which lists the source IMAP
+UIDs to allow a full restore.
 
 # Other Usage
 

data/bin/imap-backup

@@ -65,7 +65,12 @@ when 'backup'
 when 'folders'
   configuration.each_connection do |connection|
     puts connection.username
-    connection.folders.each { |f| puts "\t" + f.name }
+    folders = connection.folders
+    if folders.nil?
+      warn 'Unable to list account folders'
+      exit 1
+    end
+    folders.each { |f| puts "\t" + f.name }
   end
 when 'setup'
   Imap::Backup::Configuration::Setup.new.run

data/imap-backup.gemspec

@@ -25,7 +25,7 @@ Gem::Specification.new do |gem|
 
   gem.add_development_dependency 'pry'
   gem.add_development_dependency 'pry-doc'
-  gem.add_development_dependency 'rspec',  '>= 2.3.0'
+  gem.add_development_dependency 'rspec',  '>= 2.12.0'
   if RUBY_VERSION < '1.9'
     gem.add_development_dependency 'rcov'
   else

data/lib/imap/backup/account/connection.rb

@@ -4,42 +4,77 @@ module Imap
   module Backup
     module Account
       class Connection
-        attr_reader :username
-        attr_reader :imap
+        attr_reader :username, :local_path, :backup_folders
 
         def initialize(options)
-          @username = options[:username]
+          @username, @password = options[:username], options[:password]
           @local_path, @backup_folders = options[:local_path], options[:folders]
-          @imap = Net::IMAP.new(options[:server] || 'imap.gmail.com', 993, true)
-          @imap.login(@username, options[:password])
-        end
-
-        def disconnect
-          @imap.disconnect
         end
 
         def folders
-          @imap.list('/', '*')
+          root = root_for(username)
+          imap.list(root, '*')
         end
 
         def status
-          @backup_folders.map do |folder|
+          backup_folders.map do |folder|
             f = Imap::Backup::Account::Folder.new(self, folder[:name])
-            s = Imap::Backup::Serializer::Directory.new(@local_path, folder[:name])
+            s = Imap::Backup::Serializer::Directory.new(local_path, folder[:name])
             {:name => folder[:name], :local => s.uids, :remote => f.uids}
           end
         end
 
         def run_backup
-          @backup_folders.each do |folder|
+          backup_folders.each do |folder|
             f = Imap::Backup::Account::Folder.new(self, folder[:name])
-            s = Imap::Backup::Serializer::Mbox.new(@local_path, folder[:name])
+            s = Imap::Backup::Serializer::Mbox.new(local_path, folder[:name])
             d = Imap::Backup::Downloader.new(f, s)
             d.run
           end
         end
+
+        def disconnect
+          imap.disconnect
+        end
+
+        def imap
+          return @imap unless @imap.nil?
+          host = host_for(username)
+          options = options_for(username)
+          @imap = Net::IMAP.new(host, options)
+          @imap.login(username, @password)
+          @imap
+        end
+
+        private
+
+        def host_for(username)
+          case username
+          when /@gmail\.com/
+            'imap.gmail.com'
+          when /@fastmail\.fm/
+            'mail.messagingengine.com'
+          end
+        end
+
+        def root_for(username)
+          case username
+          when /@gmail\.com/
+            '/'
+          when /@fastmail\.fm/
+            'INBOX'
+          end
+        end
+
+        def options_for(username)
+          case username
+          when /@gmail\.com/
+            {:port => 993, :ssl => true}
+          when /@fastmail\.fm/
+            {:port => 993, :ssl => true}
+          end
+        end
       end
     end
   end
 end
-

data/lib/imap/backup/configuration/folder_chooser.rb

@@ -17,6 +17,11 @@ module Imap
             return
           end
           @folders = @connection.folders
+          if @folders.nil?
+            puts 'Unable to get folder list'
+            Setup.highline.ask 'Press a key '
+            return
+          end
           loop do
             system('clear')
             Setup.highline.choose do |menu|

data/lib/imap/backup/version.rb

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

data/spec/unit/account/connection_spec.rb

@@ -2,114 +2,121 @@
 require 'spec_helper'
 
 describe Imap::Backup::Account::Connection do
-  context '#initialize' do
-    it 'should login to the imap server' do
-      imap = stub('Net::IMAP')
-      Net::IMAP.should_receive(:new).with('imap.gmail.com', 993, true).and_return(imap)
-      imap.should_receive('login').with('myuser', 'secret')
-
-      Imap::Backup::Account::Connection.new(:username => 'myuser', :password => 'secret')
-    end
+  def self.folder_config
+    {:name => 'backup_folder'}
+  end
 
-    context "with specific server" do
-      it 'should login to the imap server' do
-        imap = stub('Net::IMAP')
-        Net::IMAP.should_receive(:new).with('my.imap.example.com', 993, true).and_return(imap)
-        imap.should_receive('login').with('myuser', 'secret')
+  let(:imap) { double('Net::IMAP', :login => nil, :list => []) }
+  let(:options) do
+    {
+      :username => username,
+      :password => 'password',
+      :local_path => 'local_path',
+      :folders => [self.class.folder_config]
+    }
+  end
+  let(:username) { 'username@gmail.com' }
 
-        Imap::Backup::Account::Connection.new(:username => 'myuser', :password => 'secret', :server => 'my.imap.example.com')
-      end
-    end
+  before do
+    allow(Net::IMAP).to receive(:new).and_return(imap)
   end
 
-  context 'instance methods' do
-    before :each do
-      @imap = stub('Net::IMAP', :login => nil)
-      Net::IMAP.stub!(:new).and_return(@imap)
-      @account = {
-        :username   => 'myuser',
-        :password   => 'secret',
-        :folders    => [{:name => 'my_folder'}],
-        :local_path => '/base/path',        
-      }
-    end
+  subject { Imap::Backup::Account::Connection.new(options) }
 
-    subject { Imap::Backup::Account::Connection.new(@account) }
+  shared_examples 'connects to IMAP' do |username = 'username@gmail.com', server = 'imap.gmail.com'|
+    it 'sets up the IMAP connection' do
+      expect(Net::IMAP).to have_received(:new).with(server, {:port => 993, :ssl => true})
+    end
 
-    context '#disconnect' do
-      it 'should disconnect from the server' do
-        @imap.should_receive(:disconnect)
+    it 'logs in to the imap server' do
+      expect(imap).to have_received(:login).with(username, 'password')
+    end
+  end
 
-        subject.disconnect
-      end
+  context '#initialize' do
+    [
+      [:username, 'username@gmail.com'],
+      [:local_path, 'local_path'],
+      [:backup_folders, [folder_config]]
+    ].each do |attr, expected|
+      its(attr) { should eq(expected) }
     end
+  end
 
-    context '#folders' do
-      it 'should list all folders' do
-        @imap.should_receive(:list).with('/', '*')
+  [
+    ['GMail', 'user@gmail.com', 'imap.gmail.com'],
+    ['Fastmail', 'user@fastmail.fm', 'mail.messagingengine.com'],
+  ].each do |service, email_username, server|
+    context service do
+      let(:username) { email_username }
 
-        subject.folders
-      end
+      before { allow(imap).to receive(:disconnect) }
+      before { subject.disconnect }
+
+      include_examples 'connects to IMAP', [email_username, server]
     end
+  end
 
-    context '#status' do
-      before :each do
-        @folder = stub('Imap::Backup::Account::Folder', :uids => [])
-        Imap::Backup::Account::Folder.stub!(:new).with(subject, 'my_folder').and_return(@folder)
-        @serializer = stub('Imap::Backup::Serializer', :uids => [])
-        Imap::Backup::Serializer::Directory.stub!(:new).with('/base/path', 'my_folder').and_return(@serializer)
-      end
+  context '#folders' do
+    let(:folders) { 'folders' }
 
-      it 'should return the names of folders' do
-        subject.status[0][:name].should == 'my_folder'
-      end
+    before { allow(imap).to receive(:list).and_return(folders) }
 
-      it 'should list local message uids' do
-        @serializer.should_receive(:uids).and_return([321, 456])
+    it 'returns the list of folders' do
+      expect(subject.folders).to eq(folders)
+    end
+  end
 
-        subject.status[0][:local].should == [321, 456]
-      end
+  context '#status' do
+    let(:folder) { double('folder', :uids => [remote_uid]) }
+    let(:local_uid) { 'local_uid' }
+    let(:serializer) { double('serializer', :uids => [local_uid]) }
+    let(:remote_uid) { 'remote_uid' }
 
-      it 'should retrieve the available uids' do
-        @folder.should_receive(:uids).and_return([101, 234])
+    before do
+      allow(Imap::Backup::Account::Folder).to receive(:new).and_return(folder)
+      allow(Imap::Backup::Serializer::Directory).to receive(:new).and_return(serializer)
+    end
 
-        subject.status[0][:remote].should == [101, 234]
-      end
+    it 'should return the names of folders' do
+      expect(subject.status[0][:name]).to eq('backup_folder')
     end
 
-    context '#run_backup' do
-      before :each do
-        @folder = stub('Imap::Backup::Account::Folder', :uids => [])
-        Imap::Backup::Account::Folder.stub!(:new).with(subject, 'my_folder').and_return(@folder)
-        @serializer = stub('Imap::Backup::Serializer')
-        Imap::Backup::Serializer::Mbox.stub!(:new).with('/base/path', 'my_folder').and_return(@serializer)
-        @downloader = stub('Imap::Backup::Downloader', :run => nil)
-        Imap::Backup::Downloader.stub!(:new).with(@folder, @serializer).and_return(@downloader)
-      end
+    it 'returns local message uids' do
+      expect(subject.status[0][:local]).to eq([local_uid])
+    end
 
-      it 'should instantiate folders' do
-        Imap::Backup::Account::Folder.should_receive(:new).with(subject, 'my_folder').and_return(@folder)
+    it 'should retrieve the available uids' do
+      expect(subject.status[0][:remote]).to eq([remote_uid])
+    end
+  end
 
-        subject.run_backup
-      end
+  context '#disconnect' do
+    before { allow(imap).to receive(:disconnect) }
+    before { subject.disconnect }
 
-      it 'should instantiate serializers' do
-        Imap::Backup::Serializer::Mbox.should_receive(:new).with('/base/path', 'my_folder').and_return(@serializer)
+    it 'disconnects from the server' do
+      expect(imap).to have_received(:disconnect).with()
+    end
 
-        subject.run_backup
-      end
+    include_examples 'connects to IMAP'
+  end
 
-      it 'should instantiate downloaders' do
-        Imap::Backup::Downloader.should_receive(:new).with(@folder, @serializer).and_return(@downloader)
+  context '#run_backup' do
+    let(:folder) { double('folder') }
+    let(:serializer) { double('serializer') }
+    let(:downloader) { double('downloader', run: nil) }
 
-        subject.run_backup
-      end
+    before do
+      allow(Imap::Backup::Account::Folder).to receive(:new).and_return(folder)
+      allow(Imap::Backup::Serializer::Mbox).to receive(:new).and_return(serializer)
+      allow(Imap::Backup::Downloader).to receive(:new).and_return(downloader)
+    end
 
-      it 'should run downloaders' do
-        @downloader.should_receive(:run)
+    before { subject.run_backup }
 
-        subject.run_backup
-      end
+    it 'runs downloaders' do
+      expect(downloader).to have_received(:run)
     end
   end
 end

data/spec/unit/account/folder_spec.rb

@@ -4,28 +4,25 @@ require 'spec_helper'
 describe Imap::Backup::Account::Folder do
   include InputOutputTestHelpers
 
+  let(:imap) { stub('Net::IMAP') }
+  let(:connection) { stub('Imap::Backup::Account::Connection', :imap => imap) }
   let(:missing_mailbox_data) { stub('Data', :text => 'Unknown Mailbox: my_folder') }
   let(:missing_mailbox_response) { stub('Response', :data => missing_mailbox_data) }
   let(:missing_mailbox_error) { Net::IMAP::NoResponseError.new(missing_mailbox_response) }
 
   context 'with instance' do
-    before :each do
-      @imap    = stub('Net::IMAP')
-      @connection = stub('Imap::Backup::Account::Connection', :imap => @imap)
-    end
-
-    subject { Imap::Backup::Account::Folder.new(@connection, 'my_folder') }
+    subject { Imap::Backup::Account::Folder.new(connection, 'my_folder') }
 
     context '#uids' do
-      it 'should list available messages' do
-        @imap.should_receive(:examine).with('my_folder')
-        @imap.should_receive(:uid_search).with(['ALL']).and_return([5678, 123])
+      it 'lists available messages' do
+        imap.should_receive(:examine).with('my_folder')
+        imap.should_receive(:uid_search).with(['ALL']).and_return([5678, 123])
 
         subject.uids.should == [123, 5678]
       end
 
       it 'returns an empty array for missing mailboxes' do
-        @imap.
+        imap.
           should_receive(:examine).
           with('my_folder').
           and_raise(missing_mailbox_error)
@@ -37,25 +34,25 @@ describe Imap::Backup::Account::Folder do
     end
 
     context '#fetch' do
-      before :each do
-        @message_body = 'the body'
-        @message = {
-          'RFC822' => @message_body,
+      let(:message_body) { 'the body' }
+      let(:message) do
+        {
+          'RFC822' => message_body,
           'other'  => 'xxx'
         }
       end
 
-      it 'should request the message, the flags and the date' do
-        @imap.should_receive(:examine).with('my_folder')
-        @imap.should_receive(:uid_fetch).
+      it 'requests the message, the flags and the date' do
+        imap.should_receive(:examine).with('my_folder')
+        imap.should_receive(:uid_fetch).
               with([123], ['RFC822', 'FLAGS', 'INTERNALDATE']).
-              and_return([[nil, @message]])
+              and_return([[nil, message]])
 
         subject.fetch(123)
       end
 
       it "returns nil if the mailbox doesn't exist" do
-        @imap.
+        imap.
           should_receive(:examine).
           with('my_folder').
           and_raise(missing_mailbox_error)
@@ -66,10 +63,10 @@ describe Imap::Backup::Account::Folder do
       end
 
       if RUBY_VERSION > '1.9'
-        it 'should set the encoding on the message' do
-          @imap.stub!(:examine => nil, :uid_fetch => [[nil, @message]])
+        it 'sets the encoding on the message' do
+          imap.stub!(:examine => nil, :uid_fetch => [[nil, message]])
 
-          @message_body.should_receive(:force_encoding).with('utf-8')
+          message_body.should_receive(:force_encoding).with('utf-8')
 
           subject.fetch(123)
         end

data/spec/unit/downloader_spec.rb

@@ -3,55 +3,60 @@ require 'spec_helper'
 
 describe Imap::Backup::Downloader do
   context 'with account and downloader' do
-    before :each do
-      local_path = '/base/path'
-      stat       = stub('File::Stat', :mode => 0700)
-      File.stub!(:stat).with(local_path).and_return(stat)
-
-      @message = {
+    let(:local_path) { '/base/path' }
+    let(:stat) { stub('File::Stat', :mode => 0700) }
+    let(:message) do
+      {
         'RFC822' => 'the body',
         'other'  => 'xxx'
       }
-      @folder     = stub('Imap::Backup::Account::Folder', :fetch => @message)
-      @serializer = stub('Imap::Backup::Serializer', :prepare => nil,
-                                                     :exist?  => true,
-                                                     :uids    => [],
-                                                     :save    => nil)
     end
+    let(:folder) { stub('Imap::Backup::Account::Folder', :fetch => message) }
+    let(:serializer) do
+      stub(
+        'Imap::Backup::Serializer',
+        :prepare => nil,
+        :exist?  => true,
+        :uids    => [],
+        :save    => nil
+      )
+    end
+
+    before { File.stub!(:stat).with(local_path).and_return(stat) }
 
-    subject { Imap::Backup::Downloader.new(@folder, @serializer) }
+    subject { Imap::Backup::Downloader.new(folder, serializer) }
 
     context '#run' do
       context 'with folder' do
         it 'should list messages' do
-          @folder.should_receive(:uids).and_return([])
+          folder.should_receive(:uids).and_return([])
 
           subject.run
         end
 
         context 'with messages' do
           before :each do
-            @folder.stub!(:uids).and_return(['123', '999', '1234'])
+            folder.stub!(:uids).and_return(['123', '999', '1234'])
           end
 
           it 'should skip messages that are downloaded' do
             File.stub!(:exist?).and_return(true)
 
-            @serializer.should_not_receive(:fetch)
+            serializer.should_not_receive(:fetch)
 
             subject.run
           end
 
           it 'skips failed fetches' do
-            @folder.should_receive(:fetch).with('999').and_return(nil)
-            @serializer.should_not_receive(:save).with('999', anything)
+            folder.should_receive(:fetch).with('999').and_return(nil)
+            serializer.should_not_receive(:save).with('999', anything)
 
             subject.run
           end
 
           context 'to download' do
             before :each do
-              @serializer.stub!(:exist?) do |uid|
+              serializer.stub!(:exist?) do |uid|
                 if uid == '123'
                   true
                 else
@@ -61,15 +66,15 @@ describe Imap::Backup::Downloader do
             end
 
             it 'should request messages' do
-              @folder.should_receive(:fetch).with('999')
-              @folder.should_receive(:fetch).with('1234')
+              folder.should_receive(:fetch).with('999')
+              folder.should_receive(:fetch).with('1234')
 
               subject.run
             end
 
             it 'should save messages' do
-              @serializer.should_receive(:save).with('999', @message)
-              @serializer.should_receive(:save).with('1234', @message)
+              serializer.should_receive(:save).with('999', message)
+              serializer.should_receive(:save).with('1234', message)
 
               subject.run
             end

metadata

@@ -1,126 +1,111 @@
 --- !ruby/object:Gem::Specification
 name: imap-backup
 version: !ruby/object:Gem::Version
-  version: 1.0.3
-  prerelease: 
+  version: 1.0.4
 platform: ruby
 authors:
 - Joe Yates
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-10 00:00:00.000000000 Z
+date: 2013-12-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: highline
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: mail
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: pry-doc
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
-        version: 2.3.0
+        version: 2.12.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
-        version: 2.3.0
+        version: 2.12.0
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: Backup GMail, or any other IMAP email service, to disk.
@@ -175,33 +160,26 @@ files:
 - spec/unit/utils_spec.rb
 homepage: https://github.com/joeyates/imap-backup
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 1167713560722086376
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 1167713560722086376
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Backup GMail (or other IMAP) accounts to disk
 test_files:
 - spec/gather_rspec_coverage.rb