dbox 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/LICENSE.txt

@@ -0,0 +1,23 @@
+The MIT License
+
+Copyright (c) 2011 Ken Pratt <ken@kenpratt.net>
+Copyright (c) 2011 Ruboss Technology Corp <peter@ruboss.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,132 @@
+dbox
+====
+
+An easy way to push and pull your Dropbox folders, with fine-grained control over what folder you are syncing, where you are syncing it to, and when you are doing it.
+
+**IMPORTANT:** This is **not** an automated Dropbox client. It will exit after sucessfully pushing/pulling, so if you want regular updates, you can run it in cron, a loop, etc.
+
+
+Installation
+------------
+
+### Get developer keys
+
+* Follow the instructions at https://www.dropbox.com/developers/quickstart to create a Dropbox development application, and copy the application keys.
+
+* Now either set the keys as environment variables:
+
+```sh
+$ export DROPBOX_APP_KEY=cmlrrjd3j0gbend
+$ export DROPBOX_APP_SECRET=uvuulp75xf9jffl
+```
+
+* Or include them in calls to dbox:
+
+```sh
+$ DROPBOX_APP_KEY=cmlrrjd3j0gbend DROPBOX_APP_SECRET=uvuulp75xf9jffl dbox ...
+```
+### Generate an auth token
+
+* Make an authorize request:
+
+```sh
+$ dbox authorize
+Please visit the following URL in your browser, log into Dropbox, and authorize the app you created.
+
+http://www.dropbox.com/0/oauth/authorize?oauth_token=j2kuzfvobcpqh0g
+
+When you have done so, press [ENTER] to continue.
+```
+
+* Visit the given URL in your browser, and then go back to the terminal and press Enter.
+
+* Now either set the keys as environment variables:
+
+```sh
+$ export DROPBOX_AUTH_KEY=v4d7l1rez1czksn
+$ export DROPBOX_AUTH_SECRET=pqej9rmnj0i1gcxr4
+```
+
+* Or include them in calls to dbox:
+
+```sh
+$ 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
+-----
+
+### Authorize
+
+```sh
+$ dbox authorize
+```
+
+### Clone an existing Dropbox folder
+
+```sh
+$ dbox clone <remote_path> [<local_path>]
+```
+
+### Create a new Dropbox folder
+
+```sh
+$ dbox create <remote_path> [<local_path>]
+```
+
+### Pull (download changes from Dropbox)
+
+```sh
+$ dbox pull [<local_path>]
+```
+
+### Push (upload changes to Dropbox)
+
+```sh
+$ 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
+```
+
+```sh
+$ cd /tmp
+$ dbox clone Public
+$ cd Public
+$ echo "Hello World" > hello.txt
+$ dbox push
+```
+
+```sh
+$ cat ~/Dropbox/Public/hello.txt
+Hello World
+$ echo "Oh, Hello" > ~/Dropbox/Public/hello.txt
+```
+
+```sh
+$ dbox pull
+$ cat hello.txt
+Oh, Hello
+```

data/Rakefile

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "dbox"
+  gem.homepage = "http://github.com/kenpratt/dbox"
+  gem.license = "MIT"
+  gem.summary = "Dropbox made easy."
+  gem.description = "An easy-to-use Dropbox client with fine-grained control over syncs."
+  gem.email = "ken@kenpratt.net"
+  gem.authors = ["Ken Pratt"]
+  gem.executables = ["dbox"]
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+  test.rcov_opts << '--exclude "gems/*"'
+end
+
+task :default => :test

data/TODO.txt

@@ -0,0 +1,8 @@
+* Add tests
+* Add proper logger
+* See if pull re-creates locally-deleted files (it shouldn't)
+* Look down directory tree until you hit a .dropbox.db file
+* Solve upload -> re-download issue
+* Add rename_remote command
+* Add a "sync" command that pushes and pulls in one go
+* Add support for partial push/pull? (also, make it defoult behaviour from subdir?)

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/bin/dbox

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
+require "dbox"
+
+# usage line
+def usage
+  "Usage:
+  dbox authorize
+  export DROPBOX_AUTH_KEY=abcdef012345678
+  export DROPBOX_AUTH_SECRET=876543210fedcba
+  dbox create <remote_path> [<local_path>]
+  dbox clone <remote_path> [<local_path>]
+  dbox pull
+  dbox push"
+end
+def print_usage_and_quit; puts usage; exit 1; end
+
+# ensure that push/pull arg was given
+print_usage_and_quit unless ARGV.size >= 1
+
+command = ARGV[0]
+rest = ARGV[1..-1]
+
+# execute the command
+case command
+when "authorize"
+  Dbox.authorize
+when "create", "clone"
+  unless rest.size >= 1
+    puts "Error: Please provide a remote path to clone"
+    print_usage_and_quit
+  end
+  Dbox.send(command, *rest)
+when "pull", "push"
+  Dbox.send(command, *rest)
+else
+  print_usage_and_quit
+end

data/lib/dbox.rb

@@ -0,0 +1,50 @@
+ROOT_PATH = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+$:.unshift File.join(ROOT_PATH, "lib")
+$:.unshift File.join(ROOT_PATH, "vendor", "dropbox-client-ruby", "lib")
+
+require "dropbox"
+require "fileutils"
+require "time"
+require "yaml"
+
+require "dbox/api"
+require "dbox/db"
+
+module Dbox
+  def self.authorize
+    Dbox::API.authorize
+  end
+
+  def self.create(remote_path, local_path = nil)
+    remote_path = clean_remote_path(remote_path)
+    local_path ||= remote_path.split("/").last
+    Dbox::DB.create(remote_path, local_path)
+  end
+
+  def self.clone(remote_path, local_path = nil)
+    remote_path = clean_remote_path(remote_path)
+    local_path ||= remote_path.split("/").last
+    Dbox::DB.clone(remote_path, local_path)
+  end
+
+  def self.pull(local_path = nil)
+    local_path ||= "."
+    Dbox::DB.pull(local_path)
+  end
+
+  def self.push(local_path = nil)
+    local_path ||= "."
+    Dbox::DB.push(local_path)
+  end
+
+  private
+
+  def self.clean_remote_path(path)
+    if path
+      path.sub(/\/$/,'')
+      path[0] == "/" ? path : "/#{path}"
+    else
+      raise "Missing remote path"
+    end
+  end
+end

data/lib/dbox/api.rb

@@ -0,0 +1,106 @@
+module Dbox
+  class API
+    def self.authorize
+      puts conf.inspect
+      auth = Authenticator.new(conf)
+      puts auth.inspect
+      authorize_url = auth.get_request_token
+      puts "Please visit the following URL in your browser, log into Dropbox, and authorize the app you created.\n\n#{authorize_url}\n\nWhen you have done so, press [ENTER] to continue."
+      STDIN.readline
+      res = auth.get_access_token
+      puts "export DROPBOX_AUTH_KEY=#{res.token}"
+      puts "export DROPBOX_AUTH_SECRET=#{res.secret}"
+      puts
+      puts "This auth token will last for 10 years, or when you choose to invalidate it, whichever comes first."
+      puts
+      puts "Now either include these constants in yours calls to dbox, or set them as environment variables."
+      puts "In bash, including them in calls looks like:"
+      puts "$ DROPBOX_AUTH_KEY=#{res.token} DROPBOX_AUTH_SECRET=#{res.secret} dbox ..."
+    end
+
+    def self.connect
+      api = new()
+      api.connect
+      api
+    end
+
+    # IMPORTANT: API.new is private. Please use API.authorize or API.connect as the entry point.
+    private_class_method :new
+    def initialize
+      @conf = self.class.conf
+    end
+
+    def connect
+      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
+
+      @auth = Authenticator.new(@conf, auth_key, auth_secret)
+      @client = DropboxClient.new(@conf["server"], @conf["content_server"], @conf["port"], @auth)
+    end
+
+    def metadata(path = "/")
+      path = escape_path(path)
+      puts "[api] fetching metadata for #{path}"
+      @client.metadata(@conf["root"], path)
+    end
+
+    def create_dir(path)
+      path = escape_path(path)
+      puts "[api] creating #{path}"
+      @client.file_create_folder(@conf["root"], path)
+    end
+
+    def delete_dir(path)
+      path = escape_path(path)
+      puts "[api] deleting #{path}"
+      @client.file_delete(@conf["root"], path)
+    end
+
+    def get_file(path)
+      path = escape_path(path)
+      puts "[api] downloading #{path}"
+      @client.get_file(@conf["root"], path)
+    end
+
+    def put_file(path, file_obj)
+      path = escape_path(path)
+      puts "[api] uploading #{path}"
+      dir = File.dirname(path)
+      name = File.basename(path)
+      @client.put_file(@conf["root"], dir, name, file_obj)
+    end
+
+    def delete_file(path)
+      path = escape_path(path)
+      puts "[api] deleting #{path}"
+      @client.file_delete(@conf["root"], path)
+    end
+
+    def escape_path(path)
+      URI.escape(path)
+    end
+
+    def self.conf
+      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
+
+      {
+        "server"            => "api.dropbox.com",
+        "content_server"    => "api-content.dropbox.com",
+        "port"              => 80,
+        "request_token_url" => "http://api.dropbox.com/0/oauth/request_token",
+        "access_token_url"  => "http://api.dropbox.com/0/oauth/access_token",
+        "authorization_url" => "http://www.dropbox.com/0/oauth/authorize",
+        "root"              => "dropbox",
+        "consumer_key"      => app_key,
+        "consumer_secret"   => app_secret
+      }
+    end
+  end
+end

data/lib/dbox/db.rb

@@ -0,0 +1,407 @@
+module Dbox
+  class DB
+    DB_FILE = ".dropbox.db"
+
+    attr_accessor :local_path
+
+    def self.create(remote_path, local_path)
+      puts "[db] Creating remote folder: #{remote_path}"
+      api.create_dir(remote_path)
+      clone(remote_path, local_path)
+    end
+
+    def self.clone(remote_path, local_path)
+      puts "[db] Cloning #{remote_path} into #{local_path}"
+      case res = api.metadata(remote_path)
+      when Hash
+        raise "Remote path error" unless remote_path == res["path"]
+        db = new(local_path, res)
+        db.pull
+      when Net::HTTPNotFound
+        raise "Remote path does not exist"
+      else
+        raise "Clone failed: #{res.inspect}"
+      end
+    end
+
+    def self.load(local_path)
+      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
+      else
+        raise "No DB file found in #{local_path}"
+      end
+    end
+
+    def self.pull(local_path)
+      load(local_path).pull
+    end
+
+    def self.push(local_path)
+      load(local_path).push
+    end
+
+    # 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)
+      @remote_path = res["path"]
+      FileUtils.mkdir_p(@local_path)
+      @root = DropboxDir.new(self, res)
+      save
+    end
+
+    def save
+      self.class.saving_timestamp(@local_path) do
+        File.open(db_file, "w") {|f| f << YAML::dump(self) }
+      end
+    end
+
+    def pull
+      @root.pull
+      save
+    end
+
+    def push
+      @root.push
+      save
+    end
+
+    def local_to_relative_path(path)
+      if path.include?(@local_path)
+        path.sub(@local_path, "").sub(/^\//, "")
+      else
+        raise "Not a local path: #{path}"
+      end
+    end
+
+    def remote_to_relative_path(path)
+      if path.include?(@remote_path)
+        path.sub(@remote_path, "").sub(/^\//, "")
+      else
+        raise "Not a remote path: #{path}"
+      end
+    end
+
+    def relative_to_local_path(path)
+      if path.any?
+        File.join(@local_path, path)
+      else
+        @local_path
+      end
+    end
+
+    def relative_to_remote_path(path)
+      if path.any?
+        File.join(@remote_path, path)
+      else
+        @remote_path
+      end
+    end
+
+    def self.saving_timestamp(path)
+      mtime = File.mtime(path)
+      yield
+      File.utime(Time.now, mtime, path)
+    end
+
+    def self.api
+      @api ||= API.connect
+    end
+
+    def api
+      self.class.api
+    end
+
+    def self.db_file(local_path)
+      File.join(local_path, DB_FILE)
+    end
+
+    def db_file
+      self.class.db_file(@local_path)
+    end
+
+    class DropboxBlob
+      attr_reader :path, :revision, :modified_at
+
+      def initialize(db, res)
+        @db = db
+        @path = @db.remote_to_relative_path(res["path"])
+        update_modification_info(res)
+      end
+
+      def update_modification_info(res)
+        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")
+          @revision = res["revision"]
+        else
+          @revision = -1 if @modified_at != last_modified_at
+        end
+      end
+
+      def smart_new(res)
+        if res["is_dir"]
+          DropboxDir.new(@db, res)
+        else
+          DropboxFile.new(@db, res)
+        end
+      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?
+        update_modification_info(res)
+      end
+
+      def local_path
+        @db.relative_to_local_path(@path)
+      end
+
+      def remote_path
+        @db.relative_to_remote_path(@path)
+      end
+
+      def dir?
+        raise "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_remote; raise "not implemented"; end
+      def delete_remote; raise "not implemented"; end
+      def update_remote; raise "not implemented"; end
+
+      def modified?(last)
+        !(revision == last.revision && modified_at == last.modified_at)
+      end
+
+      def update_file_timestamp
+        File.utime(Time.now, modified_at, local_path)
+      end
+
+      def saving_parent_timestamp(&proc)
+        parent = File.dirname(local_path)
+        DB.saving_timestamp(parent, &proc)
+      end
+
+      def api
+        @db.api
+      end
+    end
+
+    class DropboxDir < DropboxBlob
+      attr_reader :contents_hash, :contents
+
+      def initialize(db, res)
+        @contents_hash = nil
+        @contents = {}
+        super(db, res)
+      end
+
+      def update(res)
+        raise "not a directory" 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"]]
+              new_entry = last_entry.clone
+              last_entry.freeze
+              new_entry.update(c)
+              [c["path"], new_entry]
+            else
+              [c["path"], smart_new(c)]
+            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
+        puts "[db] pulling"
+        res = api.metadata(remote_path)
+        update(res)
+        if contents_hash != prev.contents_hash
+          reconcile(prev, :down)
+        end
+        subdirs.each {|d| d.pull }
+      end
+
+      def push
+        prev = self.clone
+        prev.freeze
+        puts "[db] pushing"
+        res = gather_info(@path)
+        update(res)
+        reconcile(prev, :up)
+        subdirs.each {|d| d.push }
+      end
+
+      def reconcile(prev, direction)
+        old_paths = prev.contents.keys
+        new_paths = contents.keys
+
+        deleted_paths = old_paths - new_paths
+
+        created_paths = new_paths - old_paths
+
+        kept_paths = old_paths & new_paths
+        stale_paths = kept_paths.select {|p| contents[p].modified?(prev.contents[p]) }
+
+        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 }
+        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 }
+        else
+          raise "Invalid direction: #{direction.inspect}"
+        end
+      end
+
+      def gather_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)
+        }
+
+        if attrs["is_dir"] && list_contents
+          contents = Dir[File.join(full, "*")]
+          attrs["contents"] = contents.map do |f|
+            r = @db.local_to_relative_path(f)
+            gather_info(r, false)
+          end
+        end
+
+        attrs
+      end
+
+      def dir?
+        true
+      end
+
+      def create_local
+        puts "[fs] creating dir #{local_path}"
+        saving_parent_timestamp do
+          FileUtils.mkdir_p(local_path)
+          update_file_timestamp
+        end
+      end
+
+      def delete_local
+        puts "[fs] deleting dir #{local_path}"
+        saving_parent_timestamp do
+          FileUtils.rm_r(local_path)
+        end
+      end
+
+      def update_local
+        puts "[fs] updating dir #{local_path}"
+        update_file_timestamp
+      end
+
+      def create_remote
+        api.create_dir(remote_path)
+      end
+
+      def delete_remote
+        api.delete_dir(remote_path)
+      end
+
+      def update_remote
+        # do nothing
+      end
+
+      def subdirs
+        @contents.values.select {|c| c.dir? }
+      end
+
+      def print
+        puts
+        puts "#{path} (v#{revision}, #{modified_at})"
+        contents.each do |path, c|
+          puts "  #{c.path} (v#{c.revision}, #{c.modified_at})"
+        end
+        puts
+      end
+    end
+
+    class DropboxFile < DropboxBlob
+      def dir?
+        false
+      end
+
+      def create_local
+        puts "[fs] creating file #{local_path}"
+        saving_parent_timestamp do
+          download
+          update_file_timestamp
+        end
+      end
+
+      def delete_local
+        puts "[fs] deleting file #{local_path}"
+        saving_parent_timestamp do
+          FileUtils.rm_rf(local_path)
+        end
+      end
+
+      def update_local
+        puts "[fs] updating file #{local_path}"
+        download
+        update_file_timestamp
+      end
+
+      def create_remote
+        upload
+      end
+
+      def delete_remote
+        api.delete_file(remote_path)
+      end
+
+      def update_remote
+        upload
+      end
+
+      def download
+        res = api.get_file(remote_path)
+
+        File.open(local_path, "w") do |f|
+          f << res
+        end
+        update_file_timestamp
+      end
+
+      def upload
+        File.open(local_path) do |f|
+          res = api.put_file(remote_path, f)
+        end
+      end
+    end
+  end
+end