dbox 0.4.2 → 0.4.3

data/TODO.txt

@@ -1,6 +1,3 @@
 * Look down directory tree until you hit a .dropbox.db file
-* 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

data/VERSION

@@ -1 +1 @@
-0.4.2
+0.4.3

data/dbox.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{dbox}
-  s.version = "0.4.2"
+  s.version = "0.4.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = [%q{Ken Pratt}]
-  s.date = %q{2011-05-17}
+  s.date = %q{2011-05-19}
   s.description = %q{An easy-to-use Dropbox client with fine-grained control over syncs.}
   s.email = %q{ken@kenpratt.net}
   s.executables = [%q{dbox}]

data/lib/dbox/api.rb

@@ -71,7 +71,9 @@ module Dbox
     def metadata(path = "/")
       log.debug "Fetching metadata for #{path}"
       run(path) do
-        @client.metadata(@conf["root"], escape_path(path))
+        res = @client.metadata(@conf["root"], escape_path(path))
+        log.debug res.inspect
+        res
       end
     end
 

data/lib/dbox/db.rb

@@ -65,15 +65,11 @@ module Dbox
     end
 
     def pull
-      res = @root.pull
-      save
-      res
+      @root.pull
     end
 
     def push
-      res = @root.push
-      save
-      res
+      @root.push
     end
 
     def move(new_remote_path)
@@ -148,18 +144,16 @@ module Dbox
       end
 
       def update_modification_info(res)
+        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"]
         last_modified_at = @modified_at
-        @modified_at = case t = res["modified"]
-                       when Time
-                         t
-                       when String
-                         Time.parse(t)
-                       end
-        if res.has_key?("revision")
+        @modified_at = parse_time(res["modified"])
+        if res["revision"]
           @revision = res["revision"]
         else
           @revision = -1 if @modified_at != last_modified_at
         end
+        log.debug "updated modification info on #{path.inspect}: r#{@revision}, #{@modified_at}"
       end
 
       def smart_new(res)
@@ -170,12 +164,6 @@ module Dbox
         end
       end
 
-      def update(res)
-        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
-
       def local_path
         @db.relative_to_local_path(@path)
       end
@@ -188,6 +176,33 @@ module Dbox
         raise RuntimeError, "Not implemented"
       end
 
+      def create(direction)
+        case direction
+        when :down
+          create_local
+        when :up
+          create_remote
+        end
+      end
+
+      def update(direction)
+        case direction
+        when :down
+          update_local
+        when :up
+          update_remote
+        end
+      end
+
+      def delete(direction)
+        case direction
+        when :down
+          delete_local
+        when :up
+          delete_remote
+        end
+      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
@@ -196,12 +211,23 @@ module Dbox
       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)
+      def modified?(res)
+        out = !(@revision == res["revision"] && @modified_at == parse_time(res["modified"]))
+        log.debug "#{path}.modified? r#{@revision} =? r#{res["revision"]}, #{@modified_at} =? #{parse_time(res["modified"])} => #{out}"
+        out
+      end
+
+      def parse_time(t)
+        case t
+        when Time
+          t
+        when String
+          Time.parse(t)
+        end
       end
 
       def update_file_timestamp
-        File.utime(Time.now, modified_at, local_path)
+        File.utime(Time.now, @modified_at, local_path)
       end
 
       # this downloads the metadata about this blob from the server and
@@ -232,93 +258,118 @@ module Dbox
         super(db, res)
       end
 
-      def update(res)
-        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|
-            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)
-              [new_entry.path, new_entry]
-            else
-              new_entry = smart_new(c)
-              [new_entry.path, new_entry]
-            end
-          end
-          @contents = Hash[new_contents_arr]
-        end
-      end
-
-      def remove_dotfiles(contents)
-        contents.reject {|c| File.basename(c["path"]).start_with?(".") }
-      end
-
       def pull
-        prev = self.clone
-        prev.freeze
+        # calculate changes on this dir
         res = api.metadata(remote_path)
-        update(res)
-        if contents_hash != prev.contents_hash
-          changes = reconcile(prev, :down)
-        else
-          changes = { :created => [], :deleted => [], :updated => [] }
-        end
-        subdirs.inject(changes) {|c, d| merge_changes(c, d.pull) }
+        changes = calculate_changes(res)
+
+        # execute changes on this dir
+        changelist = execute_changes(changes, :down)
+
+        # recur on subdirs, expanding changelist as we go
+        changelist = subdirs.inject(changelist) {|c, d| merge_changelists(c, d.pull) }
+
+        # only update the modification info on the directory once all descendants are updated
+        update_modification_info(res)
+
+        # return changes
+        @db.save
+        changelist
       end
 
       def push
-        prev = self.clone
-        prev.freeze
-        res = gather_info(@path)
-        update(res)
-        changes = reconcile(prev, :up)
-        subdirs.inject(changes) {|c, d| merge_changes(c, d.push) }
-      end
+        # calculate changes on this dir
+        res = gather_local_info(@path)
+        changes = calculate_changes(res)
 
-      def reconcile(prev, direction)
-        old_paths = prev.contents.keys.sort
-        new_paths = contents.keys.sort
+        # execute changes on this dir
+        changelist = execute_changes(changes, :up)
 
-        deleted_paths = old_paths - new_paths
+        # recur on subdirs, expanding changelist as we go
+        changelist = subdirs.inject(changelist) {|c, d| merge_changelists(c, d.push) }
 
-        created_paths = new_paths - old_paths
+        # only update the modification info on the directory once all descendants are updated
+        update_modification_info(res)
 
-        kept_paths = old_paths & new_paths
-        stale_paths = kept_paths.select {|p| contents[p].modified?(prev.contents[p]) }
+        # return changes
+        @db.save
+        changelist
+      end
 
-        case direction
-        when :down
-          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 }
+      def calculate_changes(res)
+        raise(ArgumentError, "Not a directory: #{res.inspect}") unless res["is_dir"]
+
+        if @contents_hash && res["hash"] && @contents_hash == res["hash"]
+          # dir hash hasn't changed -- no need to calculate changes
+          []
+        elsif res["contents"]
+          # dir has changed -- calculate changes on contents
+          out = []
+          got_paths = []
+
+          remove_dotfiles(res["contents"]).each do |c|
+            p = @db.remote_to_relative_path(c["path"])
+            c["rel_path"] = p
+            got_paths << p
+
+            if @contents.has_key?(p)
+              # only update file if it's been modified
+              if @contents[p].modified?(c)
+                out << [:update, c]
+              end
+            else
+              out << [:create, c]
+            end
+          end
+          out += (@contents.keys.sort - got_paths.sort).map {|p| [:delete, { "rel_path" => p }] }
+          out
         else
-          raise(ArgumentError, "Invalid sync direction: #{direction.inspect}")
+          raise(RuntimeError, "Trying to calculate dir changes without any contents")
         end
       end
 
-      def merge_changes(old, new)
-        old.merge(new) {|k, v1, v2| v1 + v2 }
+      def execute_changes(changes, direction)
+        log.debug "executing changes: #{changes.inspect}"
+        changelist = { :created => [], :deleted => [], :updated => [] }
+        changes.each do |op, c|
+          case op
+          when :create
+            e = smart_new(c)
+            e.create(direction)
+            @contents[e.path] = e
+            changelist[:created] << e.path
+          when :update
+            e = @contents[c["rel_path"]]
+            e.update_modification_info(c) if direction == :down
+            e.update(direction)
+            changelist[:updated] << e.path
+          when :delete
+            e = @contents[c["rel_path"]]
+            e.delete(direction)
+            @contents.delete(e.path)
+            changelist[:deleted] << e.path
+          else
+            raise(RuntimeError, "Unknown operation type: #{op}")
+          end
+          @db.save
+        end
+        changelist.keys.each {|k| changelist[k].sort! }
+        changelist
+      end
+
+      def merge_changelists(old, new)
+        old.merge(new) {|k, v1, v2| (v1 + v2).sort }
       end
 
-      def gather_info(rel, list_contents=true)
+      def gather_local_info(rel, list_contents=true)
         full = @db.relative_to_local_path(rel)
         remote = @db.relative_to_remote_path(rel)
 
         attrs = {
           "path" => remote,
           "is_dir" => File.directory?(full),
-          "modified" => File.mtime(full)
+          "modified" => File.mtime(full),
+          "revision" => @contents[rel] ? @contents[rel].revision : nil
         }
 
         if attrs["is_dir"] && list_contents
@@ -326,18 +377,23 @@ module Dbox
           attrs["contents"] = contents.map do |s|
             p = File.join(full, s)
             r = @db.local_to_relative_path(p)
-            gather_info(r, false)
+            gather_local_info(r, false)
           end
         end
 
         attrs
       end
 
+      def remove_dotfiles(contents)
+        contents.reject {|c| File.basename(c["path"]).start_with?(".") }
+      end
+
       def dir?
         true
       end
 
       def create_local
+        log.info "Creating #{local_path}"
         saving_parent_timestamp do
           FileUtils.mkdir_p(local_path)
           update_file_timestamp
@@ -345,7 +401,7 @@ module Dbox
       end
 
       def delete_local
-        log.info "Deleting dir: #{local_path}"
+        log.info "Deleting #{local_path}"
         saving_parent_timestamp do
           FileUtils.rm_r(local_path)
         end
@@ -374,7 +430,7 @@ module Dbox
 
       def print
         puts
-        puts "#{path} (v#{revision}, #{modified_at})"
+        puts "#{path} (v#{@revision}, #{@modified_at})"
         contents.each do |path, c|
           puts "  #{c.path} (v#{c.revision}, #{c.modified_at})"
         end
@@ -427,7 +483,7 @@ module Dbox
 
       def upload
         File.open(local_path) do |f|
-          res = api.put_file(remote_path, f)
+          api.put_file(remote_path, f)
         end
         force_metadata_update_from_server
       end

data/lib/dbox/loggable.rb

@@ -26,7 +26,7 @@ module Dbox
       Rails.logger
     else
       l = Logger.new(STDOUT)
-      l.level = Logger::INFO
+      l.level = (ENV["DEBUG"] && ENV["DEBUG"] != "false") ? Logger::DEBUG : Logger::INFO
       l.formatter = proc {|severity, datetime, progname, msg| "[#{severity}] #{msg}\n" }
       l
     end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: dbox
 version: !ruby/object:Gem::Version 
-  hash: 11
+  hash: 9
   prerelease: 
   segments: 
   - 0
   - 4
-  - 2
-  version: 0.4.2
+  - 3
+  version: 0.4.3
 platform: ruby
 authors: 
 - Ken Pratt
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-17 00:00:00 Z
+date: 2011-05-19 00:00:00 Z
 dependencies: []
 
 description: An easy-to-use Dropbox client with fine-grained control over syncs.