imap-backup 0.0.1 → 0.0.2

data/README.md

@@ -1,5 +1,4 @@
-imap-backup [![Build Status](https://secure.travis-ci.org/joeyates/imap-backup.png)][Continuous Integration]
-===========
+# imap-backup [![Build Status](https://secure.travis-ci.org/joeyates/imap-backup.png)][Continuous Integration]
 
 *Backup GMail (or other IMAP) accounts to disk*
 
@@ -13,31 +12,35 @@ imap-backup [![Build Status](https://secure.travis-ci.org/joeyates/imap-backup.p
 [Rubygem]: http://rubygems.org/gems/imap-backup "Ruby gem at rubygems.org"
 [Continuous Integration]: http://travis-ci.org/joeyates/imap-backup "Build status by Travis-CI"
 
-Installation
-============
-
-Add this line to your application's Gemfile:
-
-    gem 'imap/backup'
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
+# Installation
 
     gem install 'imap-backup'
 
-Basic Usage
-===========
+# Basic Usage
 
 * Create ~/.imap-backup
+
+    {
+      accounts:
+      [
+        {
+          username: "my.user@gmail.com",
+          password: "secret",
+          local_path: "/path/to/backup/root",
+          folders:
+            [
+              {name: "[Gmail]/All Mail"},
+              {name: "my_folder"}
+            ]
+        }
+      ]
+    }
+
 * Run
 
     imap-backup
 
-Usage
-=====
+# Usage
 
 Check connection:
 
@@ -47,18 +50,24 @@ List IMAP folders:
 
     imap-backup --list
 
-Design Goals
-============
+# Design Goals
 
 * Secure - use a local file protected by permissions
 * Restartable - calculate start point based on alreadt downloaded messages
 * Standards compliant - save emails in a standard format
 * Standalone - does not rely on an email client or MTA
 
-Similar Software
-================
+# Similar Software
 
 * https://github.com/thefloweringash/gmail-imap-backup
 * https://github.com/mleonhard/imapbackup
 * https://github.com/rgrove/larch - copies between IMAP servers
 
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+

data/bin/imap-backup

@@ -1,20 +1,71 @@
 #!/usr/bin/env ruby
 # -*- encoding: utf-8 -*-
 
+require 'optparse'
+
 $:.unshift(File.expand_path('../../lib/', __FILE__))
 require 'imap/backup'
 
-settings = Imap::Backup::Settings.new
+KNOWN_COMMANDS = [
+  {:name => 'backup',  :help => 'Do the backup (default)'},
+  {:name => 'folders', :help => 'List folders for all (or selected) accounts'},
+  {:name => 'status',  :help => 'List count of non backed-up emails per folder'},
+  {:name => 'help',    :help => 'Show usage'},
+]
+
+options = {:command => 'backup'}
+opts = OptionParser.new do |opts|
+  opts.banner = "Usage: #{$0} [options] COMMAND"
+
+  opts.separator ''
+  opts.separator 'Commands:'
+  KNOWN_COMMANDS.each do |command|
+    opts.separator "\t%- 20s %s" % [command[:name], command[:help]]
+  end
+  opts.separator ''
+  opts.separator 'Common options:'
+
+  opts.on('-a', '--accounts ACCOUNT1[,ACCOUNT2,...]', Array, 'only these accounts') do |account|
+    options[:account] = account
+  end
+
+  opts.on_tail("-h", "--help", "Show usage") do
+    puts opts
+    exit
+  end
+
+end
+opts.parse!
+
+if ARGV.size > 0
+  options[:command] = ARGV.shift
+end
+
+if KNOWN_COMMANDS.find{|c| c[:name] == options[:command] }.nil?
+  raise "Unknown command '#{options[:command]}'"
+end
+
+settings = Imap::Backup::Settings.new(options[:accounts])
 
-if ARGV[0] == '--list'
-  settings.each_account do |account|
-    account.folders.each { |f| puts f.name }
+case options[:command]
+when 'backup'
+  settings.each_connection do |connection|
+    connection.run_backup
+  end
+when 'help'
+  puts opts
+when 'folders'
+  settings.each_connection do |connection|
+    puts connection.username
+    connection.folders.each { |f| puts "\t" + f.name }
   end
-else
-  settings.each_account do |account|
-    account.backup_folders.each do |folder|
-      d = Imap::Backup::Downloader.new(account, folder['name'])
-      d.run
+when 'status'
+  settings.each_connection do |connection|
+    puts connection.username
+    folders = connection.status
+    folders.each do |f|
+      missing_locally = f[:remote] - f[:local]
+      puts "#{f[:name]}: #{missing_locally.size}"
     end
   end
 end

data/imap-backup.gemspec

@@ -16,6 +16,11 @@ Gem::Specification.new do |gem|
   gem.require_paths = ['lib']
   gem.version       = Imap::Backup::VERSION
 
+  gem.add_runtime_dependency 'rake'
+  if RUBY_VERSION < '1.9'
+    gem.add_runtime_dependency 'json'
+  end
+
   gem.add_development_dependency 'pry'
   gem.add_development_dependency 'pry-doc'
   gem.add_development_dependency 'rspec',  '>= 2.3.0'

data/lib/imap/backup.rb

@@ -1,6 +1,8 @@
 require 'imap/backup/utils'
-require 'imap/backup/account'
+require 'imap/backup/account/connection'
+require 'imap/backup/account/folder'
 require 'imap/backup/downloader'
+require 'imap/backup/serializer/directory'
 require 'imap/backup/settings'
 require 'imap/backup/version'
 

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

@@ -0,0 +1,47 @@
+require 'net/imap'
+
+module Imap
+  module Backup
+    module Account
+      class Connection
+
+        attr_reader :username
+        attr_reader :imap
+
+        def initialize(options)
+          @username = options[:username]
+          @local_path, @backup_folders = options[:local_path], options[:folders]
+          @imap = Net::IMAP.new('imap.gmail.com', 993, true)
+          @imap.login(@username, options[:password])
+        end
+
+        def disconnect
+          @imap.disconnect
+        end
+
+        def folders
+          @imap.list('/', '*')
+        end
+
+        def status
+          @backup_folders.map do |folder|
+            f = Imap::Backup::Account::Folder.new(self, 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|
+            f = Imap::Backup::Account::Folder.new(self, folder[:name])
+            s = Imap::Backup::Serializer::Directory.new(@local_path, folder[:name])
+            d = Imap::Backup::Downloader.new(f, s)
+            d.run
+          end
+        end
+
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+module Imap
+  module Backup
+    module Account
+      class Folder
+
+        REQUESTED_ATTRIBUTES = ['RFC822', 'FLAGS', 'INTERNALDATE']
+
+        def initialize(connection, folder)
+          @connection, @folder = connection, folder
+        end
+
+        def uids
+          @connection.imap.examine(@folder)
+          @connection.imap.uid_search(['ALL']).sort
+        end
+
+        def fetch(uid)
+          @connection.imap.examine(@folder)
+          message = @connection.imap.uid_fetch([uid.to_i], REQUESTED_ATTRIBUTES)[0][1]
+          message['RFC822'].force_encoding('utf-8') if RUBY_VERSION > '1.9'
+          message
+        end
+
+      end
+    end
+  end
+end
+

data/lib/imap/backup/downloader.rb

@@ -4,25 +4,15 @@ module Imap
   module Backup
     class Downloader
 
-      include Imap::Backup::Utils
-
-      def initialize(account, folder)
-        @account, @folder = account, folder
-
-        check_permissions(@account.local_path, 0700)
+      def initialize(folder, serializer)
+        @folder, @serializer = folder, serializer
       end
 
       def run
-        make_folder(@account.local_path, @folder, 'g-wrx,o-wrx')
-        destination_path = File.join(@account.local_path, @folder)
-        @account.each_uid(@folder) do |uid|
-          message_filename = "#{destination_path}/%012u.json" % uid.to_i
-          next if File.exist?(message_filename)
-
-          message = @account.fetch(uid)
-
-          File.open(message_filename, 'w') { |f| f.write message.to_json }
-          FileUtils.chmod 0600, message_filename
+        uids = @folder.uids - @serializer.uids
+        uids.each do |uid|
+          message = @folder.fetch(uid)
+          @serializer.save(uid, message)
         end
       end
 

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

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+module Imap
+  module Backup
+    module Serializer
+      class Directory
+
+        include Imap::Backup::Utils
+
+        def initialize(path, folder)
+          @path, @folder = path, folder
+          check_permissions(@path, 0700)
+          make_folder(@path, @folder, 'g-wrx,o-wrx')
+        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
+  end
+end
+

data/lib/imap/backup/settings.rb

@@ -7,18 +7,25 @@ module Imap
 
       include Imap::Backup::Utils
 
-      def initialize
+      attr_reader :accounts
+
+      def initialize(accounts = nil)
         config_pathname = File.expand_path('~/.imap-backup/config.json')
         raise "Configuration file '#{config_pathname}' not found" if ! File.exist?(config_pathname)
         check_permissions(config_pathname, 0600)
-        @settings = JSON.load(File.open(config_pathname))
+        @settings = JSON.parse(File.read(config_pathname), :symbolize_names => true)
+        if accounts.nil?
+          @accounts = @settings[:accounts]
+        else
+          @accounts = @settings[:accounts].select{ |account| accounts.include?(account[:username]) }
+        end
       end
 
-      def each_account
-        @settings['accounts'].each do |account|
-          a = Account.new(account)
-          yield a
-          a.disconnect
+      def each_connection
+        @accounts.each do |account|
+          connection = Imap::Backup::Account::Connection.new(account)
+          yield connection
+          connection.disconnect
         end
       end
 

data/lib/imap/backup/version.rb

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

data/spec/unit/account/connection_spec.rb

@@ -0,0 +1,117 @@
+# encoding: utf-8
+load File.expand_path( '../../spec_helper.rb', File.dirname(__FILE__) )
+
+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
+
+  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(@account) }
+
+    context '#disconnect' do
+      it 'should disconnect from the server' do
+        @imap.should_receive(:disconnect)
+
+        subject.disconnect
+      end
+    end
+
+    context '#folders' do
+      it 'should list all folders' do
+        @imap.should_receive(:list).with('/', '*')
+
+        subject.folders
+      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
+
+      it 'should return the names of folders' do
+        subject.status[0][:name].should == 'my_folder'
+      end
+
+      it 'should list local message uids' do
+        @serializer.should_receive(:uids).and_return([321, 456])
+
+        subject.status[0][:local].should == [321, 456]
+      end
+
+      it 'should retrieve the available uids' do
+        @folder.should_receive(:uids).and_return([101, 234])
+
+        subject.status[0][:remote].should == [101, 234]
+      end
+
+    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::Directory.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 'should instantiate folders' do
+        Imap::Backup::Account::Folder.should_receive(:new).with(subject, 'my_folder').and_return(@folder)
+
+        subject.run_backup
+      end
+
+      it 'should instantiate serializers' do
+        Imap::Backup::Serializer::Directory.should_receive(:new).with('/base/path', 'my_folder').and_return(@serializer)
+
+        subject.run_backup
+      end
+
+      it 'should instantiate downloaders' do
+        Imap::Backup::Downloader.should_receive(:new).with(@folder, @serializer).and_return(@downloader)
+
+        subject.run_backup
+      end
+
+      it 'should run downloaders' do
+        @downloader.should_receive(:run)
+
+        subject.run_backup
+      end
+
+    end
+
+  end
+
+end
+

data/spec/unit/account/folder_spec.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+load File.expand_path('../../spec_helper.rb', File.dirname(__FILE__))
+
+describe Imap::Backup::Account::Folder do
+
+  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') }
+
+    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])
+
+        subject.uids.should == [123, 5678]
+      end
+
+    end
+
+    context '#fetch' do
+      before :each do
+        @message_body = 'the body'
+        @message = {
+          '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).
+              with([123], ['RFC822', 'FLAGS', 'INTERNALDATE']).
+              and_return([[nil, @message]])
+
+        subject.fetch(123)
+      end
+
+      if RUBY_VERSION > '1.9'
+        it 'should set the encoding on the message' do
+          @imap.stub!(:examine => nil, :uid_fetch => [[nil, @message]])
+
+          @message_body.should_receive(:force_encoding).with('utf-8')
+
+          subject.fetch(123)
+        end
+      end
+
+    end
+
+  end
+
+end
+

data/spec/unit/downloader_spec.rb

@@ -3,129 +3,78 @@ load File.expand_path( '../spec_helper.rb', File.dirname(__FILE__) )
 
 describe Imap::Backup::Downloader do
 
-  context '#initialize' do
-
-    it 'should fail if download path file permissions are to lax' do
-      account = stub('Imap::Backup::Account', :local_path => 'foobar')
-      stat = stub('File::Stat', :mode => 0345)
-      File.should_receive(:stat).with('foobar').and_return(stat)
-
-      expect do
-        Imap::Backup::Downloader.new(account, 'foo')
-      end.to raise_error(RuntimeError, "Permissions on 'foobar' should be 0700, not 0345")
-    end
-
-  end
-
-  context '#run' do
+  context 'with account and downloader' do
 
     before :each do
-      stat    = stub('File::Stat', :mode => 0700)
-      File.stub!(:stat => stat)
-
-      @account = stub('Imap::Backup::Account', :local_path => '/base/path')
-      @d       = Imap::Backup::Downloader.new(@account, 'my_folder')
+      local_path = '/base/path'
+      stat       = stub('File::Stat', :mode => 0700)
+      File.stub!(:stat).with(local_path).and_return(stat)
+
+      @message = {
+        '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
 
-    it 'should create the folder and update permissions' do
-      @account.stub!(:each_uid)
-      FileUtils.should_receive(:mkdir_p).with('/base/path/my_folder')
-      FileUtils.should_receive(:chmod_R).with('g-wrx,o-wrx', '/base/path/my_folder')
+    subject { Imap::Backup::Downloader.new(@folder, @serializer) }
 
-      @d.run
-    end
+    context '#run' do
 
-    context 'with folder' do
-      before :each do
-        FileUtils.stub!(:mkdir_p)
-        FileUtils.stub!(:chmod_R)
-      end
-
-      it 'should list messages' do
-        @account.should_receive(:each_uid)
-
-        @d.run
-      end
-
-      context 'with messages' do
-        before :each do
-          @account.should_receive(:each_uid) do |&block|
-            block.call '123'
-            block.call '999'
-            block.call '1234'
-          end
-        end
+      context 'with folder' do
 
-        it 'should check if messages exist' do
-          File.should_receive(:exist?).with(%r{/base/path/my_folder/\d+.json}).exactly(3).times.and_return(true)
+        it 'should list messages' do
+          @folder.should_receive(:uids).and_return([])
 
-          @d.run
+          subject.run
         end
 
-        it 'should skip messages that are downloaded' do
-          File.stub!(:exist?).and_return(true)
-
-          @account.should_not_receive(:fetch)
-
-          @d.run
-        end
-
-        context 'to download' do
+        context 'with messages' do
           before :each do
-            # N.B. messages 999 and 1234 wil be 'fetched'
-            File.stub!(:exist?) do |path|
-              if path =~ %r{123.json$}
-                true
-              else
-                false
-              end
-            end
-
-            @message = {
-              'RFC822' => 'the body',
-              'other'  => 'xxx'
-            }
-            @account.stub!(:fetch => @message)
-            File.stub!(:open)
-            FileUtils.stub!(:chmod)
+            @folder.stub!(:uids).and_return(['123', '999', '1234'])
           end
 
-          it 'should request messages' do
-            @account.should_receive(:fetch).with('999')
-            @account.should_receive(:fetch).with('1234')
+          it 'should skip messages that are downloaded' do
+            File.stub!(:exist?).and_return(true)
 
-            @d.run
+            @serializer.should_not_receive(:fetch)
+
+            subject.run
           end
 
-          it 'should save messages' do
-            file = stub('File')
-            File.should_receive(:open) do |&block|
-              block.call file
+          context 'to download' do
+            before :each do
+              @serializer.stub!(:exist?) do |uid|
+                if uid == '123'
+                  true
+                else
+                  false
+                end
+              end
             end
-            file.should_receive(:write).with(/the body/)
 
-            @d.run
-          end
+            it 'should request messages' do
+              @folder.should_receive(:fetch).with('999')
+              @folder.should_receive(:fetch).with('1234')
 
-          it 'should JSON encode messages' do
-            file = stub('File', :write => nil)
-            File.stub!(:open) do |&block|
-              block.call file
+              subject.run
             end
 
-            @message.should_receive(:to_json).twice
+            it 'should save messages' do
+              @serializer.should_receive(:save).with('999', @message)
+              @serializer.should_receive(:save).with('1234', @message)
 
-            @d.run
-          end
-
-          it 'should set file permissions' do
-            FileUtils.should_receive(:chmod).with(0600, /999.json$/)
-            FileUtils.should_receive(:chmod).with(0600, /1234.json$/)
+              subject.run
+            end
 
-            @d.run
           end
 
         end
+
       end
 
     end

data/spec/unit/serializer/directory_spec.rb

@@ -0,0 +1,100 @@
+# encoding: utf-8
+
+load File.expand_path('../../spec_helper.rb', File.dirname(__FILE__))
+
+describe Imap::Backup::Serializer::Directory do
+
+  context '#initialize' do
+
+    it 'should fail if download path file permissions are to lax' do
+      stat = stub('File::Stat', :mode => 0345)
+      File.should_receive(:stat).with('/base/path').and_return(stat)
+
+      expect do
+        Imap::Backup::Serializer::Directory.new('/base/path', 'my_folder')
+      end.to raise_error(RuntimeError, "Permissions on '/base/path' should be 0700, not 0345")
+    end
+
+  end
+
+  context 'with object' do
+
+    before :each do
+      stat = stub('File::Stat', :mode => 0700)
+      File.stub!(:stat).with('/base/path').and_return(stat)
+      FileUtils.stub!(:mkdir_p).with('/base/path/my_folder')
+      FileUtils.stub!(:chmod_R).with('g-wrx,o-wrx', '/base/path/my_folder')
+    end
+
+    subject { Imap::Backup::Serializer::Directory.new('/base/path', 'my_folder') }
+
+    context '#uids' do
+
+      it 'should return the backed-up uids' do
+        files = ['00000123.json', '000001.json']
+
+        File.should_receive(:exist?).with('/base/path/my_folder').and_return(true)
+        Dir.should_receive(:open).with('/base/path/my_folder').and_return(files)
+
+        subject.uids.should == [1, 123]
+      end
+
+      it 'should return an empty Array if the directory does not exist' do
+        File.should_receive(:exist?).with('/base/path/my_folder').and_return(false)
+
+        subject.uids.should == []
+      end
+
+    end
+
+    context '#exist?' do
+
+      it 'should check if the file exists' do
+        File.should_receive(:exist?).with(%r{/base/path/my_folder/0+123.json}).and_return(true)
+
+        subject.exist?(123).should be_true
+      end
+
+    end
+
+    context '#save' do
+
+      before :each do
+        File.stub!(:exist?).with(%r{/base/path/my_folder/0+1234.json}).and_return(true)
+        FileUtils.stub!(:chmod).with(0600, /0+1234.json$/)
+        @message = {
+          'RFC822' => 'the body',
+          'other'  => 'xxx'
+        }
+        @file = stub('File', :write => nil)
+        File.stub!(:open) do |&block|
+          block.call @file
+        end
+      end
+
+      it 'should save messages' do
+        File.should_receive(:open) do |&block|
+          block.call @file
+        end
+        @file.should_receive(:write).with(/the body/)
+
+        subject.save('1234', @message)
+      end
+
+      it 'should JSON encode messages' do
+        @message.should_receive(:to_json)
+
+        subject.save('1234', @message)
+      end
+
+      it 'should set file permissions' do
+        FileUtils.should_receive(:chmod).with(0600, /0+1234.json$/)
+
+        subject.save(1234, @message)
+      end
+    end
+
+  end
+
+end
+

data/spec/unit/settings_spec.rb

@@ -3,6 +3,24 @@ load File.expand_path( '../spec_helper.rb', File.dirname(__FILE__) )
 
 describe Imap::Backup::Settings do
 
+  before :each do
+    @settings = {
+      :accounts => [
+        {
+          :username => 'a1@example.com'
+        },
+        {
+          :username => 'a2@example.com',
+        },
+      ]
+    }
+    File.stub!(:exist?).and_return(true)
+    stat = stub('File::Stat', :mode => 0600)
+    File.stub!(:stat).and_return(stat)
+    File.stub!(:read)
+    JSON.stub!(:parse).and_return(@settings)
+  end
+
   context '#initialize' do
 
     it 'should fail if the config file is missing' do
@@ -30,52 +48,59 @@ describe Imap::Backup::Settings do
       stat = stub('File::Stat', :mode => 0600)
       File.stub!(:stat).and_return(stat)
 
-      file = stub('file')
-      File.should_receive(:open).with(%r{/.imap-backup/config.json}).and_return(file)
-      JSON.should_receive(:load).with(file)
+      configuration = 'JSON string'
+      File.should_receive(:read).with(%r{/.imap-backup/config.json}).and_return(configuration)
+      JSON.should_receive(:parse).with(configuration, :symbolize_names => true)
 
       Imap::Backup::Settings.new
     end
 
+    context 'with account parameter' do
+      it 'should only create requested accounts' do
+        settings = Imap::Backup::Settings.new(['a2@example.com'])
+
+        settings.accounts.should == @settings[:accounts][1..1]
+      end
+    end
+
   end
 
-  context '#each_account' do
+  context 'instance methods' do
+
     before :each do
-      @account1_settings = stub('account1 settings')
-      settings = {
-        'accounts' => [
-          @account1_settings
-        ]
-      }
-      File.stub!(:open)
-      JSON.stub!(:load).and_return(settings)
-      @account = stub('Imap::Backup::Settings', :disconnect => nil)
+      @connection = stub('Imap::Backup::Account::Connection', :disconnect => nil)
     end
 
     subject { Imap::Backup::Settings.new }
 
-    it 'should create accounts' do
-      Imap::Backup::Account.should_receive(:new).with(@account1_settings).and_return(@account)
-      subject.each_account {}
-    end
+    context '#each_connection' do
 
-    it 'should call the block' do
-      Imap::Backup::Account.stub!(:new).and_return(@account)
-      calls = 0
+      it 'should instantiate connections' do
+        Imap::Backup::Account::Connection.should_receive(:new).with(@settings[:accounts][0]).and_return(@connection)
+        Imap::Backup::Account::Connection.should_receive(:new).with(@settings[:accounts][1]).and_return(@connection)
 
-      subject.each_account do |a|
-        calls += 1
-        a.should == @account
+        subject.each_connection{}
       end
-      calls.should == 1
-    end
 
-    it 'should disconnect the account' do
-      Imap::Backup::Account.stub!(:new).and_return(@account)
+      it 'should call the block' do
+        Imap::Backup::Account::Connection.stub!(:new).and_return(@connection)
+        calls = 0
+
+        subject.each_connection do |a|
+          calls += 1
+          a.should == @connection
+        end
+        calls.should == 2
+      end
 
-      @account.should_receive(:disconnect)
+      it 'should disconnect connections' do
+        Imap::Backup::Account::Connection.stub!(:new).and_return(@connection)
+
+        @connection.should_receive(:disconnect)
+
+        subject.each_connection {}
+      end
 
-      subject.each_account {}
     end
 
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: imap-backup
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,8 +9,24 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-10 00:00:00.000000000 Z
+date: 2012-06-11 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: pry
   requirement: !ruby/object:Gem::Requirement
@@ -92,15 +108,19 @@ files:
 - bin/imap-backup
 - imap-backup.gemspec
 - lib/imap/backup.rb
-- lib/imap/backup/account.rb
+- lib/imap/backup/account/connection.rb
+- lib/imap/backup/account/folder.rb
 - lib/imap/backup/downloader.rb
+- lib/imap/backup/serializer/directory.rb
 - lib/imap/backup/settings.rb
 - lib/imap/backup/utils.rb
 - lib/imap/backup/version.rb
 - spec/gather_rspec_coverage.rb
 - spec/spec_helper.rb
-- spec/unit/account_spec.rb
+- spec/unit/account/connection_spec.rb
+- spec/unit/account/folder_spec.rb
 - spec/unit/downloader_spec.rb
+- spec/unit/serializer/directory_spec.rb
 - spec/unit/settings_spec.rb
 - spec/unit/utils_spec.rb
 homepage: https://github.com/joeyates/imap-backup
@@ -117,7 +137,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3027570741254356503
+      hash: 3223776400470663453
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -126,7 +146,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3027570741254356503
+      hash: 3223776400470663453
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -136,8 +156,10 @@ summary: Backup GMail (or other IMAP) accounts to disk
 test_files:
 - spec/gather_rspec_coverage.rb
 - spec/spec_helper.rb
-- spec/unit/account_spec.rb
+- spec/unit/account/connection_spec.rb
+- spec/unit/account/folder_spec.rb
 - spec/unit/downloader_spec.rb
+- spec/unit/serializer/directory_spec.rb
 - spec/unit/settings_spec.rb
 - spec/unit/utils_spec.rb
 has_rdoc: 

data/lib/imap/backup/account.rb

@@ -1,42 +0,0 @@
-require 'net/imap'
-
-module Imap
-  module Backup
-    class Account
-
-      REQUESTED_ATTRIBUTES = ['RFC822', 'FLAGS', 'INTERNALDATE']
-
-      attr_accessor :local_path
-      attr_accessor :backup_folders
-
-      def initialize(options)
-        @local_path, @backup_folders = options['local_path'], options['folders']
-        @imap = Net::IMAP.new('imap.gmail.com', 993, true)
-        @imap.login(options['username'], options['password'])
-      end
-
-      def disconnect
-        @imap.disconnect
-      end
-
-      def folders
-        @imap.list('/', '*')
-      end
-
-      def each_uid(folder)
-        @imap.examine(folder)
-        @imap.uid_search(['ALL']).each do |uid|
-          yield uid
-        end
-      end
-
-      def fetch(uid)
-        message = @imap.uid_fetch([uid], REQUESTED_ATTRIBUTES)[0][1]
-        message['RFC822'].force_encoding('utf-8') if RUBY_VERSION > '1.9'
-        message
-      end
-
-    end
-  end
-end
-

data/spec/unit/account_spec.rb

@@ -1,95 +0,0 @@
-# encoding: utf-8
-load File.expand_path( '../spec_helper.rb', File.dirname(__FILE__) )
-
-describe Imap::Backup::Account 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.new('username' => 'myuser', 'password' => 'secret')
-    end
-
-  end
-
-  context 'with imap' do
-    before :each do
-      @imap = stub('Net::IMAP', :login => nil)
-      Net::IMAP.stub!(:new).and_return(@imap)
-    end
-
-    subject { Imap::Backup::Account.new('username' => 'myuser', 'password' => 'secret') }
-
-    context '#disconnect' do
-      it 'should disconnect from the server' do
-        @imap.should_receive(:disconnect)
-
-        subject.disconnect
-      end
-    end
-
-    context '#folders' do
-      it 'should list all folders' do
-        @imap.should_receive(:list).with('/', '*')
-
-        subject.folders
-      end
-    end
-
-    context '#each_uid' do
-      it 'should examine the folder' do
-        @imap.stub!(:uid_search => [])
-        @imap.should_receive(:examine).with('my_folder')
-
-        subject.each_uid('my_folder') {}
-      end
-
-      it 'should call the block with each message uid' do
-        @imap.stub!(:examine).with('my_folder')
-        @imap.should_receive(:uid_search).with(['ALL']).and_return(['123', '456'])
-
-        uids = []
-        subject.each_uid('my_folder') do |uid|
-          uids << uid
-        end
-
-        uids.should == ['123', '456']
-      end
-    end
-
-    context '#fetch' do
-      before :each do
-        @message_body = 'the body'
-        @message = {
-          'RFC822' => @message_body,
-          'other'  => 'xxx'
-        }
-      end
-
-      it 'should request the message, the flags and the date' do
-        @imap.should_receive(:uid_fetch).
-              with(['123'], ['RFC822', 'FLAGS', 'INTERNALDATE']).
-              and_return([[nil, @message]])
-
-        subject.fetch('123')
-      end
-
-      if RUBY_VERSION > '1.9'
-        it 'should set the encoding on the message' do
-          @imap.stub!(:uid_fetch => [[nil, @message]])
-
-          @message_body.should_receive(:force_encoding).with('utf-8')
-
-          subject.fetch('123')
-        end
-      end
-
-    end
-
-  end
-
-end
-