dbox 0.2.0 → 0.3.0

data/README.md

@@ -62,42 +62,42 @@ $ DROPBOX_AUTH_KEY=v4d7l1rez1czksn DROPBOX_AUTH_SECRET=pqej9rmnj0i1gcxr4 dbox ..
 * This auth token will last for **10 years**, or when you choose to invalidate it, whichever comes first. So you really only need to do this once, and then keep them around.
 
 
-Usage
------
+Using dbox from the Command-Line
+--------------------------------
 
-### Authorize
+### Usage
+
+#### Authorize
 
 ```sh
 $ dbox authorize
 ```
 
-### Create a new Dropbox folder
+#### Create a new Dropbox folder
 
 ```sh
 $ dbox create <remote_path> [<local_path>]
 ```
 
-### Clone an existing Dropbox folder
+#### Clone an existing Dropbox folder
 
 ```sh
 $ dbox clone <remote_path> [<local_path>]
 ```
 
-### Pull (download changes from Dropbox)
+#### Pull (download changes from Dropbox)
 
 ```sh
 $ dbox pull [<local_path>]
 ```
 
-### Push (upload changes to Dropbox)
+#### Push (upload changes to Dropbox)
 
 ```sh
 $ dbox push [<local_path>]
 ```
 
-
-Example
--------
+#### Example
 
 ```sh
 $ export DROPBOX_APP_KEY=cmlrrjd3j0gbend
@@ -136,3 +136,75 @@ $ dbox pull
 $ cat hello.txt
 Oh, Hello
 ```
+
+Using dbox from Ruby
+--------------------
+
+### Usage
+
+#### Setup
+
+* Authorize beforehand with the command-line tool
+
+```ruby
+require "dbox"
+```
+
+#### Create a new Dropbox folder
+
+```ruby
+Dbox.create(remote_path, local_path)
+```
+
+#### Clone an existing Dropbox folder
+
+```ruby
+Dbox.clone(remote_path, local_path)
+```
+
+#### Pull (download changes from Dropbox)
+
+```ruby
+Dbox.pull(local_path)
+```
+
+#### Push (upload changes to Dropbox)
+
+```ruby
+Dbox.push(local_path)
+```
+
+#### Example
+
+```sh
+$ export DROPBOX_APP_KEY=cmlrrjd3j0gbend
+$ export DROPBOX_APP_SECRET=uvuulp75xf9jffl
+```
+
+```sh
+$ dbox authorize
+```
+
+```sh
+$ open http://www.dropbox.com/0/oauth/authorize?oauth_token=aaoeuhtns123456
+```
+
+```sh
+$ export DROPBOX_AUTH_KEY=v4d7l1rez1czksn
+$ export DROPBOX_AUTH_SECRET=pqej9rmnj0i1gcxr4
+```
+
+```ruby
+> require "dbox"
+> Dbox.clone("/Public", "/tmp/public")
+> File.open("/tmp/public/hello.txt", "w") {|f| f << "Hello World" }
+> Dbox.push("/tmp/public")
+
+> File.read("#{ENV['HOME']}/Dropbox/Public/hello.txt")
+=> "Hello World"
+> File.open("#{ENV['HOME']}/Dropbox/Public/hello.txt", "w") {|f| f << "Oh, Hello" }
+
+> Dbox.pull("/tmp/public")
+> File.read("#{ENV['HOME']}/Dropbox/Public/hello.txt")
+=> "Oh, Hello"
+```

data/TODO.txt

@@ -1,7 +1,6 @@
-* More helpers in specs (and string style paths instead of join all over the place)
-* Have pull, push, etc return a list of changed files
 * Look down directory tree until you hit a .dropbox.db file
-* Solve upload -> re-download issue
-* Add rename_remote command
+* Put pull, push, etc in begin blocks and rescue => save to avoid half-baked repos
+* Detect old db format and migrate
+* Add "move" command (that renames remote)
 * Add a "sync" command that pushes and pulls in one go
-* Add support for partial push/pull? (also, make it defoult behaviour from subdir?)
+* Add support for partial push/pull

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.3.0

data/bin/dbox

@@ -32,20 +32,30 @@ def print_usage_and_quit; puts usage; exit 1; end
 print_usage_and_quit unless ARGV.size >= 1
 
 command = ARGV[0]
-rest = ARGV[1..-1]
+args = ARGV[1..-1]
 
 # execute the command
 case command
 when "authorize"
   Dbox.authorize
 when "create", "clone"
-  unless rest.size >= 1
+  unless args.size >= 1
     puts "Error: Please provide a remote path to clone"
     print_usage_and_quit
   end
-  Dbox.send(command, *rest)
+
+  remote_path = args[0]
+
+  # default to creating a directory inside the current directory with
+  # the same name of the directory being created/cloned
+  local_path = args[1] || remote_path.split("/").last
+
+  Dbox.send(command, remote_path, local_path)
 when "pull", "push"
-  Dbox.send(command, *rest)
+  # default to current directory
+  local_path = args[0] || "."
+
+  Dbox.send(command, local_path)
 else
   print_usage_and_quit
 end

data/dbox.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{dbox}
-  s.version = "0.2.0"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = [%q{Ken Pratt}]

data/lib/dbox.rb

@@ -17,36 +17,38 @@ module Dbox
     Dbox::API.authorize
   end
 
-  def self.create(remote_path, local_path = nil)
+  def self.create(remote_path, local_path)
     remote_path = clean_remote_path(remote_path)
-    local_path ||= remote_path.split("/").last
+    local_path = clean_local_path(local_path)
     Dbox::DB.create(remote_path, local_path)
   end
 
-  def self.clone(remote_path, local_path = nil)
+  def self.clone(remote_path, local_path)
     remote_path = clean_remote_path(remote_path)
-    local_path ||= remote_path.split("/").last
+    local_path = clean_local_path(local_path)
     Dbox::DB.clone(remote_path, local_path)
   end
 
-  def self.pull(local_path = nil)
-    local_path ||= "."
+  def self.pull(local_path)
+    local_path = clean_local_path(local_path)
     Dbox::DB.pull(local_path)
   end
 
-  def self.push(local_path = nil)
-    local_path ||= "."
+  def self.push(local_path)
+    local_path = clean_local_path(local_path)
     Dbox::DB.push(local_path)
   end
 
   private
 
   def self.clean_remote_path(path)
-    if path
-      path.sub(/\/$/,'')
-      path[0].chr == "/" ? path : "/#{path}"
-    else
-      raise "Missing remote path"
-    end
+    raise(ArgumentError, "Missing remote path") unless path
+    path.sub(/\/$/,'')
+    path[0].chr == "/" ? path : "/#{path}"
+  end
+
+  def self.clean_local_path(path)
+    raise(ArgumentError, "Missing local path") unless path
+    File.expand_path(path)
   end
 end

data/lib/dbox/api.rb

@@ -1,4 +1,10 @@
 module Dbox
+  class ConfigurationError < RuntimeError; end
+  class ServerError < RuntimeError; end
+  class RemoteMissing < RuntimeError; end
+  class RemoteAlreadyExists < RuntimeError; end
+  class RequestDenied < RuntimeError; end
+
   class API
     include Loggable
 
@@ -34,60 +40,84 @@ module Dbox
       auth_key = ENV["DROPBOX_AUTH_KEY"]
       auth_secret = ENV["DROPBOX_AUTH_SECRET"]
 
-      raise("Please set the DROPBOX_AUTH_KEY environment variable to an authenticated Dropbox session key") unless auth_key
-      raise("Please set the DROPBOX_AUTH_SECRET environment variable to an authenticated Dropbox session secret") unless auth_secret
+      raise(ConfigurationError, "Please set the DROPBOX_AUTH_KEY environment variable to an authenticated Dropbox session key") unless auth_key
+      raise(ConfigurationError, "Please set the DROPBOX_AUTH_SECRET environment variable to an authenticated Dropbox session secret") unless auth_secret
 
       @auth = Authenticator.new(@conf, auth_key, auth_secret)
       @client = DropboxClient.new(@conf["server"], @conf["content_server"], @conf["port"], @auth)
     end
 
-    def metadata(path = "/")
+    def run(path)
       path = escape_path(path)
-      log.debug "Fetching metadata for #{path}"
       begin
-        case res = @client.metadata(@conf["root"], path)
+        res = yield path
+        log.debug "Result: #{res.inspect}"
+
+        case res
         when Hash
           res
+        when String
+          res
         when Net::HTTPNotFound
-          raise "Remote path does not exist"
+          raise RemoteMissing, "#{path} does not exist on Dropbox"
+        when Net::HTTPForbidden
+          raise RequestDenied, "Operation on #{path} denied"
         else
-          raise "Unexpected result from GET /metadata: #{res.inspect}"
+          raise RuntimeError, "Unexpected result: #{res.inspect}"
         end
       rescue DropboxError => e
-        raise "Server error -- might be a hiccup, please try your request again (#{e.message})"
+        log.debug e.inspect
+        raise ServerError, "Server error -- might be a hiccup, please try your request again (#{e.message})"
+      end
+    end
+
+    def metadata(path = "/")
+      log.debug "Fetching metadata for #{path}"
+      run(path) do |path|
+        @client.metadata(@conf["root"], path)
       end
     end
 
     def create_dir(path)
-      path = escape_path(path)
       log.info "Creating #{path}"
-      @client.file_create_folder(@conf["root"], path)
+      run(path) do |path|
+        case res = @client.file_create_folder(@conf["root"], path)
+        when Net::HTTPForbidden
+          raise RemoteAlreadyExists, "The directory at #{path} already exists"
+        else
+          res
+        end
+      end
     end
 
     def delete_dir(path)
-      path = escape_path(path)
       log.info "Deleting #{path}"
-      @client.file_delete(@conf["root"], path)
+      run(path) do |path|
+        @client.file_delete(@conf["root"], path)
+      end
     end
 
     def get_file(path)
-      path = escape_path(path)
       log.info "Downloading #{path}"
-      @client.get_file(@conf["root"], path)
+      run(path) do |path|
+        @client.get_file(@conf["root"], path)
+      end
     end
 
     def put_file(path, file_obj)
-      path = escape_path(path)
       log.info "Uploading #{path}"
-      dir = File.dirname(path)
-      name = File.basename(path)
-      @client.put_file(@conf["root"], dir, name, file_obj)
+      run(path) do |path|
+        dir = File.dirname(path)
+        name = File.basename(path)
+        @client.put_file(@conf["root"], dir, name, file_obj)
+      end
     end
 
     def delete_file(path)
-      path = escape_path(path)
       log.info "Deleting #{path}"
-      @client.file_delete(@conf["root"], path)
+      run(path) do |path|
+        @client.file_delete(@conf["root"], path)
+      end
     end
 
     def escape_path(path)
@@ -98,8 +128,8 @@ module Dbox
       app_key = ENV["DROPBOX_APP_KEY"]
       app_secret = ENV["DROPBOX_APP_SECRET"]
 
-      raise("Please set the DROPBOX_APP_KEY environment variable to a Dropbox application key") unless app_key
-      raise("Please set the DROPBOX_APP_SECRET environment variable to a Dropbox application secret") unless app_secret
+      raise(ConfigurationError, "Please set the DROPBOX_APP_KEY environment variable to a Dropbox application key") unless app_key
+      raise(ConfigurationError, "Please set the DROPBOX_APP_SECRET environment variable to a Dropbox application secret") unless app_secret
 
       {
         "server"            => "api.dropbox.com",

data/lib/dbox/db.rb

@@ -1,4 +1,7 @@
 module Dbox
+  class MissingDatabase < RuntimeError; end
+  class BadPath < RuntimeError; end
+
   class DB
     include Loggable
 
@@ -7,7 +10,6 @@ module Dbox
     attr_accessor :local_path
 
     def self.create(remote_path, local_path)
-      log.info "Creating remote folder: #{remote_path}"
       api.create_dir(remote_path)
       clone(remote_path, local_path)
     end
@@ -15,7 +17,7 @@ module Dbox
     def self.clone(remote_path, local_path)
       log.info "Cloning #{remote_path} into #{local_path}"
       res = api.metadata(remote_path)
-      raise "Remote path error" unless remote_path == res["path"]
+      raise(BadPath, "Remote path error") unless remote_path == res["path"]
       db = new(local_path, res)
       db.pull
     end
@@ -24,10 +26,10 @@ module Dbox
       db_file = db_file(local_path)
       if File.exists?(db_file)
         db = File.open(db_file, "r") {|f| YAML::load(f.read) }
-        db.local_path = File.expand_path(local_path)
+        db.local_path = local_path
         db
       else
-        raise "No DB file found in #{local_path}"
+        raise MissingDatabase, "No DB file found in #{local_path}"
       end
     end
 
@@ -42,7 +44,7 @@ module Dbox
     # IMPORTANT: DropboxDb.new is private. Please use DropboxDb.create, DropboxDb.clone, or DropboxDb.load as the entry point.
     private_class_method :new
     def initialize(local_path, res)
-      @local_path = File.expand_path(local_path)
+      @local_path = local_path
       @remote_path = res["path"]
       FileUtils.mkdir_p(@local_path)
       @root = DropboxDir.new(self, res)
@@ -56,20 +58,22 @@ module Dbox
     end
 
     def pull
-      @root.pull
+      res = @root.pull
       save
+      res
     end
 
     def push
-      @root.push
+      res = @root.push
       save
+      res
     end
 
     def local_to_relative_path(path)
       if path.include?(@local_path)
         path.sub(@local_path, "").sub(/^\//, "")
       else
-        raise "Not a local path: #{path}"
+        raise BadPath, "Not a local path: #{path}"
       end
     end
 
@@ -77,7 +81,7 @@ module Dbox
       if path.include?(@remote_path)
         path.sub(@remote_path, "").sub(/^\//, "")
       else
-        raise "Not a remote path: #{path}"
+        raise BadPath, "Not a remote path: #{path}"
       end
     end
 
@@ -154,8 +158,8 @@ module Dbox
       end
 
       def update(res)
-        raise "bad path (#{remote_path} != #{res["path"]})" unless remote_path == res["path"]
-        raise "mode on #{@path} changed between file and dir -- not supported yet" unless dir? == res["is_dir"] # TODO handle change from dir to file or vice versa?
+        raise(BadPath, "Bad path (#{remote_path} != #{res["path"]})") unless remote_path == res["path"]
+        raise(RuntimeError, "Mode on #{@path} changed between file and dir -- not supported yet") unless dir? == res["is_dir"]
         update_modification_info(res)
       end
 
@@ -168,16 +172,16 @@ module Dbox
       end
 
       def dir?
-        raise "not implemented"
+        raise RuntimeError, "Not implemented"
       end
 
-      def create_local; raise "not implemented"; end
-      def delete_local; raise "not implemented"; end
-      def update_local; raise "not implemented"; end
+      def create_local; raise RuntimeError, "Not implemented"; end
+      def delete_local; raise RuntimeError, "Not implemented"; end
+      def update_local; raise RuntimeError, "Not implemented"; end
 
-      def create_remote; raise "not implemented"; end
-      def delete_remote; raise "not implemented"; end
-      def update_remote; raise "not implemented"; end
+      def create_remote; raise RuntimeError, "Not implemented"; end
+      def delete_remote; raise RuntimeError, "Not implemented"; end
+      def update_remote; raise RuntimeError, "Not implemented"; end
 
       def modified?(last)
         !(revision == last.revision && modified_at == last.modified_at)
@@ -187,6 +191,15 @@ module Dbox
         File.utime(Time.now, modified_at, local_path)
       end
 
+      # this downloads the metadata about this blob from the server and
+      # overwrites the metadata & timestamp
+      # IMPORTANT: should only be called if you are CERTAIN the file is up to date
+      def force_metadata_update_from_server
+        res = api.metadata(remote_path)
+        update_modification_info(res)
+        update_file_timestamp
+      end
+
       def saving_parent_timestamp(&proc)
         parent = File.dirname(local_path)
         DB.saving_timestamp(parent, &proc)
@@ -207,19 +220,21 @@ module Dbox
       end
 
       def update(res)
-        raise "not a directory" unless res["is_dir"]
+        raise(ArgumentError, "Not a directory: #{res.inspect}") unless res["is_dir"]
         super(res)
         @contents_hash = res["hash"] if res.has_key?("hash")
         if res.has_key?("contents")
           old_contents = @contents
           new_contents_arr = remove_dotfiles(res["contents"]).map do |c|
-            if last_entry = old_contents[c["path"]]
+            p = @db.remote_to_relative_path(c["path"])
+            if last_entry = old_contents[p]
               new_entry = last_entry.clone
               last_entry.freeze
               new_entry.update(c)
-              [c["path"], new_entry]
+              [new_entry.path, new_entry]
             else
-              [c["path"], smart_new(c)]
+              new_entry = smart_new(c)
+              [new_entry.path, new_entry]
             end
           end
           @contents = Hash[new_contents_arr]
@@ -233,28 +248,28 @@ module Dbox
       def pull
         prev = self.clone
         prev.freeze
-        log.info "Pulling changes"
         res = api.metadata(remote_path)
         update(res)
         if contents_hash != prev.contents_hash
-          reconcile(prev, :down)
+          changes = reconcile(prev, :down)
+        else
+          changes = { :created => [], :deleted => [], :updated => [] }
         end
-        subdirs.each {|d| d.pull }
+        subdirs.inject(changes) {|c, d| merge_changes(c, d.pull) }
       end
 
       def push
         prev = self.clone
         prev.freeze
-        log.info "Pushing changes"
         res = gather_info(@path)
         update(res)
-        reconcile(prev, :up)
-        subdirs.each {|d| d.push }
+        changes = reconcile(prev, :up)
+        subdirs.inject(changes) {|c, d| merge_changes(c, d.push) }
       end
 
       def reconcile(prev, direction)
-        old_paths = prev.contents.keys
-        new_paths = contents.keys
+        old_paths = prev.contents.keys.sort
+        new_paths = contents.keys.sort
 
         deleted_paths = old_paths - new_paths
 
@@ -268,15 +283,21 @@ module Dbox
           deleted_paths.each {|p| prev.contents[p].delete_local }
           created_paths.each {|p| contents[p].create_local }
           stale_paths.each {|p| contents[p].update_local }
+          { :created => created_paths, :deleted => deleted_paths, :updated => stale_paths }
         when :up
           deleted_paths.each {|p| prev.contents[p].delete_remote }
           created_paths.each {|p| contents[p].create_remote }
           stale_paths.each {|p| contents[p].update_remote }
+          { :created => created_paths, :deleted => deleted_paths, :updated => stale_paths }
         else
-          raise "Invalid direction: #{direction.inspect}"
+          raise(ArgumentError, "Invalid sync direction: #{direction.inspect}")
         end
       end
 
+      def merge_changes(old, new)
+        old.merge(new) {|k, v1, v2| v1 + v2 }
+      end
+
       def gather_info(rel, list_contents=true)
         full = @db.relative_to_local_path(rel)
         remote = @db.relative_to_remote_path(rel)
@@ -303,7 +324,6 @@ module Dbox
       end
 
       def create_local
-        log.info "Creating dir: #{local_path}"
         saving_parent_timestamp do
           FileUtils.mkdir_p(local_path)
           update_file_timestamp
@@ -318,12 +338,12 @@ module Dbox
       end
 
       def update_local
-        log.info "Updating dir: #{local_path}"
         update_file_timestamp
       end
 
       def create_remote
         api.create_dir(remote_path)
+        force_metadata_update_from_server
       end
 
       def delete_remote
@@ -354,10 +374,8 @@ module Dbox
       end
 
       def create_local
-        log.info "Creating file: #{local_path}"
         saving_parent_timestamp do
           download
-          update_file_timestamp
         end
       end
 
@@ -369,9 +387,7 @@ module Dbox
       end
 
       def update_local
-        log.info "Updating file: #{local_path}"
         download
-        update_file_timestamp
       end
 
       def create_remote
@@ -399,6 +415,7 @@ module Dbox
         File.open(local_path) do |f|
           res = api.put_file(remote_path, f)
         end
+        force_metadata_update_from_server
       end
     end
   end

data/spec/dbox_spec.rb

@@ -3,119 +3,183 @@ require File.expand_path(File.dirname(__FILE__) + "/spec_helper")
 include FileUtils
 
 describe Dbox do
+  before(:all) do
+    clear_test_log
+  end
+
   before(:each) do
-    cd LOCAL_TEST_PATH
+    log.info example.full_description
     @name = randname()
     @local = File.join(LOCAL_TEST_PATH, @name)
     @remote = File.join(REMOTE_TEST_PATH, @name)
   end
 
+  after(:each) do
+    log.info ""
+  end
+
   describe "#create" do
     it "creates the local directory" do
-      Dbox.create(@remote)
-      File.exists?(@local).should be_true
+      Dbox.create(@remote, @local)
+      @local.should exist
     end
 
-    xit "should fail if the remote already exists" do
-      Dbox.create(@remote)
+    it "should fail if the remote already exists" do
+      Dbox.create(@remote, @local)
       rm_rf @local
-      expect { Dbox.create(@remote) }.to raise_error("Remote path already exists")
-      File.exists?(@local).should be_false
+      expect { Dbox.create(@remote, @local) }.to raise_error(Dbox::RemoteAlreadyExists)
+      @local.should_not exist
     end
   end
 
   describe "#clone" do
     it "creates the local directory" do
-      Dbox.create(@remote)
+      Dbox.create(@remote, @local)
       rm_rf @local
-      File.exists?(@local).should be_false
-      Dbox.clone(@remote)
-      File.exists?(@local).should be_true
+      @local.should_not exist
+      Dbox.clone(@remote, @local)
+      @local.should exist
     end
 
     it "should fail if the remote does not exist" do
-      expect { Dbox.clone(@remote) }.to raise_error("Remote path does not exist")
-      File.exists?(@local).should be_false
+      expect { Dbox.clone(@remote, @local) }.to raise_error(Dbox::RemoteMissing)
+      @local.should_not exist
     end
   end
 
   describe "#pull" do
     it "should fail if the local dir is missing" do
-      expect { Dbox.pull(@local) }.to raise_error(/No DB file found/)
+      expect { Dbox.pull(@local) }.to raise_error(Dbox::MissingDatabase)
     end
 
     it "should fail if the remote dir is missing" do
-      Dbox.create(@remote)
+      Dbox.create(@remote, @local)
       modify_dbfile {|s| s.sub(/^remote_path: \/.*$/, "remote_path: /#{randname()}") }
-      expect { Dbox.pull(@local) }.to raise_error("Remote path does not exist")
+      expect { Dbox.pull(@local) }.to raise_error(Dbox::RemoteMissing)
     end
 
     it "should be able to pull" do
-      Dbox.create(@remote)
-      expect { Dbox.pull(@local) }.to_not raise_error
-    end
-
-    it "should be able to pull from inside the dir" do
-      Dbox.create(@remote)
-      cd @local
-      expect { Dbox.pull }.to_not raise_error
+      Dbox.create(@remote, @local)
+      Dbox.pull(@local).should eql(:created => [], :deleted => [], :updated => [])
     end
 
     it "should be able to pull changes" do
-      Dbox.create(@remote)
-      File.exists?("#{@local}/hello.txt").should be_false
+      Dbox.create(@remote, @local)
+      "#{@local}/hello.txt".should_not exist
 
-      cd ALTERNATE_LOCAL_TEST_PATH
-      Dbox.clone(@remote)
-      cd @name
-      touch "hello.txt"
-      Dbox.push
+      @alternate = "#{ALTERNATE_LOCAL_TEST_PATH}/#{@name}"
+      Dbox.clone(@remote, @alternate)
+      touch "#{@alternate}/hello.txt"
+      Dbox.push(@alternate).should eql(:created => ["hello.txt"], :deleted => [], :updated => [])
 
-      expect { Dbox.pull(@local) }.to_not raise_error
-      File.exists?("#{@local}/hello.txt").should be_true
+      Dbox.pull(@local).should eql(:created => ["hello.txt"], :deleted => [], :updated => [])
+      "#{@local}/hello.txt".should exist
     end
 
     it "should be able to pull after deleting a file and not have the file re-created" do
-      Dbox.create(@remote)
-      cd @name
-      touch "hello.txt"
-      Dbox.push
-      Dbox.pull
-      rm "hello.txt"
-      Dbox.pull
-      File.exists?("#{@local}/hello.txt").should be_false
+      Dbox.create(@remote, @local)
+      touch "#{@local}/hello.txt"
+      Dbox.push(@local).should eql(:created => ["hello.txt"], :deleted => [], :updated => [])
+      rm "#{@local}/hello.txt"
+      Dbox.pull(@local).should eql(:created => [], :deleted => [], :updated => [])
+      "#{@local}/hello.txt".should_not exist
+    end
+
+    it "should handle a complex set of changes" do
+      Dbox.create(@remote, @local)
+
+      @alternate = "#{ALTERNATE_LOCAL_TEST_PATH}/#{@name}"
+      Dbox.clone(@remote, @alternate)
+
+      Dbox.pull(@local).should eql(:created => [], :deleted => [], :updated => [])
+
+      touch "#{@alternate}/foo.txt"
+      touch "#{@alternate}/bar.txt"
+      touch "#{@alternate}/baz.txt"
+      Dbox.push(@alternate).should eql(:created => ["bar.txt", "baz.txt", "foo.txt"], :deleted => [], :updated => [])
+
+      Dbox.pull(@local).should eql(:created => ["bar.txt", "baz.txt", "foo.txt"], :deleted => [], :updated => [])
+
+      sleep 1
+      mkdir "#{@alternate}/subdir"
+      touch "#{@alternate}/subdir/one.txt"
+      rm "#{@alternate}/foo.txt"
+      File.open("#{@alternate}/baz.txt", "w") {|f| f << "baaz" }
+      Dbox.push(@alternate).should eql(:created => ["subdir", "subdir/one.txt"], :deleted => ["foo.txt"], :updated => ["baz.txt"])
+
+      Dbox.pull(@local).should eql(:created => ["subdir", "subdir/one.txt"], :deleted => ["foo.txt"], :updated => ["baz.txt"])
     end
   end
 
   describe "#push" do
     it "should fail if the local dir is missing" do
-      expect { Dbox.push(@local) }.to raise_error(/No DB file found/)
+      expect { Dbox.push(@local) }.to raise_error(Dbox::MissingDatabase)
     end
 
     it "should be able to push" do
-      Dbox.create(@remote)
-      expect { Dbox.push(@local) }.to_not raise_error
-    end
-
-    it "should be able to push from inside the dir" do
-      Dbox.create(@remote)
-      cd @local
-      expect { Dbox.push }.to_not raise_error
+      Dbox.create(@remote, @local)
+      Dbox.push(@local).should eql(:created => [], :deleted => [], :updated => [])
     end
 
     it "should be able to push new file" do
-      Dbox.create(@remote)
-      touch File.join(@local, "foo.txt")
-      expect { Dbox.push(@local) }.to_not raise_error
+      Dbox.create(@remote, @local)
+      touch "#{@local}/foo.txt"
+      Dbox.push(@local).should eql(:created => ["foo.txt"], :deleted => [], :updated => [])
     end
 
     it "should create the remote dir if it is missing" do
-      Dbox.create(@remote)
-      touch File.join(@local, "foo.txt")
+      Dbox.create(@remote, @local)
+      touch "#{@local}/foo.txt"
       @new_name = randname()
       @new_remote = File.join(REMOTE_TEST_PATH, @new_name)
       modify_dbfile {|s| s.sub(/^remote_path: \/.*$/, "remote_path: #{@new_remote}") }
-      expect { Dbox.push(@local) }.to_not raise_error
+      Dbox.push(@local).should eql(:created => ["foo.txt"], :deleted => [], :updated => [])
+    end
+
+    it "should be able to push nested content" do
+      Dbox.create(@remote, @local)
+      mkdir "#{@local}/subdir"
+      touch "#{@local}/subdir/foo.txt"
+      Dbox.push(@local).should eql(:created => ["subdir", "subdir/foo.txt"], :deleted => [], :updated => [])
+    end
+
+    it "should not re-download the file after creating" do
+      Dbox.create(@remote, @local)
+      touch "#{@local}/foo.txt"
+      Dbox.push(@local).should eql(:created => ["foo.txt"], :deleted => [], :updated => [])
+      Dbox.pull(@local).should eql(:created => [], :deleted => [], :updated => [])
+    end
+
+    it "should not re-download the file after updating" do
+      Dbox.create(@remote, @local)
+      touch "#{@local}/foo.txt"
+      Dbox.push(@local).should eql(:created => ["foo.txt"], :deleted => [], :updated => [])
+      sleep 1
+      File.open("#{@local}/foo.txt", "w") {|f| f << "fooz" }
+      Dbox.push(@local).should eql(:created => [], :deleted => [], :updated => ["foo.txt"])
+      Dbox.pull(@local).should eql(:created => [], :deleted => [], :updated => [])
+    end
+
+    it "should not re-download the dir after creating" do
+      Dbox.create(@remote, @local)
+      mkdir "#{@local}/subdir"
+      Dbox.push(@local).should eql(:created => ["subdir"], :deleted => [], :updated => [])
+      Dbox.pull(@local).should eql(:created => [], :deleted => [], :updated => [])
+    end
+
+    it "should handle a complex set of changes" do
+      Dbox.create(@remote, @local)
+      touch "#{@local}/foo.txt"
+      touch "#{@local}/bar.txt"
+      touch "#{@local}/baz.txt"
+      Dbox.push(@local).should eql(:created => ["bar.txt", "baz.txt", "foo.txt"], :deleted => [], :updated => [])
+      sleep 1
+      mkdir "#{@local}/subdir"
+      touch "#{@local}/subdir/one.txt"
+      rm "#{@local}/foo.txt"
+      touch "#{@local}/baz.txt"
+      Dbox.push(@local).should eql(:created => ["subdir", "subdir/one.txt"], :deleted => ["foo.txt"], :updated => ["baz.txt"])
+      Dbox.pull(@local).should eql(:created => [], :deleted => [], :updated => [])
     end
   end
 end

data/spec/spec_helper.rb

@@ -11,7 +11,13 @@ FileUtils.mkdir_p(ALTERNATE_LOCAL_TEST_PATH)
 
 REMOTE_TEST_PATH = "/dbox_test_dirs"
 
-LOGGER = Logger.new(File.expand_path(File.join(File.dirname(__FILE__), "..", "tmp", "test.log")))
+$started_at ||= Time.now
+
+LOGFILE = File.expand_path(File.join(File.dirname(__FILE__), "..", "tmp", "test.log"))
+LOGGER = Logger.new(LOGFILE)
+LOGGER.formatter = proc do |severity, datetime, progname, msg|
+  format "[%4.1fs] [%s] %s\n", (Time.now - $started_at), severity, msg
+end
 
 def randname
   u = `uuidgen`.chomp
@@ -24,3 +30,17 @@ def modify_dbfile
   s = yield s
   File.open(dbfile, "w") {|f| f << s }
 end
+
+def clear_test_log
+  File.open(LOGFILE, "w") {|f| f << "" }
+end
+
+def log
+  LOGGER
+end
+
+RSpec::Matchers.define :exist do
+  match do |actual|
+    File.exists?(actual) == true
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: dbox
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 19
   prerelease: 
   segments: 
   - 0
-  - 2
+  - 3
   - 0
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Ken Pratt