dbox 0.5.3 → 0.6.0

data/lib/dbox/utils.rb

@@ -0,0 +1,82 @@
+module Dbox
+  module Utils
+    def times_equal?(t1, t2)
+      time_to_s(t1) == time_to_s(t2)
+    end
+
+    def time_to_s(t)
+      case t
+      when Time
+        # matches dropbox time format
+        t.utc.strftime("%a, %d %b %Y %H:%M:%S +0000")
+      when String
+        t
+      end
+    end
+
+    def parse_time(t)
+      case t
+      when Time
+        t
+      when String
+        Time.parse(t)
+      end
+    end
+
+    # assumes local_path is defined
+    def local_to_relative_path(path)
+      if path.include?(local_path)
+        path.sub(local_path, "").sub(/^\//, "")
+      else
+        raise BadPath, "Not a local path: #{path}"
+      end
+    end
+
+    # assumes remote_path is defined
+    def remote_to_relative_path(path)
+      if path.include?(remote_path)
+        path.sub(remote_path, "").sub(/^\//, "")
+      else
+        raise BadPath, "Not a remote path: #{path}"
+      end
+    end
+
+    # assumes local_path is defined
+    def relative_to_local_path(path)
+      if path && path.length > 0
+        File.join(local_path, path)
+      else
+        local_path
+      end
+    end
+
+    # assumes remote_path is defined
+    def relative_to_remote_path(path)
+      if path && path.length > 0
+        File.join(remote_path, path)
+      else
+        remote_path
+      end
+    end
+
+    def calculate_hash(filepath)
+      begin
+        Digest::MD5.file(filepath).to_s
+      rescue Errno::EISDIR
+        nil
+      rescue Errno::ENOENT
+        nil
+      end
+    end
+
+    def find_nonconflicting_path(filepath)
+      proposed = filepath
+      while File.exists?(proposed)
+        dir, p = File.split(proposed)
+        p = p.sub(/^(.*?)( \((\d+)\))?(\..*?)?$/) { "#{$1} (#{$3 ? $3.to_i + 1 : 1})#{$4}" }
+        proposed = File.join(dir, p)
+      end
+      proposed
+    end
+  end
+end

data/spec/dbox_spec.rb

@@ -122,6 +122,101 @@ describe Dbox do
       Dbox.pull(@local).should eql(:created => ["subdir", "subdir/one.txt"], :deleted => ["foo.txt"], :updated => ["", "baz.txt"], :failed => [])
       Dbox.pull(@local).should eql(:created => [], :deleted => [], :updated => [], :failed => [])
     end
+
+    it "should be able to download a bunch of files at the same time" do
+      Dbox.create(@remote, @local)
+      @alternate = "#{ALTERNATE_LOCAL_TEST_PATH}/#{@name}"
+      Dbox.clone(@remote, @alternate)
+
+      # generate 20 x 100kB files
+      20.times do
+        make_file "#{@alternate}/#{randname}.txt", 100
+      end
+
+      Dbox.push(@alternate)
+
+      res = Dbox.pull(@local)
+      res[:deleted].should eql([])
+      res[:updated].should eql([""])
+      res[:failed].should eql([])
+      res[:created].size.should eql(20)
+    end
+
+    it "should be able to pull a series of updates to the same file" do
+      Dbox.create(@remote, @local)
+      @alternate = "#{ALTERNATE_LOCAL_TEST_PATH}/#{@name}"
+      Dbox.clone(@remote, @alternate)
+
+      make_file "#{@local}/hello.txt"
+      Dbox.push(@local)
+      Dbox.pull(@alternate).should eql(:created => ["hello.txt"], :deleted => [], :updated => [""], :failed => [])
+      make_file "#{@local}/hello.txt"
+      Dbox.push(@local)
+      Dbox.pull(@alternate).should eql(:created => [], :deleted => [], :updated => ["", "hello.txt"], :failed => [])
+      make_file "#{@local}/hello.txt"
+      Dbox.push(@local)
+      Dbox.pull(@alternate).should eql(:created => [], :deleted => [], :updated => ["", "hello.txt"], :failed => [])
+    end
+
+    it "should handle conflicting pulls of new files gracefully" do
+      Dbox.create(@remote, @local)
+      @alternate = "#{ALTERNATE_LOCAL_TEST_PATH}/#{@name}"
+      Dbox.clone(@remote, @alternate)
+
+      make_file "#{@local}/hello.txt"
+      Dbox.push(@local)
+
+      make_file "#{@alternate}/hello.txt"
+      Dbox.pull(@alternate).should eql(:created => ["hello.txt"], :deleted => [], :updated => [""], :conflicts => [{:original => "hello.txt", :renamed => "hello (1).txt"}], :failed => [])
+    end
+
+    it "should handle conflicting pulls of updated files gracefully" do
+      Dbox.create(@remote, @local)
+      @alternate = "#{ALTERNATE_LOCAL_TEST_PATH}/#{@name}"
+      Dbox.clone(@remote, @alternate)
+
+      make_file "#{@local}/hello.txt"
+      Dbox.push(@local)
+      Dbox.pull(@alternate).should eql(:created => ["hello.txt"], :deleted => [], :updated => [""], :failed => [])
+
+      make_file "#{@local}/hello.txt"
+      Dbox.push(@local)
+
+      make_file "#{@alternate}/hello.txt"
+      Dbox.pull(@alternate).should eql(:created => [], :deleted => [], :updated => ["", "hello.txt"], :conflicts => [{:original => "hello.txt", :renamed => "hello (1).txt"}], :failed => [])
+    end
+
+    it "should deal with all sorts of weird filenames when renaming due to conflicts on pull" do
+      Dbox.create(@remote, @local)
+      @alternate = "#{ALTERNATE_LOCAL_TEST_PATH}/#{@name}"
+      Dbox.clone(@remote, @alternate)
+
+      make_file "#{@local}/hello.txt"
+      make_file "#{@local}/hello (1).txt"
+      make_file "#{@local}/goodbye.txt"
+      Dbox.push(@local)
+
+      make_file "#{@alternate}/hello.txt"
+      make_file "#{@alternate}/hello (1).txt"
+      make_file "#{@alternate}/hello (3).txt"
+      make_file "#{@alternate}/hello (4).txt"
+      make_file "#{@alternate}/hello (test).txt"
+      make_file "#{@alternate}/goodbye.txt"
+      make_file "#{@alternate}/goodbye (1).txt"
+      make_file "#{@alternate}/goodbye (2).txt"
+      make_file "#{@alternate}/goodbye (3).txt"
+      make_file "#{@alternate}/goodbye ().txt"
+
+      # there's a race condition, so the output could be one of two things
+      res = Dbox.pull(@alternate)
+      res[:created].should eql(["goodbye.txt", "hello (1).txt", "hello.txt"])
+      res[:updated].should eql([""])
+      res[:deleted].should eql([])
+      res[:failed].should eql([])
+      c = (res[:conflicts] == [{:original => "goodbye.txt", :renamed => "goodbye (4).txt"}, {:original => "hello (1).txt", :renamed => "hello (5).txt"}, {:original => "hello.txt", :renamed => "hello (2).txt"}]) ||
+        (res[:conflicts] == [{:original => "goodbye.txt", :renamed => "goodbye (4).txt"}, {:original => "hello (1).txt", :renamed => "hello (2).txt"}, {:original => "hello.txt", :renamed => "hello (5).txt"}])
+      c.should be_true
+    end
   end
 
   describe "#push" do
@@ -230,6 +325,112 @@ describe Dbox do
       rm_rf @local
       Dbox.clone(@remote, @local).should eql(:created => [crazy_name1, File.join(crazy_name1, "foo.txt")], :deleted => [], :updated => [""], :failed => [])
     end
+
+    it "should be able to upload a bunch of files at the same time" do
+      Dbox.create(@remote, @local)
+
+      # generate 20 x 100kB files
+      20.times do
+        make_file "#{@local}/#{randname}.txt", 100
+      end
+
+      res = Dbox.push(@local)
+      res[:deleted].should eql([])
+      res[:updated].should eql([])
+      res[:failed].should eql([])
+      res[:created].size.should eql(20)
+    end
+
+    it "should be able to push a series of updates to the same file" do
+      Dbox.create(@remote, @local)
+
+      make_file "#{@local}/hello.txt"
+      Dbox.push(@local).should eql(:created => ["hello.txt"], :deleted => [], :updated => [], :failed => [])
+      make_file "#{@local}/hello.txt"
+      Dbox.push(@local).should eql(:created => [], :deleted => [], :updated => ["hello.txt"], :failed => [])
+      make_file "#{@local}/hello.txt"
+      Dbox.push(@local).should eql(:created => [], :deleted => [], :updated => ["hello.txt"], :failed => [])
+    end
+
+    it "should handle conflicting pushes of new files gracefully" do
+      Dbox.create(@remote, @local)
+
+      @alternate = "#{ALTERNATE_LOCAL_TEST_PATH}/#{@name}"
+      Dbox.clone(@remote, @alternate)
+
+      make_file "#{@local}/hello.txt"
+      Dbox.push(@local).should eql(:created => ["hello.txt"], :deleted => [], :updated => [], :failed => [])
+
+      make_file "#{@alternate}/hello.txt"
+      Dbox.push(@alternate).should eql(:created => [], :deleted => [], :updated => [], :conflicts => [{:original => "hello.txt", :renamed => "hello (1).txt"}], :failed => [])
+    end
+
+    it "should handle conflicting pushes of updated files gracefully" do
+      Dbox.create(@remote, @local)
+      make_file "#{@local}/hello.txt"
+      Dbox.push(@local)
+
+      @alternate = "#{ALTERNATE_LOCAL_TEST_PATH}/#{@name}"
+      Dbox.clone(@remote, @alternate)
+
+      make_file "#{@local}/hello.txt"
+      Dbox.push(@local).should eql(:created => [], :deleted => [], :updated => ["hello.txt"], :failed => [])
+
+      make_file "#{@alternate}/hello.txt"
+      Dbox.push(@alternate).should eql(:created => [], :deleted => [], :updated => [], :conflicts => [{:original => "hello.txt", :renamed => "hello (1).txt"}], :failed => [])
+    end
+  end
+
+  describe "#sync" do
+    it "should fail if the local dir is missing" do
+      expect { Dbox.sync(@local) }.to raise_error(Dbox::DatabaseError)
+    end
+
+    it "should be able to sync basic changes" do
+      Dbox.create(@remote, @local)
+      @alternate = "#{ALTERNATE_LOCAL_TEST_PATH}/#{@name}"
+      Dbox.clone(@remote, @alternate)
+
+      Dbox.sync(@local).should eql(:pull => { :created => [], :deleted => [], :updated => [], :failed => [] },
+                                   :push => { :created => [], :deleted => [], :updated => [], :failed => [] })
+      Dbox.sync(@alternate).should eql(:pull => { :created => [], :deleted => [], :updated => [], :failed => [] },
+                                       :push => { :created => [], :deleted => [], :updated => [], :failed => [] })
+
+      make_file "#{@local}/hello.txt"
+      Dbox.sync(@local).should eql(:pull => { :created => [], :deleted => [], :updated => [], :failed => [] },
+                                   :push => { :created => ["hello.txt"], :deleted => [], :updated => [], :failed => [] })
+      Dbox.sync(@alternate).should eql(:pull => { :created => ["hello.txt"], :deleted => [], :updated => [""], :failed => [] },
+                                       :push => { :created => [], :deleted => [], :updated => [], :failed => [] })
+    end
+
+    it "should be able to sync complex changes" do
+      Dbox.create(@remote, @local)
+      @alternate = "#{ALTERNATE_LOCAL_TEST_PATH}/#{@name}"
+      Dbox.clone(@remote, @alternate)
+
+      Dbox.sync(@local).should eql(:pull => { :created => [], :deleted => [], :updated => [], :failed => [] },
+                                   :push => { :created => [], :deleted => [], :updated => [], :failed => [] })
+      Dbox.sync(@alternate).should eql(:pull => { :created => [], :deleted => [], :updated => [], :failed => [] },
+                                       :push => { :created => [], :deleted => [], :updated => [], :failed => [] })
+
+      make_file "#{@local}/hello.txt"
+      make_file "#{@local}/goodbye.txt"
+      make_file "#{@local}/so_long.txt"
+      make_file "#{@alternate}/hello.txt"
+      make_file "#{@alternate}/farewell.txt"
+      Dbox.sync(@local).should eql(:pull => { :created => [], :deleted => [], :updated => [], :failed => [] },
+                                   :push => { :created => ["goodbye.txt", "hello.txt", "so_long.txt"], :deleted => [], :updated => [], :failed => [] })
+      Dbox.sync(@alternate).should eql(:pull => { :created => ["goodbye.txt", "hello.txt", "so_long.txt"], :deleted => [], :updated => [""], :failed => [], :conflicts => [{ :renamed => "hello (1).txt", :original => "hello.txt" }] },
+                                       :push => { :created => ["farewell.txt", "hello (1).txt"], :deleted => [], :updated => [], :failed => [] })
+
+      make_file "#{@alternate}/farewell.txt"
+      make_file "#{@alternate}/goodbye.txt"
+      make_file "#{@alternate}/au_revoir.txt"
+      Dbox.sync(@alternate).should eql(:pull => { :created => [], :deleted => [], :updated => [""], :failed => [] },
+                                       :push => { :created => ["au_revoir.txt"], :deleted => [], :updated => ["farewell.txt", "goodbye.txt"], :failed => [] })
+      Dbox.sync(@local).should eql(:pull => { :created => ["au_revoir.txt", "farewell.txt", "hello (1).txt"], :deleted => [], :updated => ["", "goodbye.txt"], :failed => [] },
+                                   :push => { :created => [], :deleted => [], :updated => [], :failed => [] })
+    end
   end
 
   describe "#move" do

data/spec/spec_helper.rb

@@ -36,8 +36,8 @@ def log
   LOGGER
 end
 
-def make_file(filepath)
-  File.open(filepath, "w") {|f| f << randname }
+def make_file(filepath, size_in_kb=1)
+  `dd if=/dev/urandom of="#{filepath.gsub('"','\"')}" bs=1024 count=#{size_in_kb} 1>/dev/null 2>/dev/null`
 end
 
 RSpec::Matchers.define :exist do

data/vendor/dropbox-ruby-sdk/CHANGELOG

@@ -0,0 +1,29 @@
+1.1 (2011-10-17)
+* Various bug fixes found during beta period
+* Improved documentation
+* Improved module structure
+* Removed dependency on the oauth module, using plaintext authentication over https
+
+1.0 (2011-8-16)
+* Backwards compatibility broken
+   - Changed interface
+   - Change 'sandbox' references to 'app_folder'
+* Updated SDK to Dropbox API Version 1, supporting all calls
+   - Added 'rev' parameter to metadata and get_file
+   - Added 'parent_rev' parameter to put_file
+   - Added search, share, media, revisions, and restore
+   - put_file uses /files_put instead of multipart POST
+   - Removed methods for calls that were removed from v1 of the REST API
+* Changed return format for calls
+   - On error (non-200 response), an exception is raised
+   - On success, the JSON is parsed and a Hash is returned
+* Updated examples
+   - Improved CLI example
+   - Added a Ruby on Rails 3 controller example
+   - Added a web based file browser/uploader that uses Sinatra
+* put_file no longer takes a "name" arugment, only takes a full path
+* Removed reliance on config files
+* Assorted bugfixes and improvements
+* All calls are now made over SSL
+* Fully documented code for RDoc generation
+* Added a CHANGELOG

data/vendor/{dropbox-client-ruby → dropbox-ruby-sdk}/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009 Dropbox (Evenflow, Inc.), http://getdropbox.com/
+Copyright (c) 2009-2011 Dropbox Inc., http://www.dropbox.com/
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/vendor/dropbox-ruby-sdk/README

@@ -0,0 +1,7 @@
+Getting started with the Dropbox Ruby SDK:
+1.  Install json and oauth ruby gems with:
+    gem install json oauth
+2.  Edit cli_example.rb to to include your APP_KEY and APP_SECRET
+3.  Try running the example app: 'ruby clie_example.rb'.
+4.  See dropbox_controller.rb for an example Ruby on Rails controller.  It needs an APP_KEY and APP_SECRET set too.
+5.  Check out the dropbox website for reference and help! http://dropbox.com/developers_beta

data/vendor/dropbox-ruby-sdk/cli_example.rb

@@ -0,0 +1,197 @@
+require './lib/dropbox_sdk'
+require 'pp'
+
+####
+# An example app using the Dropbox API Ruby Client
+#   This ruby script sets up a basic command line interface (CLI)
+#   that prompts a user to authenticate on the web, then
+#   allows them to type commands to manipulate their dropbox.
+####
+
+# You must use your Dropbox App key and secret to use the API.
+# Find this at https://www.dropbox.com/developers
+APP_KEY = ''
+APP_SECRET = ''
+ACCESS_TYPE = :app_folder #The two valid values here are :app_folder and :dropbox
+                          #The default is :app_folder, but your application might be
+                          #set to have full :dropbox access.  Check your app at
+                          #https://www.dropbox.com/developers/apps
+
+class DropboxCLI
+    LOGIN_REQUIRED = %w{put get cp mv rm ls mkdir info logout search}
+
+    def initialize
+        if APP_KEY == '' or APP_SECRET == ''
+            puts "You must set your APP_KEY and APP_SECRET in cli_example.rb!"
+            puts "Find this in your apps page at https://www.dropbox.com/developers/"
+            exit
+        end
+
+        @session = DropboxSession.new(APP_KEY, APP_SECRET)
+        @client = nil
+    end
+
+    def login
+        ########
+        # Instead of going to a authorize URL, you can set a access token key and secret
+        # from a previous session
+        ########
+        # @session.set_access_token('key', 'secret')
+
+        if @session.authorized?
+           puts "already logged in!"
+        else
+
+            # grab the request token for session
+            @session.get_request_token
+
+            authorize_url = @session.get_authorize_url
+            puts "Got a request token.  Your request token key is #{@session.request_token.key} and your token secret is #{@session.request_token.secret}"
+
+            # make the user log in and authorize this token
+            puts "AUTHORIZING", authorize_url, "Please visit that web page and hit 'Allow', then hit Enter here."
+            gets
+
+            # get the access token from the server. Its then stored in the session.
+            @session.get_access_token
+
+        end
+        puts "You are logged in.  Your access token key is #{@session.access_token.key} your secret is #{@session.access_token.secret}"
+        @client = DropboxClient.new(@session, ACCESS_TYPE)
+    end
+
+    def command_loop
+        puts "Enter a command or 'help' or 'exit'"
+        command_line = ''
+        while command_line.strip != 'exit'
+            begin
+                execute_dropbox_command(command_line)
+            rescue RuntimeError => e
+                puts "Command Line Error! #{e.class}: #{e}"
+                puts e.backtrace
+            end
+            print '> '
+            command_line = gets.strip
+        end
+        puts 'goodbye'
+        exit(0)
+    end
+
+    def execute_dropbox_command(cmd_line)
+        command = cmd_line.split
+        method = command.first
+        if LOGIN_REQUIRED.include? method
+            if @client
+                send(method.to_sym, command)
+            else
+                puts 'must be logged in; type \'login\' to get started.'
+            end
+        elsif ['login', 'help'].include? method
+            send(method.to_sym)
+        else
+            if command.first && !command.first.strip.empty?
+                puts 'invalid command. type \'help\' to see commands.'
+            end
+        end
+    end
+
+    def logout(command)
+        @session.clear_access_token
+        puts "You are logged out."
+        @client = nil
+    end
+
+    def put(command)
+        fname = command[1]
+
+        #If the user didn't specifiy the file name, just use the name of the file on disk
+        if command[2]
+            new_name = command[2]
+        else
+            new_name = File.basename(fname)
+        end
+
+        if fname && !fname.empty? && File.exists?(fname) && (File.ftype(fname) == 'file') && File.stat(fname).readable?
+            #This is where we call the the Dropbox Client
+            pp @client.put_file(new_name, open(fname))
+        else
+            puts "couldn't find the file #{ fname }"
+        end
+    end
+
+    def get(command)
+        dest = command[2]
+        if !command[1] || command[1].empty?
+            puts "please specify item to get"
+        elsif !dest || dest.empty?
+            puts "please specify full local path to dest, i.e. the file to write to"
+        elsif File.exists?(dest)
+            puts "error: File #{dest} already exists."
+        else
+            src = clean_up(command[1])
+            out = @client.get_file('/' + src)
+            open(dest, 'w'){|f| f.puts out }
+            puts "wrote file #{dest}."
+        end
+    end
+
+    def mkdir(command)
+        pp @client.file_create_folder(command[1])
+    end
+
+    def thumbnail(command)
+        command[2] ||= 'small'
+        pp @client.thumbnail(command[1], command[2])
+    end
+
+    def cp(command)
+        src = clean_up(command[1])
+        dest = clean_up(command[2])
+        pp @client.file_copy(src, dest)
+    end
+
+    def mv(command)
+        src = clean_up(command[1])
+        dest = clean_up(command[2])
+        pp @client.file_move(src, dest)
+    end
+
+    def rm(command)
+        pp @client.file_delete(clean_up(command[1]))
+    end
+
+    def search(command)
+        resp = @client.search('/',clean_up(command[1]))
+
+        for item in resp
+            puts item['path']
+        end
+    end
+
+    def info(command)
+        pp @client.account_info
+    end
+
+    def ls(command)
+        command[1] = '/' + clean_up(command[1] || '')
+        resp = @client.metadata(command[1])
+
+        if resp['contents'].length > 0
+            for item in resp['contents']
+                puts item['path']
+            end
+        end
+    end
+
+    def help
+        puts "commands are: login #{LOGIN_REQUIRED.join(' ')} help exit"
+    end
+
+    def clean_up(str)
+        return str.gsub(/^\/+/, '') if str
+        str
+    end
+end
+
+cli = DropboxCLI.new
+cli.command_loop