cloud_encrypted_sync 0.1.0 → 0.1.1

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    cloud_encrypted_sync (0.0.1)
+    cloud_encrypted_sync (0.1.1)
 
 GEM
   remote: http://rubygems.org/

data/README.md

@@ -23,10 +23,6 @@ preferred cloud.
 CES runs as a command line tool and takes options as CLI arguments and/or from a config file.
 Arguments passed at the command line take precedence over those in the config file.
 
-### Creating a valid encryption key and initialization vector.
-
-TODO
-
 ### Example
 
     ces --adapter=s3 --bucket=my-backup-bucket \

data/lib/cloud_encrypted_sync/adapter_liaison.rb

@@ -0,0 +1,57 @@
+module CloudEncryptedSync
+  class AdapterLiaison
+    include Singleton
+
+    def initialize
+      find_and_require_adapters
+    end
+
+    def push(data,key)
+      adapter.write(Cryptographer.encrypt_data(data),key)
+    end
+
+    def pull(key)
+      Cryptographer.decrypt_data(adapter.read(key))
+    end
+
+    def delete(key)
+      adapter.delete(key)
+    end
+
+    def key_exists?(key)
+      adapter.key_exists?(key)
+    end
+
+    def adapters
+      Adapters::Template.children
+    end
+
+    #######
+    private
+    #######
+
+    def find_and_require_adapters
+      latest_versions_of_installed_adapters.each_pair do |adapter_name,adapter_version|
+        require File.expand_path("../../../../cloud_encrypted_sync_#{adapter_name}_adapter-#{adapter_version}", __FILE__)
+      end
+    end
+
+    def latest_versions_of_installed_adapters
+      glob_path = '../../../../cloud_encrypted_sync_*_adapter-*/lib/*.rb'
+      Dir.glob(File.expand_path(glob_path,__FILE__)).inject({}) do |hash,adapter_path|
+        if adapter_path.match(/cloud_encrypted_sync_(.+)_adapter-(.+)/)
+          adapter_name = $1
+          adapter_version = $2
+          if hash[adapter_name].to_s < adapter_version
+            hash[adapter_name] = adapter_version
+          end
+        end
+        hash
+      end
+    end
+
+    def adapter
+      adapters[Configuration.settings[:adapter_name].to_sym]
+    end
+  end
+end

data/lib/cloud_encrypted_sync/adapter_template.rb

@@ -5,29 +5,49 @@ module CloudEncryptedSync
       class << self
 
         def inherited(subclass)
-          Master.register(subclass)
+          register_subclass_with_parent(subclass)
+        end
+
+        def children
+          @children ||= {}
         end
 
         def parse_command_line_options(opts,command_line_options)
-          raise 'called template method: parse_command_line_options'
+          raise Errors::TemplateMethodCalled.new('parse_command_line_options')
         end
 
         def write(data, key)
-          raise 'called template method: write'
+          raise Errors::TemplateMethodCalled.new('write')
         end
 
         def read(key)
-          raise 'called template method: read'
+          raise Errors::TemplateMethodCalled.new('read')
         end
 
         def delete(key)
-          raise 'called template method: delete'
+          raise Errors::TemplateMethodCalled.new('delete')
         end
 
         def key_exists?(key)
-          raise 'called template method: key_exists?'
+          raise Errors::TemplateMethodCalled.new('key_exists?')
         end
 
+        #######
+        private
+        #######
+
+        def register_subclass_with_parent(subclass)
+          name = formated_name_of(subclass)
+          if children[name]
+            raise Errors::RegistrationError.new("#{name} already registered")
+          else
+            children[name] = subclass
+          end
+        end
+
+        def formated_name_of(subclass)
+          subclass.name.match(/([^:]+)$/)[0].underscore.to_sym
+        end
       end
     end
   end

data/lib/cloud_encrypted_sync/configuration.rb

@@ -1,5 +1,3 @@
-require 'yaml'
-
 module CloudEncryptedSync
   class Configuration
 
@@ -32,10 +30,10 @@ module CloudEncryptedSync
 
         if loaded_settings[:sync_path].nil?
           message = "You must supply a path to a folder to sync.\n\n#{option_parser.help}"
-          raise IncompleteConfigurationError.new(message)
+          raise Errors::IncompleteConfigurationError.new(message)
         elsif loaded_settings[:encryption_key].nil? or loaded_settings[:encryption_key].empty?
           message = "You must supply an encryption key.\n\n#{option_parser.help}"
-          raise IncompleteConfigurationError.new(message)
+          raise Errors::IncompleteConfigurationError.new(message)
         end
 
         return loaded_settings
@@ -64,7 +62,7 @@ module CloudEncryptedSync
           end
           opts.on('--adapter ADAPTERNAME', 'Name of cloud adapter to use.') do |adapter_name|
             clo[:adapter_name] = adapter_name
-            clo = Master.adapters[adapter_name.to_sym].parse_command_line_options(opts,clo)
+            clo = AdapterLiaison.instance.adapters[adapter_name.to_sym].parse_command_line_options(opts,clo)
           end
           opts.on('--encryption-key KEY') do |key|
             clo[:encryption_key] = key
@@ -77,6 +75,4 @@ module CloudEncryptedSync
 
     end
   end
-
-  class IncompleteConfigurationError < RuntimeError; end
 end

data/lib/cloud_encrypted_sync/cryptographer.rb

@@ -1,6 +1,3 @@
-require 'openssl'
-require 'digest'
-
 module CloudEncryptedSync
   class Cryptographer
     ALGORITHM = 'AES-256-CBC'

data/lib/cloud_encrypted_sync/dummy_adapter.rb

@@ -16,7 +16,7 @@ module CloudEncryptedSync
         end
 
         def read(key)
-          raise "key doesn't exist" unless key_exists?(key)
+          raise Errors::NoSuchKey.new("key doesn't exist: #{key}") unless key_exists?(key)
           stored_data[bucket_name][key]
         end
 
@@ -37,7 +37,6 @@ module CloudEncryptedSync
         end
 
         def bucket_name
-          raise RuntimeError, Configuration.settings.inspect
           Configuration.settings[:bucket_name].to_sym
         end
 

data/lib/cloud_encrypted_sync/errors.rb

@@ -0,0 +1,8 @@
+module CloudEncryptedSync
+  module Errors
+    class RegistrationError < RuntimeError; end
+    class IncompleteConfigurationError < RuntimeError; end
+    class NoSuchKey < RuntimeError; end
+    class TemplateMethodCalled < RuntimeError; end
+  end
+end

data/lib/cloud_encrypted_sync/index.rb

@@ -0,0 +1,86 @@
+module CloudEncryptedSync
+  class Index
+
+    class << self
+
+      def local
+        @local ||= compile_local_hash
+      end
+
+      def remote
+        @remote ||= begin
+          YAML.parse(liaison.pull(index_key)).to_ruby
+        rescue Errors::NoSuchKey
+          {}
+        end
+      end
+
+      def write
+        local_hash = compile_local_hash #recompile
+        liaison.push(local_hash.to_yaml,index_key) #push to remote
+        File.open(snapshot_path, 'w') { |file| YAML.dump(local_hash, file) } #save to local
+      end
+
+      def full_file_path(relative_path)
+        normalized_sync_path+'/'+relative_path
+      end
+
+      def snapshot_path
+        "#{Configuration.data_folder_path}/#{snapshot_filename}"
+      end
+
+      def file_key(full_path)
+        Cryptographer.hash_data(relative_file_path(full_path) + File.open(full_path).read).to_s
+      end
+
+      #######
+      private
+      #######
+
+      def liaison
+        AdapterLiaison.instance
+      end
+
+      def compile_local_hash
+        hash = {}
+        progress_meter = ProgressMeter.new(Dir["#{normalized_sync_path}/**/*"].length,:label => 'Compiling Local Index: ')
+        completed_files = 0
+        Find.find(normalized_sync_path) do |path|
+          print progress_meter.update(completed_files)
+          unless FileTest.directory?(path)
+            hash[file_key(path)] = relative_file_path(path)
+          end
+          completed_files += 1
+        end
+        puts #newline for progress meter
+        return hash
+      end
+
+      def index_key
+        @index_key ||= Cryptographer.hash_data(Configuration.settings[:encryption_key])
+      end
+
+      def snapshot_filename
+        "#{normalized_sync_path.gsub(/[^A-Za-z0-9]/,'_')}.index.yml"
+      end
+
+      def relative_file_path(full_path)
+        full_path.gsub(normalized_sync_path,'')
+      end
+
+      def normalized_sync_path
+        @normalized_sync_path ||= normalize_sync_path
+      end
+
+      def normalize_sync_path
+        path = Configuration.settings[:sync_path]
+        if path.match(/\/$/)
+          return path
+        else
+          return path + '/'
+        end
+      end
+
+    end
+  end
+end

data/lib/cloud_encrypted_sync/master.rb

@@ -1,23 +1,10 @@
-require 'find'
-require 'active_support/core_ext/string'
-
 module CloudEncryptedSync
   class Master
 
     class << self
       attr_accessor :finalize_required
-      attr_reader   :command_line_options, :adapters
-      attr_writer   :sync_path
-
-      def register(adapter)
-        @adapters ||= {}
-        name = adapter.name.match(/([^:]+)$/)[0].underscore.to_sym
-        raise RegistrationError, "#{name} already registered" if @adapters[name]
-        @adapters[name] = adapter
-      end
 
       def activate!
-        find_and_require_adapters
         sync
       end
 
@@ -28,7 +15,7 @@ module CloudEncryptedSync
           CloudEncryptedSync::Master.pull_files!
           CloudEncryptedSync::Master.push_files!
           CloudEncryptedSync::Master.finalize!
-        rescue IncompleteConfigurationError => exception
+        rescue Errors::IncompleteConfigurationError => exception
           puts exception.message
         end
       end
@@ -37,12 +24,13 @@ module CloudEncryptedSync
         progress_meter = ProgressMeter.new(files_to_pull.keys.size,:label => 'Pushing Files: ')
         pushed_files_counter = 0
         files_to_push.each_pair do |key,relative_path|
-          if adapter.key_exists?(key)
+          puts #newline for progress meter
+          if liaison.key_exists?(key)
             #already exists. probably left over from an earlier aborted push
             puts "Not Pushing (already exists): #{relative_path}"
           else
             puts "Pushing: #{relative_path}"
-            encrypt_to_adapter(File.read(full_file_path(relative_path)),key)
+            liaison.push(File.read(Index.full_file_path(relative_path)),key)
             self.finalize_required = true
           end
           pushed_files_counter += 1
@@ -54,17 +42,18 @@ module CloudEncryptedSync
         progress_meter = ProgressMeter.new(files_to_pull.keys.size,:label => 'Pulling Files: ')
         pulled_files_counter = 0
         files_to_pull.each_pair do |key,relative_path|
-          full_path = full_file_path(relative_path)
-          if File.exist?(full_path) and (file_key(full_path) == key)
+          full_path = Index.full_file_path(relative_path)
+          puts #newline for progress meter
+          if File.exist?(full_path) and (Index.file_key(full_path) == key)
             #already exists. probably left over from an earlier aborted pull
             puts "Not Pulling (already exists): #{path}"
           else
             Dir.mkdir(File.dirname(full_path)) unless File.exist?(File.dirname(full_path))
             puts "Pulling: #{relative_path}"
             begin
-              File.open(full_path,'w') { |file| file.write(decrypt_from_adapter(key)) }
+              File.open(full_path,'w') { |file| file.write(liaison.pull(key)) }
               self.finalize_required = true
-            rescue #AWS::S3::Errors::NoSuchKey  Should provide error for adapters to raise
+            rescue Errors::NoSuchKey
               puts "Failed to pull #{relative_path}"
             end
           end
@@ -76,15 +65,15 @@ module CloudEncryptedSync
       def delete_remote_files!
         remote_files_to_delete.each_pair do |key,path|
           puts "Deleting Remote: #{path}"
-          adapter.delete(key)
+          liaison.delete(key)
           self.finalize_required = true
         end
       end
 
       def delete_local_files!
         local_files_to_delete.each_pair do |key,relative_path|
-          full_path = full_file_path(relative_path)
-          if !File.exist?(full_path) or (file_key(full_path) == key)
+          full_path = Index.full_file_path(relative_path)
+          if !File.exist?(full_path) or (Index.file_key(full_path) == key)
             puts "Not Deleting Local: #{relative_path}"
           else
             puts "Deleting Local: #{relative_path}"
@@ -95,119 +84,39 @@ module CloudEncryptedSync
       end
 
       def finalize!
-        if finalize_required
-          store_directory_hash_file
-          File.open(snapshot_file_path, 'w') { |file| YAML.dump(directory_hash, file) }
-        end
+        Index.write if finalize_required
       end
 
       #######
       private
       #######
 
-      def find_and_require_adapters
-        latest_versions_of_installed_adapters.each_pair do |adapter_name,adapter_version|
-          require File.expand_path("../../../../cloud_encrypted_sync_#{adapter_name}_adapter-#{adapter_version}", __FILE__)
-        end
-      end
-
-      def latest_versions_of_installed_adapters
-        glob_path = '../../../../cloud_encrypted_sync_*_adapter-*/lib/*.rb'
-        Dir.glob(File.expand_path(glob_path,__FILE__)).inject({}) do |hash,adapter_path|
-          if adapter_path.match(/cloud_encrypted_sync_(.+)_adapter-(.+)/)
-            adapter_name = $1
-            adapter_version = $2
-            if hash[adapter_name].to_s < adapter_version
-              hash[adapter_name] = adapter_version
-            end
-          end
-          hash
-        end
-      end
-
-      def adapter
-        @adapters[Configuration.settings[:adapter_name].to_sym]
-      end
-
-      def encrypt_to_adapter(data,key)
-        adapter.write(Cryptographer.encrypt_data(data),key)
-      end
-
-      def decrypt_from_adapter(key)
-        Cryptographer.decrypt_data(adapter.read(key))
-      end
-
-      def directory_hash
-        return @directory_hash if @directory_hash
-        @directory_hash = {}
-        progress_meter = ProgressMeter.new(Dir["#{normalized_sync_path}/**/*"].length,:label => 'Compiling Directory Analysis: ')
-        completed_files = 0
-        Find.find(normalized_sync_path) do |path|
-          print progress_meter.update(completed_files)
-          if FileTest.directory?(path)
-            completed_files += 1
-            next
-          else
-            @directory_hash[file_key(path)] = relative_file_path(path)
-            completed_files += 1
-          end
-        end
-        puts
-        return @directory_hash
-      end
-
-      def directory_key
-        @directory_key ||= Cryptographer.hash_data(Configuration.settings[:encryption_key])
-      end
-
-      def normalized_sync_path
-        @normalized_sync_path ||= normalize_sync_path
-      end
-
-      def normalize_sync_path
-        path = Configuration.settings[:sync_path]
-        if path.match(/\/$/)
-          return path
-        else
-          return path + '/'
-        end
+      def liaison
+        AdapterLiaison.instance
       end
 
       def last_sync_date
-        @last_sync_date ||= File.exist?(snapshot_file_path) ? File.stat(snapshot_file_path).ctime : nil
+        @last_sync_date ||= File.exist?(Index.snapshot_path) ? File.stat(Index.snapshot_path).ctime : nil
       end
 
       def last_sync_hash
-        @last_sync_hash ||= File.exist?(snapshot_file_path) ? YAML.load(File.read(snapshot_file_path)) : {}
+        @last_sync_hash ||= File.exist?(Index.snapshot_path) ? YAML.load(File.read(Index.snapshot_path)) : {}
       end
 
       def files_to_push
-        syncable_files_check(directory_hash,remote_directory_hash)
+        syncable_files_check(Index.local,Index.remote)
       end
 
       def files_to_pull
-        syncable_files_check(remote_directory_hash,directory_hash)
+        syncable_files_check(Index.remote,Index.local)
       end
 
       def remote_files_to_delete
-        deletable_files_check(remote_directory_hash,directory_hash)
+        deletable_files_check(Index.remote,Index.local)
       end
 
       def local_files_to_delete
-        deletable_files_check(directory_hash,remote_directory_hash)
-      end
-
-      def remote_directory_hash
-        @remote_directory_hash ||= begin
-          YAML.parse(decrypt_from_adapter(directory_key)).to_ruby
-        rescue #AWS::S3::Errors::NoSuchKey  should provide error for adapters to raise
-          {}
-        end
-      end
-
-      def store_directory_hash_file
-        @directory_hash = nil #force re-compile before pushing to remote
-        encrypt_to_adapter(directory_hash.to_yaml,directory_key)
+        deletable_files_check(Index.local,Index.remote)
       end
 
       def deletable_files_check(source_hash,comparison_hash)
@@ -222,27 +131,6 @@ module CloudEncryptedSync
         source_hash.select{|k,v| !comparison_hash.has_key?(k) and (last_sync_has_key ? last_sync_hash.has_key?(k) : !last_sync_hash.has_key?(k)) }
       end
 
-      def snapshot_file_path
-        "#{Configuration.data_folder_path}/#{snapshot_filename}"
-      end
-
-      def snapshot_filename
-        "#{normalized_sync_path.gsub(/[^A-Za-z0-9]/,'_')}.snapshot.yml"
-      end
-
-      def file_key(full_path)
-        Cryptographer.hash_data(relative_file_path(full_path) + File.open(full_path).read).to_s
-      end
-
-      def relative_file_path(full_path)
-        full_path.gsub(normalized_sync_path,'')
-      end
-
-      def full_file_path(relative_path)
-        normalized_sync_path+'/'+relative_path
-      end
     end
   end
-
-  class RegistrationError < RuntimeError; end
 end

data/lib/cloud_encrypted_sync/version.rb

@@ -1,3 +1,3 @@
 module CloudEncryptedSync
-  VERSION = '0.1.0'
+  VERSION = '0.1.1'
 end

data/lib/cloud_encrypted_sync.rb

@@ -1,6 +1,17 @@
+require 'singleton'
+require 'yaml'
+require 'openssl'
+require 'digest'
+require 'find'
+require 'active_support/core_ext/string'
+
 require File.expand_path('../cloud_encrypted_sync/master', __FILE__)
+
+require File.expand_path('../cloud_encrypted_sync/adapter_liaison', __FILE__)
+require File.expand_path('../cloud_encrypted_sync/adapter_template', __FILE__)
 require File.expand_path('../cloud_encrypted_sync/configuration', __FILE__)
 require File.expand_path('../cloud_encrypted_sync/cryptographer', __FILE__)
-require File.expand_path('../cloud_encrypted_sync/adapter_template', __FILE__)
 require File.expand_path('../cloud_encrypted_sync/dummy_adapter', __FILE__)
+require File.expand_path('../cloud_encrypted_sync/errors', __FILE__)
+require File.expand_path('../cloud_encrypted_sync/index', __FILE__)
 require File.expand_path('../cloud_encrypted_sync/progress_meter', __FILE__)

data/test/test_helper.rb

@@ -22,7 +22,7 @@ module CloudEncryptedSync
     def preset_environment
       Configuration.instance_variable_set(:@settings,nil)
       Configuration.instance_variable_set(:@command_line_options,nil)
-      Master.instance_variable_set(:@directory_hash, nil)
+      Index.instance_variable_set(:@local, nil)
       FileUtils.mkdir_p test_source_folder
       FileUtils.mkdir_p test_source_folder + '/test_sub_folder'
       File.open(test_source_folder + '/test_sub_folder/test_file_one.txt', 'w') do |test_file|

data/test/unit/adapter_liaison_test.rb

@@ -0,0 +1,32 @@
+require 'test_helper'
+
+module CloudEncryptedSync
+  class AdapterLiaisonTest < ActiveSupport::TestCase
+
+    def setup
+      Configuration.stubs(:settings).returns({
+        :encryption_key => 'asdf',
+        :adapter_name => 'dummy',
+        :bucket => "test-bucket",
+        :sync_path => test_source_folder
+      })
+      Configuration.stubs(:data_folder_path).returns("#{Etc.getpwuid.dir}/.cloud_encrypted_sync")
+    end
+
+    test 'should encrypt when writing' do
+      precrypted_data = File.read(test_source_folder + '/test_sub_folder/test_file_one.txt')
+      key = Cryptographer.hash_data('test_file_key')
+      Adapters::Dummy.expects(:write).with(anything,key).returns(true)
+      AdapterLiaison.instance.push(precrypted_data,key)
+    end
+
+    test 'should decrypt_when_reading' do
+      precrypted_data = File.read(test_source_folder + '/test_sub_folder/test_file_one.txt')
+      encrypted_data = Cryptographer.encrypt_data(precrypted_data)
+      key = Cryptographer.hash_data('test_file_key')
+      Adapters::Dummy.expects(:read).with(key).returns(encrypted_data)
+      assert_equal(precrypted_data,AdapterLiaison.instance.pull(key))
+    end
+
+  end
+end

data/test/unit/configuration_test.rb

@@ -21,12 +21,12 @@ module CloudEncryptedSync
 
     test 'should gracefully fail without path in ARGV' do
       ::ARGV = '--adapter dummy --bucket foobar'.split(/\s/)
-      assert_raise(IncompleteConfigurationError) { Configuration.settings }
+      assert_raise(Errors::IncompleteConfigurationError) { Configuration.settings }
     end
 
     test 'should gracefully fail when not provided encryption_key and vector provided path in ARGV' do
       ::ARGV = '--adapter dummy --bucket foobar /some/path/to/sync'.split(/\s/)
-      assert_raise(IncompleteConfigurationError) { Configuration.settings }
+      assert_raise(Errors::IncompleteConfigurationError) { Configuration.settings }
     end
 
   end

data/test/unit/cryptographer_test.rb

@@ -6,7 +6,6 @@ module CloudEncryptedSync
     def setup
       Configuration.stubs(:settings).returns({
         :encryption_key => 'asdf',
-        :initialization_vector => 'qwerty',
         :adapter_name => 'dummy',
         :bucket => "test-bucket",
         :data_dir => "#{Etc.getpwuid.dir}/.cloud_encrypted_sync",

data/test/unit/master_test.rb

@@ -1,5 +1,4 @@
 require 'test_helper'
-require 'yaml'
 
 module CloudEncryptedSync
   class MasterTest < ActiveSupport::TestCase
@@ -7,7 +6,6 @@ module CloudEncryptedSync
     def setup
       Configuration.stubs(:settings).returns({
         :encryption_key => 'asdf',
-        :initialization_vector => 'qwerty',
         :adapter_name => 'dummy',
         :bucket => "test-bucket",
         :sync_path => test_source_folder
@@ -17,10 +15,10 @@ module CloudEncryptedSync
 
     test 'should generate directory hash' do
       assert_equal('',$stdout.string)
-      hash = Master.send(:directory_hash)
-      assert_match(/\% Complete/,$stdout.string)
+      hash = Index.local
       assert_equal(1,hash.keys.size)
       assert_equal('test_sub_folder/test_file_one.txt',hash[hash.keys.first])
+      assert_match(/\% Complete/,$stdout.string)
     end
 
     test 'should_return_nil_if_never_synced_before' do
@@ -29,25 +27,10 @@ module CloudEncryptedSync
     end
 
     test 'should want to push everything on first run with local files and empty remote' do
-      Master.stubs(:remote_directory_hash).returns({})
-      Master.stubs(:directory_hash).returns({"old_file_key"=>"test_sub_folder/old_file.txt"})
+      Index.stubs(:remote).returns({})
+      Index.stubs(:local).returns({"old_file_key"=>"test_sub_folder/old_file.txt"})
       Master.stubs(:last_sync_hash).returns({})
-      assert_equal(Master.directory_hash,Master.send(:files_to_push))
-    end
-
-    test 'should encrypt when writing' do
-      precrypted_data = File.read(test_source_folder + '/test_sub_folder/test_file_one.txt')
-      key = Cryptographer.hash_data('test_file_key')
-      Adapters::Dummy.expects(:write).with(anything,key).returns(true)
-      Master.send(:encrypt_to_adapter,precrypted_data,key)
-    end
-
-    test 'should decrypt_when_reading' do
-      precrypted_data = File.read(test_source_folder + '/test_sub_folder/test_file_one.txt')
-      encrypted_data = Cryptographer.encrypt_data(precrypted_data)
-      key = Cryptographer.hash_data('test_file_key')
-      Adapters::Dummy.expects(:read).with(key).returns(encrypted_data)
-      assert_equal(precrypted_data,Master.send(:decrypt_from_adapter,key))
+      assert_equal(Index.local,Master.send(:files_to_push))
     end
 
     test 'should push files' do
@@ -61,15 +44,15 @@ module CloudEncryptedSync
     end
 
     test 'should want to pull everything on first run with remote files and empty local' do
-      Master.stubs(:remote_directory_hash).returns({'new_file_key' => 'test_sub_folder/new_file.txt'})
-      Master.stubs(:directory_hash).returns({})
+      Index.stubs(:remote).returns({'new_file_key' => 'test_sub_folder/new_file.txt'})
+      Index.stubs(:local).returns({})
       Master.stubs(:last_sync_hash).returns({})
       assert_equal({'new_file_key' => 'test_sub_folder/new_file.txt'},Master.send(:files_to_pull))
     end
 
     test 'should pull files' do
-      Master.stubs(:remote_directory_hash).returns({'new_file_key' => 'test_sub_folder/new_file.txt'})
-      Master.stubs(:directory_hash).returns({})
+      Index.stubs(:remote).returns({'new_file_key' => 'test_sub_folder/new_file.txt'})
+      Index.stubs(:local).returns({})
       Master.stubs(:last_sync_hash).returns({})
       Adapters::Dummy.expects(:read).with('new_file_key').returns(Cryptographer.encrypt_data('foobar'))
       assert_equal('',$stdout.string)
@@ -80,44 +63,44 @@ module CloudEncryptedSync
     end
 
     test 'should only want to push new files on later run' do
-      Master.stubs(:remote_directory_hash).returns({'old_file_key' => 'test_sub_folder/old_file.txt'})
-      Master.stubs(:directory_hash).returns({'new_file_key' => 'test_sub_folder/new_file.txt', 'old_file_key' => 'test_sub_folder/old_file.txt'})
+      Index.stubs(:remote).returns({'old_file_key' => 'test_sub_folder/old_file.txt'})
+      Index.stubs(:local).returns({'new_file_key' => 'test_sub_folder/new_file.txt', 'old_file_key' => 'test_sub_folder/old_file.txt'})
       Master.stubs(:last_sync_hash).returns({'old_file_key' => 'test_sub_folder/old_file.txt'})
       assert_equal({'new_file_key' => 'test_sub_folder/new_file.txt'},Master.send(:files_to_push))
     end
 
     test 'should want to pull new files from cloud' do
-      Master.stubs(:remote_directory_hash).returns({'new_file_key' => 'test_sub_folder/new_file.txt', 'old_file_key' => 'test_sub_folder/old_file.txt'})
-      Master.stubs(:directory_hash).returns({'old_file_key' => 'test_sub_folder/old_file.txt'})
+      Index.stubs(:remote).returns({'new_file_key' => 'test_sub_folder/new_file.txt', 'old_file_key' => 'test_sub_folder/old_file.txt'})
+      Index.stubs(:local).returns({'old_file_key' => 'test_sub_folder/old_file.txt'})
       Master.stubs(:last_sync_hash).returns({'old_file_key' => 'test_sub_folder/old_file.txt'})
       assert_equal({'new_file_key' => 'test_sub_folder/new_file.txt'},Master.send(:files_to_pull))
     end
 
     test 'should want to delete locally missing files from cloud' do
-      Master.stubs(:remote_directory_hash).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt', 'deleted_file_key' => 'test_sub_folder/deleted_file.txt'})
-      Master.stubs(:directory_hash).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt'})
+      Index.stubs(:remote).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt', 'deleted_file_key' => 'test_sub_folder/deleted_file.txt'})
+      Index.stubs(:local).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt'})
       Master.stubs(:last_sync_hash).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt', 'deleted_file_key' => 'test_sub_folder/deleted_file.txt'})
       assert_equal({'deleted_file_key' => 'test_sub_folder/deleted_file.txt'},Master.send(:remote_files_to_delete))
     end
 
     test 'should delete files from cloud' do
-      Master.stubs(:remote_directory_hash).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt', 'deleted_file_key' => 'test_sub_folder/deleted_file.txt'})
-      Master.stubs(:directory_hash).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt'})
+      Index.stubs(:remote).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt', 'deleted_file_key' => 'test_sub_folder/deleted_file.txt'})
+      Index.stubs(:local).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt'})
       Master.stubs(:last_sync_hash).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt', 'deleted_file_key' => 'test_sub_folder/deleted_file.txt'})
       Adapters::Dummy.expects(:delete).with('deleted_file_key').returns(true)
       Master.delete_remote_files!
     end
 
     test 'should want to delete appropriate files locally' do
-      Master.stubs(:remote_directory_hash).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt'})
-      Master.stubs(:directory_hash).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt', 'deleted_file_key' => 'test_sub_folder/deleted_file.txt'})
+      Index.stubs(:remote).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt'})
+      Index.stubs(:local).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt', 'deleted_file_key' => 'test_sub_folder/deleted_file.txt'})
       Master.stubs(:last_sync_hash).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt', 'deleted_file_key' => 'test_sub_folder/deleted_file.txt'})
       assert_equal({'deleted_file_key' => 'test_sub_folder/deleted_file.txt'},Master.send(:local_files_to_delete))
     end
 
     test 'should delete local files' do
-      Master.stubs(:remote_directory_hash).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt'})
-      Master.stubs(:last_sync_hash).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt', 'deleted_file_key' => 'test_sub_folder/deleted_file.txt'}.merge(Master.send(:directory_hash)))
+      Index.stubs(:remote).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt'})
+      Master.stubs(:last_sync_hash).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt', 'deleted_file_key' => 'test_sub_folder/deleted_file.txt'}.merge(Index.local))
       assert_difference('Dir["#{test_source_folder}/**/*"].length',-1) do
         Master.delete_local_files!
       end
@@ -128,7 +111,7 @@ module CloudEncryptedSync
       sample_directory_hash = {'sample_file_key' => 'test_sub_folder/sample_file.txt'}
       Master.instance_variable_set(:@finalize_required,true)
       Master.stubs(:directory_hash).returns(sample_directory_hash)
-      Adapters::Dummy.expects(:write).with(anything,Master.send(:directory_key)).returns(true)
+      Adapters::Dummy.expects(:write).with(anything,Index.send(:index_key)).returns(true)
       Master.finalize!
     end
 
@@ -136,15 +119,15 @@ module CloudEncryptedSync
       #setup mock data
       sample_directory_hash = {'sample_file_key' => 'test_sub_folder/sample_file.txt'}
       encrypted_directory_hash = Cryptographer.encrypt_data(sample_directory_hash.to_yaml)
-      Adapters::Dummy.stubs(:read).with(Master.send(:directory_key)).returns(encrypted_directory_hash)
+      Adapters::Dummy.expects(:read).with(Index.send(:index_key)).returns(encrypted_directory_hash)
 
       #do actual test
-      decrypted_remote_hash = Master.send(:remote_directory_hash)
+      decrypted_remote_hash = Index.remote
       assert_equal(sample_directory_hash,decrypted_remote_hash)
     end
 
     test 'should puts error message to stdout' do
-      Configuration.stubs(:settings).raises(IncompleteConfigurationError,'test message')
+      Configuration.stubs(:settings).raises(Errors::IncompleteConfigurationError,'test message')
       assert_equal('',$stdout.string)
       Master.expects(:pull_files).never
       Master.sync

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cloud_encrypted_sync
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-14 00:00:00.000000000 Z
+date: 2012-11-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mocha
@@ -93,14 +93,18 @@ files:
 - bin/ces
 - cloud_encrypted_sync.gemspec
 - lib/cloud_encrypted_sync.rb
+- lib/cloud_encrypted_sync/adapter_liaison.rb
 - lib/cloud_encrypted_sync/adapter_template.rb
 - lib/cloud_encrypted_sync/configuration.rb
 - lib/cloud_encrypted_sync/cryptographer.rb
 - lib/cloud_encrypted_sync/dummy_adapter.rb
+- lib/cloud_encrypted_sync/errors.rb
+- lib/cloud_encrypted_sync/index.rb
 - lib/cloud_encrypted_sync/master.rb
 - lib/cloud_encrypted_sync/progress_meter.rb
 - lib/cloud_encrypted_sync/version.rb
 - test/test_helper.rb
+- test/unit/adapter_liaison_test.rb
 - test/unit/configuration_test.rb
 - test/unit/cryptographer_test.rb
 - test/unit/master_test.rb
@@ -131,6 +135,7 @@ specification_version: 3
 summary: Encrypted sync of folder contents to/from cloud storage.
 test_files:
 - test/test_helper.rb
+- test/unit/adapter_liaison_test.rb
 - test/unit/configuration_test.rb
 - test/unit/cryptographer_test.rb
 - test/unit/master_test.rb