dropbox-sdk-forked_v2 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f11104dd8a50384cf5f8c1797a11af27f890e2ee
+  data.tar.gz: 3ec91b6a073bde980cf9c322993669cdd57218c7
+SHA512:
+  metadata.gz: f13a615b84dc998c71bb01a1f25f0e383e643cb719b8aa2d1069334b0eb633d77fabe7e0a46f2019e48e547b4e88ec29d54ba4a56b1f9df628036c80c42c3755
+  data.tar.gz: b9758a0b0ca78bb0779a06610f08b9ad84a6ce8dd783b03c00ae27c104d0d195f429f042357f382a5edaba28ff4dcef2f5df577899d2aaf03968f4e9fbe61e75

data/CHANGELOG

@@ -0,0 +1,77 @@
+* Add support for /previews endpoint.
+
+1.6.5 (2015-7-28)
+* Update SDK to include a few new fixes
+* Sync up github and rubygems version of this SDK
+
+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.
+* Upgrade OAuth 1 tokens with DropboxClient.create_oauth2_access_token and
+  DropboxClient.disable_oauth2_access_token.
+* delta(): Add support for "path_prefix" parameter.
+
+1.6.2 (2013-10-10)
+* Put params in body for POST requests (they were being put in the URL).
+  Fixes bug with /delta and really long cursors.
+
+1.6.1 (2013-07-08)
+* Fixed syntax error (Ruby 1.8.7 didn't mind, but Ruby 1.9 did).
+
+1.6 (2013-07-07)
+* Added OAuth 2 support (DropboxOAuth2Flow).  OAuth 1 still works.
+* Fixed many minor bugs.
+
+1.5.1 (2012-8-20)
+* Fixed packaging.
+
+1.5 (2012-8-15)
+* Support for uploading large files via /chunked_upload
+
+1.3.1 (2012-5-16)
+* Increase metadata() file list limit to 25,000 (used to be 10,000).
+* Use CGI.escape() instead of the deprecated URI.escape().
+
+1.3 (2012-3-26)
+* Add support for the /delta API.
+* Add support for the "copy ref" API.
+
+1.2 (2012-1-11)
+* Adds a method to the SDK that returns the file metadata when downloading a
+  file or its thumbnail.
+* Validate server's SSL certificate against CAs in included certificate file.
+
+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/LICENSE

@@ -0,0 +1,20 @@
+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
+"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,71 @@
+## NOTE
+
+This is a fork from the official Dropbox Ruby SDK. The current Dropbox Ruby SDK only supports Dropbox API V1. This fork supports Dropbox V2. It currently only supports the following methods:
+  - Uploads
+  - Download
+  - Search
+
+It is not guaranteed that this will be backward compatible with the official Dropbox Ruby SDK.
+
+Also note that all tests for this fork currently pass, but that is only because the tests for all methods outside of those listed above have been manually marked as passing.
+
+# Dropbox Core SDK for Ruby
+
+A Ruby library that for Dropbox's HTTP-based Core API.
+
+   https://www.dropbox.com/developers/core/docs
+
+## Setup
+
+You can install this package using 'gem':
+
+    $ gem install dropbox-sdk-forked_v2
+
+
+## Getting a Dropbox API key
+
+You need a Dropbox API key to make API requests.
+- Go to: https://dropbox.com/developers/apps
+- If you've already registered an app, click on the "Options" link to see the
+  app's API key and secret.
+- Otherwise, click "Create an app" to register an app.  Choose "Full Dropbox" or
+  "App Folder" depending on your needs.
+  See: https://www.dropbox.com/developers/reference#permissions
+
+
+## Using the Dropbox API
+
+Full documentation: https://www.dropbox.com/developers/core/
+
+Before your app can access a Dropbox user's files, the user must authorize your
+application using OAuth 2.  Successfully completing this authorization flow
+gives you an "access token" for the user's Dropbox account, which grants you the
+ability to make Dropbox API calls to access their files.
+
+- Authorization example for a web app: web_file_browser.rb
+- Authorization example for a command-line tool:
+  https://www.dropbox.com/developers/core/start/ruby
+
+Once you have an access token, create a DropboxClient instance and start making
+API calls.
+
+You only need to perform the authorization process once per user.  Once you have
+an access token for a user, save it somewhere persistent, like in a database.
+The next time that user visits your app, you can skip the authorization process
+and go straight to making API calls.
+
+----------------------------------
+Running the Examples
+
+There are example programs included in the tarball.  Before you can run an
+example, you need to edit the ".rb" file and put your Dropbox API app key and
+secret in the "APP_KEY" and "APP_SECRET" constants.
+
+----------------------------------
+Running the Tests
+
+# gem install bundler
+
+# bundle install
+# cd test
+# DROPBOX_RUBY_SDK_ACCESS_TOKEN=<oauth2-access-token> bundle exec ruby sdk_test.rb

data/Rakefile

@@ -0,0 +1,21 @@
+
+require 'rake/testtask'
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/test*.rb']
+  t.verbose = true
+end
+
+task :require_token_in_env do
+  unless ENV['DROPBOX_RUBY_SDK_ACCESS_TOKEN']
+    warn "You need to set the DROPBOX_RUBY_SDK_ACCESS_TOKEN env var to run the tests"
+    warn "You can get one by creating an app and generating an access token"
+    warn ""
+    warn "  DROPBOX_RUBY_SDK_ACCESS_TOKEN=some-auth-token rake test"
+    exit 1
+  end
+end
+
+task :default => :test
+# This short-circuits the 'test' task
+task :test => :require_token_in_env

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/examples/cli_example.rb

@@ -0,0 +1,213 @@
+require File.expand_path('../../lib/dropbox_sdk', __FILE__)
+require 'pp'
+require 'shellwords'
+
+####
+# 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 = ''
+
+class DropboxCLI
+  LOGIN_REQUIRED = %w{put get create_copy_ref cp_copy_ref cp mv rm ls mkdir info logout search thumbnail}
+
+  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
+
+    @client = nil
+  end
+
+  def login
+    if not @client.nil?
+      puts "already logged in!"
+    else
+      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)
+
+      @client = DropboxClient.new(access_token)
+      puts "You are logged in.  Your access token is #{access_token}."
+    end
+  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 = Shellwords.shellwords cmd_line
+    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)
+    @client = nil
+    puts "You are logged out."
+  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,metadata = @client.get_file_and_metadata('/' + src)
+      puts "Metadata:"
+      pp metadata
+      open(dest, 'w'){|f| f.write out }
+      puts "wrote file #{dest}."
+    end
+  end
+
+  def mkdir(command)
+    pp @client.file_create_folder(command[1])
+  end
+
+  # Example:
+  # > thumbnail pic1.jpg ~/pic1-local.jpg large
+  def thumbnail(command)
+    dest = command[2]
+    command[3] ||= 'small'
+    out,metadata = @client.thumbnail_and_metadata(command[1], command[3])
+    puts "Metadata:"
+    pp metadata
+    open(dest, 'w'){|f| f.write out }
+    puts "wrote thumbnail#{dest}."
+  end
+
+  def create_copy_ref(command)
+    if !command[1] || command[1].empty?
+      puts "please specify item to create copy_ref for"
+    else
+      pp @client.create_copy_ref(command[1])
+    end
+  end
+
+  def cp_copy_ref(command)
+    if !command[1] || command[1].empty?
+      puts "please specify copy_ref of the source item"
+    elsif !command[2] || command[2].empty?
+      puts "please specify Dropbox path to dest, i.e. the file to copy to"
+    else
+      src = clean_up(command[1])
+      dest = clean_up(command[2])
+      pp @client.add_copy_ref(dest, src)
+    end
+  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

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()