dropbox-sdk 1.6.3 → 1.6.4

data/CHANGELOG

@@ -1,3 +1,8 @@
+1.6.4 (2014-4-12)
+* Bugfixes
+* Update gemspec to include all examples
+* Release tests and other internal scripts
+
 1.6.3 (2013-12-11)
 * Stricter SSL: Update certs, use only approved ciphersuites, work around
   Ruby SSL bugs.

data/README

@@ -7,9 +7,9 @@ A Ruby library that for Dropbox's HTTP-based Core API.
 ----------------------------------
 Setup
 
-You can install this package using 'pip':
+You can install this package using 'gem':
 
-   # pip install dropbox
+   # gem install dropbox-sdk
 
 ----------------------------------
 Getting a Dropbox API key

data/examples/chunked_upload.rb

@@ -0,0 +1,71 @@
+# An example use of the /chunked_upload API call.
+
+require File.expand_path('../../lib/dropbox_sdk', __FILE__)
+
+# 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 = ''
+
+STATE_FILE = 'search_cache.json'
+
+def main()
+    if APP_KEY == '' or APP_SECRET == ''
+        warn "ERROR: Set your APP_KEY and APP_SECRET at the top of search_cache.rb"
+        exit
+    end
+    prog_name = __FILE__
+    args = ARGV
+    if args.size == 0
+        warn("Usage:\n")
+        warn("   #{prog_name} <local-file-path> <dropbox-target-path> <chunk-size-in-bytes>")
+        exit
+    end
+
+    if args.size != 3
+        warn "ERROR: expecting exactly three arguments.  Run with no arguments for help."
+        exit(1)
+    end
+
+    web_auth = DropboxOAuth2FlowNoRedirect.new(APP_KEY, APP_SECRET)
+    authorize_url = web_auth.start()
+    puts "1. Go to: #{authorize_url}"
+    puts "2. Click \"Allow\" (you might have to log in first)."
+    puts "3. Copy the authorization code."
+
+    print "Enter the authorization code here: "
+    STDOUT.flush
+    auth_code = STDIN.gets.strip
+
+    access_token, user_id = web_auth.finish(auth_code)
+
+    c = DropboxClient.new(access_token)
+
+    local_file_path = args[0]
+    dropbox_target_path = args[1]
+    chunk_size = args[2].to_i
+
+    # Upload the file
+    local_file_size = File.size(local_file_path)
+    uploader = c.get_chunked_uploader(File.new(local_file_path, "r"), local_file_size)
+    retries = 0
+    puts "Uploading..."
+    while uploader.offset < uploader.total_size
+        begin
+            uploader.upload(chunk_size)
+        rescue DropboxError => e
+            if retries > 10
+                puts "- Error uploading, giving up."
+                break
+            end
+            puts "- Error uploading, trying again..."
+            retries += 1
+        end
+    end
+    puts "Finishing upload..."
+    uploader.finish(dropbox_target_path)
+    puts "Done."
+
+end
+
+main()

data/{cli_example.rb → examples/cli_example.rb}

@@ -1,5 +1,6 @@
-require './lib/dropbox_sdk'
+require File.expand_path('../../lib/dropbox_sdk', __FILE__)
 require 'pp'
+require 'shellwords'
 
 ####
 # An example app using the Dropbox API Ruby Client
@@ -65,7 +66,7 @@ class DropboxCLI
     end
 
     def execute_dropbox_command(cmd_line)
-        command = cmd_line.split
+        command = Shellwords.shellwords cmd_line
         method = command.first
         if LOGIN_REQUIRED.include? method
             if @client

data/examples/copy_between_accounts.rb

@@ -0,0 +1,148 @@
+require File.expand_path('../../lib/dropbox_sdk', __FILE__)
+require 'json'
+
+# 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 = ''
+
+STATE_FILE = 'copy_between_accounts.json'
+
+def main()
+    prog_name = __FILE__
+    if APP_KEY == '' or APP_SECRET == ''
+        warn "ERROR: Set your APP_KEY and APP_SECRET at the top of #{prog_name}"
+        exit
+    end
+    args = ARGV
+    if args.size == 0
+        warn("Usage:\n")
+        warn("   #{prog_name} link                                   Link to a user's account.  Also displays UID.")
+        warn("   #{prog_name} list                                   List linked users including UID.")
+        warn("   #{prog_name} copy '<uid>:<path>' '<uid>:<path>'     Copies a file from the first user's path, to the second user's path.")
+        warn("\n\n   <uid> is the account UID shown when linked.  <path> is a path to a file on that user's dropbox.")
+        exit
+    end
+
+    command = args[0]
+    if command == 'link'
+        command_link(args)
+    elsif command == 'list'
+        command_list(args)
+    elsif command == 'copy'
+        command_copy(args)
+    else
+        warn "ERROR: Unknown command: #{command}"
+        warn "Run with no arguments for help."
+        exit(1)
+    end
+end
+
+def command_link(args)
+    if args.size != 1
+        warn "ERROR: \"link\" doesn't take any arguments"
+        exit
+    end
+
+    web_auth = DropboxOAuth2FlowNoRedirect.new(APP_KEY, APP_SECRET)
+    authorize_url = web_auth.start()
+    puts "1. Go to: #{authorize_url}"
+    puts "2. Click \"Allow\" (you might have to log in first)."
+    puts "3. Copy the authorization code."
+
+    print "Enter the authorization code here: "
+    STDOUT.flush
+    auth_code = STDIN.gets.strip
+
+    access_token, user_id = web_auth.finish(auth_code)
+
+    c = DropboxClient.new(access_token)
+    account_info = c.account_info()
+    puts "Link successful. #{account_info['display_name']} is uid #{account_info['uid']} "
+
+    state = load_state()
+    state[account_info['uid']] = {
+                    'access_token' => access_token,
+                    'display_name' => account_info['display_name'],
+    }
+
+    if account_info['team']
+        state[account_info['uid']]['team_name'] = account_info['team']['name']
+    end
+
+    save_state(state)
+end
+
+def command_list(args)
+    if args.size != 1
+        warn "ERROR: \"list\" doesn't take any arguments"
+        exit
+    end
+
+    state = load_state()
+    for e in state.keys()
+        if state[e]['team_name']
+            puts "#{state[e]['display_name']} (#{state[e]['team_name']}) is uid #{e}"
+        else
+            puts "#{state[e]['display_name']} is uid #{e}"
+        end
+    end
+end
+
+def command_copy(args)
+    if args.size != 3
+        warn "ERROR: \"copy\" takes exactly two arguments"
+        exit
+    end
+
+    state = load_state()
+
+    if state.keys().length < 2
+        warn "ERROR: You can't use the copy command until at least two users have linked"
+        exit
+    end
+
+    from = args[1].gsub(/['"]/,'')
+    to = args[2].gsub(/['"]/,'')
+
+    if not to.index(':') or not from.index(':')
+        warn "ERROR: Ill-formated paths. Run #{prog_name} without arugments to see documentation."
+        exit
+    end
+
+    from_uid, from_path = from.split ":"
+    to_uid, to_path = to.split ":"
+
+    if not state.has_key?(to_uid) or not state.has_key?(from_uid)
+        warn "ERROR: Those UIDs have not linked.  Run #{prog_name} list to see linked UIDs."
+        exit
+    end
+
+    from_client = DropboxClient.new(state[from_uid]['access_token'])
+    to_client = DropboxClient.new(state[to_uid]['access_token'])
+
+    #Create a copy ref under the identity of the from user
+    copy_ref = from_client.create_copy_ref(from_path)['copy_ref']
+
+    metadata = to_client.add_copy_ref(to_path, copy_ref)
+
+    puts "File successly copied from #{state[from_uid]['display_name']} to #{state[to_uid]['display_name']}!"
+    puts "The file now exists at #{metadata['path']}"
+
+end
+
+def save_state(state)
+    File.open(STATE_FILE,"w") do |f|
+        f.write(JSON.pretty_generate(state))
+    end
+end
+
+def load_state()
+    if not FileTest.exists?(STATE_FILE)
+        return {}
+    end
+    JSON.parse(File.read(STATE_FILE))
+end
+
+
+main()

data/{dropbox_controller.rb → examples/dropbox_controller.rb}

@@ -3,18 +3,24 @@
 # - Runs the through Dropbox's OAuth 2 flow, yielding a Dropbox API access token.
 # - Makes a Dropbox API call to upload a file.
 #
+# To set up:
+# 1. Create a Dropbox App key and secret to use the API. https://www.dropbox.com/developers
+# 2. Add http://localhost:3000/dropbox/auth_finish as a Redirect URI for your Dropbox app.
+# 3. Copy your App key and App secret into APP_KEY and APP_SECRET below.
+#
 # To run:
 # 1. You need a Rails 3 project (to create one, run: rails new <folder-name>)
-# 2. Copy this file into <folder-name>/app/controllers/
-# 3. Add the following lines to <folder-name>/config/routes.rb
+# 2. Copy dropbox_sdk.rb into <folder-name>/vendor
+# 3. Copy this file into <folder-name>/app/controllers/
+# 4. Add the following lines to <folder-name>/config/routes.rb
 #        get  "dropbox/main"
 #        post "dropbox/upload"
 #        get  "dropbox/auth_start"
 #        get  "dropbox/auth_finish"
-# 4. Run: rails server
-# 5. Point your browser at: https://localhost:3000/dropbox/main
+# 5. Run: rails server
+# 6. Point your browser at: https://localhost:3000/dropbox/main
 
-require '../lib/dropbox_sdk'
+require 'dropbox_sdk'
 require 'securerandom'
 
 APP_KEY = ""

data/examples/oauth1_upgrade.rb

@@ -0,0 +1,40 @@
+require File.expand_path('../../lib/dropbox_sdk', __FILE__)
+require 'pp'
+
+# 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 = ''
+
+def main
+    if APP_KEY == '' or APP_SECRET == ''
+        warn "ERROR: Set your APP_KEY and APP_SECRET at the top of search_cache.rb"
+        exit
+    end
+
+    prog_name = __FILE__
+    args = ARGV
+    if args.size != 2
+        warn "Usage: #{prog_name} <oauth1-access-token-key> <oauth1-access-token-secret>"
+        exit 1
+    end
+
+    access_token_key = args[0]
+    access_token_secret = args[1]
+
+    sess = DropboxSession.new(APP_KEY, APP_SECRET)
+    sess.set_access_token(access_token_key, access_token_secret)
+    c = DropboxClient.new(sess)
+
+    print "Creating OAuth 2 access token...\n"
+    oauth2_access_token = c.create_oauth2_access_token
+
+    print "Using OAuth 2 access token to get account info...\n"
+    c2 = DropboxClient.new(oauth2_access_token)
+    pp c2.account_info
+
+    print "Disabling OAuth 1 access token...\n"
+    c.disable_access_token
+end
+
+main()

data/examples/search_cache.rb

@@ -0,0 +1,322 @@
+# An example use of the /delta API call.  Maintains a local cache of
+# the App Folder's contents.  Use the 'update' sub-command to update
+# the local cache.  Use the 'find' sub-command to search the local
+# cache.
+#
+# Example usage:
+#
+# 1. Link to your Dropbox account
+#    > ruby search_cache.rb link
+#
+# 2. Go to Dropbox and make changes to the contents.
+#
+# 3. Update the local cache to match what's on Dropbox.
+#    > ruby search_cache.rb update
+#
+# 4. Search the local cache.
+#    > ruby search_cache.rb find 'txt'
+
+# Repeat steps 2-4 any number of times.
+
+
+
+require File.expand_path('../../lib/dropbox_sdk', __FILE__)
+require 'json'
+
+# 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 = ''
+
+STATE_FILE = 'search_cache.json'
+
+def main()
+    if APP_KEY == '' or APP_SECRET == ''
+        warn "ERROR: Set your APP_KEY and APP_SECRET at the top of search_cache.rb"
+        exit
+    end
+    prog_name = __FILE__
+    args = ARGV
+    if args.size == 0
+        warn("Usage:\n")
+        warn("   #{prog_name} link          Link to a user's account.")
+        warn("   #{prog_name} update        Update cache to the latest on Dropbox.")
+        warn("   #{prog_name} update <num>  Update cache, limit to <num> pages of /delta.")
+        warn("   #{prog_name} find <term>   Search cache for <term>.")
+        warn("   #{prog_name} find          Display entire cache contents")
+        warn("   #{prog_name} reset         Delete the cache.")
+        exit
+    end
+
+    command = args[0]
+    if command == 'link'
+        command_link(args)
+    elsif command == 'update'
+        command_update(args)
+    elsif command == 'find'
+        command_find(args)
+    elsif command == 'reset'
+        command_reset(args)
+    else
+        warn "ERROR: Unknown command: #{command}"
+        warn "Run with no arguments for help."
+        exit(1)
+    end
+end
+
+
+def command_link(args)
+    if args.size != 1
+        warn "ERROR: \"link\" doesn't take any arguments"
+        exit
+    end
+
+    web_auth = DropboxOAuth2FlowNoRedirect.new(APP_KEY, APP_SECRET)
+    authorize_url = web_auth.start()
+    puts "1. Go to: #{authorize_url}"
+    puts "2. Click \"Allow\" (you might have to log in first)."
+    puts "3. Copy the authorization code."
+
+    print "Enter the authorization code here: "
+    STDOUT.flush
+    auth_code = STDIN.gets.strip
+
+    access_token, user_id = web_auth.finish(auth_code)
+    puts "Link successful."
+
+    save_state({
+        'access_token' => access_token,
+        'tree' => {}
+    })
+end
+
+
+def command_update(args)
+    if args.size == 1
+        page_limit = nil
+    elsif args.size == 2
+        page_limit = Integer(args[1])
+    else
+        warn "ERROR: \"update\" takes either zero or one argument."
+        exit
+    end
+
+    # Load state
+    state = load_state()
+    access_token = state['access_token']
+    cursor = state['cursor']
+    tree = state['tree']
+
+    # Connect to Dropbox
+    c = DropboxClient.new(access_token)
+
+    page = 0
+    changed = false
+    while (page_limit == nil) or (page < page_limit)
+        # Get /delta results from Dropbox
+        result = c.delta(cursor)
+        page += 1
+        if result['reset'] == true
+            puts 'reset'
+            changed = true
+            tree = {}
+        end
+        cursor = result['cursor']
+        # Apply the entries one by one to our cached tree.
+        for delta_entry in result['entries']
+            changed = true
+            apply_delta(tree, delta_entry)
+        end
+        cursor = result['cursor']
+        if not result['has_more']
+            break
+        end
+    end
+
+    # Save state
+    if changed
+        state['cursor'] = cursor
+        state['tree'] = tree
+        save_state(state)
+    else
+        puts "No updates."
+    end
+
+end
+
+# We track folder state as a tree of Node objects.
+class Node
+    attr_accessor :path, :content
+    def initialize(path, content)
+        # The "original" page (i.e. not the lower-case path)
+        @path = path
+        # For files, content is a pair (size, modified)
+        # For folders, content is a hash of children Nodes, keyed by lower-case file names.
+        @content = content
+    end
+    def folder?()
+        @content.is_a? Hash
+    end
+    def to_json()
+        [@path, Node.to_json_content(@content)]
+    end
+    def self.from_json(jnode)
+        path, jcontent = jnode
+        Node.new(path, Node.from_json_content(jcontent))
+    end
+    def self.to_json_content(content)
+        if content.is_a? Hash
+            map_hash_values(content) { |child| child.to_json }
+        else
+            content
+        end
+    end
+    def self.from_json_content(jcontent)
+        if jcontent.is_a? Hash
+            map_hash_values(jcontent) { |jchild| Node.from_json jchild }
+        else
+            jcontent
+        end
+    end
+end
+
+# Run a mapping function over every value in a Hash, returning a new Hash.
+def map_hash_values(h)
+    new = {}
+    h.each { |k,v| new[k] = yield v }
+    new
+end
+
+
+def apply_delta(root, e)
+    path, metadata = e
+    branch, leaf = split_path(path)
+
+    if metadata != nil
+        puts "+ #{path}"
+        # Traverse down the tree until we find the parent folder of the entry
+        # we want to add.  Create any missing folders along the way.
+        children = root
+        branch.each do |part|
+            node = get_or_create_child(children, part)
+            # If there's no folder here, make an empty one.
+            if not node.folder?
+                node.content = {}
+            end
+            children = node.content
+        end
+
+        # Create the file/folder.
+        node = get_or_create_child(children, leaf)
+        node.path = metadata['path']  # Save the un-lower-cased path.
+        if metadata['is_dir']
+            # Only create a folder if there isn't one there already.
+            node.content = {} if not node.folder?
+        else
+            node.content = metadata['size'], metadata['modified']
+        end
+    else
+        puts "- #{path}"
+        # Traverse down the tree until we find the parent of the entry we
+        # want to delete.
+        children = root
+        missing_parent = false
+        branch.each do |part|
+            node = children[part]
+            # If one of the parent folders is missing, then we're done.
+            if node == nil or not node.folder?
+                missing_parent = true
+                break
+            end
+            children = node.content
+        end
+        # If we made it all the way, delete the file/folder.
+        if not missing_parent
+            children.delete(leaf)
+        end
+    end
+end
+
+def get_or_create_child(children, name)
+    child = children[name]
+    if child == nil
+        children[name] = child = Node.new(nil, nil)
+    end
+    child
+end
+
+def split_path(path)
+    bad, *parts = path.split '/'
+    [parts, parts.pop]
+end
+
+
+def command_find(args)
+    if args.size == 1
+        term = ''
+    elsif args.size == 2
+        term = args[1]
+    else
+        warn("ERROR: \"find\" takes either zero or one arguments.")
+        exit
+    end
+
+    state = load_state()
+    results = []
+    search_tree(results, state['tree'], term)
+    for r in results
+        puts("#{r}")
+    end
+    puts("[Matches: #{results.size}]")
+end
+
+
+def command_reset(args)
+    if args.size != 1
+        warn("ERROR: \"reset\" takes no arguments.")
+        exit
+    end
+
+    # Delete cursor, empty tree.
+    state = load_state()
+    if state.has_key?('cursor')
+        state.delete('cursor')
+    end
+    state['tree'] = {}
+    save_state(state)
+end
+
+
+# Recursively search 'tree' for files that contain the string in 'term'.
+# Print out any matches.
+def search_tree(results, tree, term)
+    tree.each do |name_lc, node|
+        path = node.path
+        if (path != nil) and path.include?(term)
+            if node.folder?
+                results.push("#{path}")
+            else
+                size, modified = node.content
+                results.push("#{path}  (#{size}, #{modified})")
+            end
+        end
+        if node.folder?
+            search_tree(results, node.content, term)
+        end
+    end
+end
+
+def save_state(state)
+    state['tree'] = Node.to_json_content(state['tree'])
+    File.open(STATE_FILE,"w") do |f|
+        f.write(JSON.pretty_generate(state, :max_nesting => false))
+    end
+end
+
+def load_state()
+    state = JSON.parse(File.read(STATE_FILE), :max_nesting => false)
+    state['tree'] = Node.from_json_content(state['tree'])
+    state
+end
+
+main()

data/{web_file_browser.rb → examples/web_file_browser.rb}

@@ -4,6 +4,11 @@
 # - The webapp OAuth process.
 # - The metadata() and put_file() calls.
 #
+# To set up:
+# 1. Create a Dropbox App key and secret to use the API. https://www.dropbox.com/developers
+# 2. Add http://localhost:4567/dropbox-auth-finish as a Redirect URI for your Dropbox app.
+# 3. Copy your App key and App secret into APP_KEY and APP_SECRET below.
+#
 # To run:
 # 1. Install Sinatra  $ gem install sinatra
 # 2. Launch server    $ ruby web_file_browser.rb
@@ -14,7 +19,7 @@ require 'rubygems'
 require 'sinatra'
 require 'pp'
 require 'securerandom'
-require './lib/dropbox_sdk'
+require File.expand_path('../../lib/dropbox_sdk', __FILE__)
 
 # Get your app's key and secret from https://www.dropbox.com/developers/
 APP_KEY = ''

data/lib/dropbox_sdk.rb

@@ -1,4 +1,3 @@
-require 'rubygems'
 require 'uri'
 require 'net/https'
 require 'cgi'
@@ -14,7 +13,7 @@ module Dropbox # :nodoc:
     WEB_SERVER = "www.dropbox.com"
 
     API_VERSION = 1
-    SDK_VERSION = "1.6.3"
+    SDK_VERSION = "1.6.4"
 
     TRUSTED_CERT_FILE = File.join(File.dirname(__FILE__), 'trusted-certs.crt')
 
@@ -88,7 +87,7 @@ module Dropbox # :nodoc:
             http.request(request)
         rescue OpenSSL::SSL::SSLError => e
             raise DropboxError.new("SSL error connecting to Dropbox.  " +
-                                   "There may be a problem with the set of certificates in \"#{Dropbox::TRUSTED_CERT_FILE}\".  #{e}")
+                                   "There may be a problem with the set of certificates in \"#{Dropbox::TRUSTED_CERT_FILE}\".  #{e.message}")
         end
     end
 
@@ -861,9 +860,18 @@ class DropboxClient
                 begin
                     resp = Dropbox::parse_response(@client.partial_chunked_upload(last_chunk, @upload_id, @offset))
                     last_chunk = nil
+                rescue SocketError => e
+                  raise e
+                rescue SystemCallError => e
+                  raise e
                 rescue DropboxError => e
-                    resp = JSON.parse(e.http_response.body)
-                    raise unless resp.has_key? 'offset'
+                  raise e if e.http_response.nil? or e.http_response.code[0] == '5'
+                    begin
+                      resp = JSON.parse(e.http_response.body)
+                      raise DropboxError.new('server response does not have offset key') unless resp.has_key? 'offset'
+                    rescue JSON::ParserError
+                      raise DropboxError.new("Unable to parse JSON response: #{e.http_response.body}")
+                    end
                 end
 
                 if resp.has_key? 'offset' and resp['offset'] > @offset

metadata

@@ -1,13 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: dropbox-sdk
 version: !ruby/object:Gem::Version 
-  hash: 9
-  prerelease: 
+  prerelease: false
   segments: 
   - 1
   - 6
-  - 3
-  version: 1.6.3
+  - 4
+  version: 1.6.4
 platform: ruby
 authors: 
 - Dropbox, Inc.
@@ -15,17 +14,16 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-12-11 00:00:00 Z
+date: 2014-04-24 00:00:00 -07:00
+default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: json
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
         segments: 
         - 0
         version: "0"
@@ -44,11 +42,16 @@ files:
 - CHANGELOG
 - LICENSE
 - README
-- cli_example.rb
-- dropbox_controller.rb
-- web_file_browser.rb
+- examples/cli_example.rb
+- examples/dropbox_controller.rb
+- examples/web_file_browser.rb
+- examples/copy_between_accounts.rb
+- examples/chunked_upload.rb
+- examples/oauth1_upgrade.rb
+- examples/search_cache.rb
 - lib/dropbox_sdk.rb
 - lib/trusted-certs.crt
+has_rdoc: true
 homepage: http://www.dropbox.com/developers/
 licenses: 
 - MIT
@@ -58,27 +61,23 @@ rdoc_options: []
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: Dropbox REST API Client.