dropbox-sdk-v2 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f7aebcfc896301354f9bcfdc1d04ea31e83565ec
+  data.tar.gz: 38355d1a956283242d731b3160daabac149281ef
+SHA512:
+  metadata.gz: 8e6c399ffb0a1ae9e460dd7a0f120167e92ba6ababee422840dfdfbada64e3901ad6710d19a699673260a1fc9b5b22f39551199f2cad995e67ac39bfd1fef176
+  data.tar.gz: 138a4e77f9797b32ecd972f56dee81f8ac5dfae0cece5e4b4ffe747305a4a8551dd8e812fb94bc0833ed0c77bd69fda25daba7e2a8c5c22c5f2466ac368934c4

data/lib/dropbox.rb

@@ -0,0 +1,9 @@
+require_relative 'dropbox/client'
+require_relative 'dropbox/errors'
+require_relative 'dropbox/account'
+require_relative 'dropbox/metadata'
+
+module Dropbox
+  API = 'https://api.dropboxapi.com/2'
+  CONTENT_API = 'https://content.dropboxapi.com/2'
+end

data/lib/dropbox/account.rb

@@ -0,0 +1,47 @@
+module Dropbox
+  class Account
+    attr_reader :account_id, :display_name, :email, :email_verified, :disabled, :profile_photo_url
+
+    def initialize(attrs={})
+      @account_id = attrs['account_id']
+      @display_name = attrs['name']['display_name']
+      @email = attrs['email']
+      @email_verified = attrs['email_verified']
+      @disabled = attrs['disabled']
+      @profile_photo_url = attrs['profile_photo_url']
+    end
+  end
+
+  class BasicAccount < Account
+    attr_reader :is_teammate, :team_member_id
+
+    def initialize(attrs={})
+      @is_teammate = attrs.delete('is_teammate')
+      @team_member_id = attrs.delete('team_member_id')
+      super(attrs)
+    end
+  end
+
+  class FullAccount < Account
+    attr_reader :locale, :referral_link, :is_paired, :profile_photo_url, :country
+
+    def initialize(attrs={})
+      @locale = attrs.delete('locale')
+      @referral_link = attrs.delete('referral_link')
+      @is_paired = attrs.delete('is_paired')
+      @profile_photo_url = attrs.delete('profile_photo_url')
+      @country = attrs.delete('country')
+      super(attrs)
+    end
+  end
+
+  class SpaceUsage
+    attr_reader :used, :allocation, :allocated
+
+    def initialize(attrs={})
+      @used = attrs['used'] # Space used in bytes
+      @allocation = attrs['allocation']['.tag'] # The type of allocation
+      @allocated = attrs['allocation']['allocated'] # Space allocated in bytes
+    end
+  end
+end

data/lib/dropbox/client.rb

@@ -0,0 +1,179 @@
+require 'http'
+require 'json'
+require 'time'
+
+module Dropbox
+  class Client
+    def initialize(access_token)
+      unless access_token =~ /^[a-z0-9_-]{64}$/i
+        raise ClientError.invalid_access_token
+      end
+
+      @access_token = access_token
+    end
+
+    def copy(from, to)
+      resp = request('/files/copy', from_path: from, to_path: to)
+      parse_tagged_response(resp)
+    end
+
+    def create_folder(path)
+      resp = request('/files/create_folder', path: path)
+      parse_tagged_response(resp, 'folder')
+    end
+
+    def delete(path)
+      resp = request('/files/delete', path: path)
+      parse_tagged_response(resp)
+    end
+
+    def download(path)
+      resp, body = content_request('/files/download', path: path)
+      return parse_tagged_response(resp, 'file'), body
+    end
+
+    def get_account(id)
+      resp = request('/users/get_account', account_id: id)
+      parse_tagged_response(resp, 'basic_account')
+    end
+
+    # Takes an array of account IDs and returns an array of BasicAccounts
+    def get_account_batch(ids)
+      resp = request('/users/get_account_batch', account_ids: ids)
+      resp.map { |a| parse_tagged_response(a, 'basic_account') }
+    end
+
+    def get_current_account
+      resp = request('/users/get_current_account')
+      parse_tagged_response(resp, 'full_account')
+    end
+
+    def get_metadata(path)
+      resp = request('/files/get_metadata', path: path)
+      parse_tagged_response(resp)
+    end
+
+    def get_preview(path)
+      resp, body = content_request('/files/get_preview', path: path)
+      return parse_tagged_response(resp, 'file'), body
+    end
+
+    def get_space_usage
+      resp = request('/users/get_space_usage')
+      SpaceUsage.new(resp)
+    end
+
+    def get_temporary_link(path)
+      resp = request('/files/get_temporary_link', path: path)
+      return parse_tagged_response(resp['metadata'], 'file'), resp['link']
+    end
+
+    def get_thumbnail(path, format='jpeg', size='w64h64')
+      resp, body = content_request('/files/get_thumbnail', path: path, format: format, size: size)
+      return parse_tagged_response(resp, 'file'), body
+    end
+
+    def list_folder(path)
+      resp = request('/files/list_folder', path: path)
+      resp['entries'].map { |e| parse_tagged_response(e) }
+    end
+
+    def list_revisions(path)
+      resp = request('/files/list_revisions', path: path)
+      entries = resp['entries'].map { |e| parse_tagged_response(e, 'file') }
+      return entries, resp['is_deleted']
+    end
+
+    def move(from, to)
+      resp = request('/files/move', from_path: from, to_path: to)
+      parse_tagged_response(resp)
+    end
+
+    def restore(path, rev)
+      resp = request('/files/restore', path: path, rev: rev)
+      parse_tagged_response(resp, 'file')
+    end
+
+    # Revokes the current access token and returns it
+    def revoke_token
+      r = HTTP.auth('Bearer ' + @access_token).post(API + '/auth/token/revoke')
+      raise APIError.new(r) if r.code != 200
+      @access_token
+    end
+
+    def save_url(path, url)
+      resp = request('/files/save_url', path: path, url: url)
+      case resp['.tag']
+      when 'complete'
+        parse_tagged_response(resp['complete'], 'file')
+      when 'async_job_id'
+        resp['async_job_id']
+      else
+        raise ClientError.unknown_response_type(resp['.tag'])
+      end
+    end
+
+    def search(query, path='', max=100)
+      resp = request('/files/search', path: path, query: query, max_results: max)
+      resp['matches'].map { |m| parse_tagged_response(m['metadata']) }
+    end
+
+    # Body can be a String or an Enumerable
+    # Mode can be 'add', 'overwrite', or 'update'
+    def upload(path, body, mode='add', autorename=false, client_modified=nil, mute=false)
+      client_modified = client_modified.iso8601 if client_modified.is_a?(Time)
+      resp = upload_request('/files/upload', body, path: path, mode: mode,
+        autorename: autorename, client_modified: client_modified, mute: mute)
+      parse_tagged_response(resp, 'file')
+    end
+
+    private
+      def parse_tagged_response(resp, tag=resp['.tag'])
+        case tag
+        when 'file'
+          FileMetadata.new(resp)
+        when 'folder'
+          FolderMetadata.new(resp)
+        when 'deleted'
+          DeletedMetadata.new(resp)
+        when 'basic_account'
+          BasicAccount.new(resp)
+        when 'full_account'
+          FullAccount.new(resp)
+        else
+          raise ClientError.unknown_response_type(tag)
+        end
+      end
+
+      def request(action, data=nil)
+        url = API + action
+        resp = HTTP.auth('Bearer ' + @access_token)
+          .headers(content_type: ('application/json' if data))
+          .post(url, json: data)
+
+        raise APIError.new(resp) if resp.code != 200
+        JSON.parse(resp.to_s)
+      end
+
+      def content_request(action, args={})
+        url = CONTENT_API + action
+        resp = HTTP.auth('Bearer ' + @access_token)
+          .headers('Dropbox-API-Arg' => args.to_json).get(url)
+
+        raise APIError.new(resp) if resp.code != 200
+        file = JSON.parse(resp.headers['Dropbox-API-Result'])
+        return file, resp.body
+      end
+
+      def upload_request(action, body, args={})
+        resp = HTTP.auth('Bearer ' + @access_token).headers({
+          'Content-Type' => 'application/octet-stream',
+          'Dropbox-API-Arg' => args.to_json,
+          'Transfer-Encoding' => ('chunked' unless body.is_a?(String))
+        }).post(CONTENT_API + action, body: body)
+
+        raise APIError.new(resp) if resp.code != 200
+        JSON.parse(resp.to_s)
+      end
+  end
+end

data/lib/dropbox/errors.rb

@@ -0,0 +1,39 @@
+require 'json'
+
+module Dropbox
+  class ClientError < StandardError
+    attr_reader :message
+
+    def self.invalid_access_token
+      self.new("Invalid access token")
+    end
+
+    def self.unknown_response_type(str)
+      self.new("Unknown response type '#{str}'")
+    end
+
+    def initialize(message=nil)
+      @message = message
+    end
+
+    def to_s
+      @message.to_s
+    end
+  end
+
+  class APIError < StandardError
+    attr_reader :message
+
+    def initialize(response)
+      if response.content_type.mime_type == 'application/json'
+        @message = JSON.parse(response)['error_summary']
+      else
+        @message = response
+      end
+    end
+
+    def to_s
+      @message.to_s
+    end
+  end
+end

data/lib/dropbox/metadata.rb

@@ -0,0 +1,40 @@
+require 'time'
+
+module Dropbox
+  class Metadata
+    attr_reader :name, :path_lower, :path_display
+
+    def initialize(attrs={})
+      @name = attrs['name']
+      @path_lower = attrs['path_lower']
+      @path_display = attrs['path_display']
+    end
+  end
+
+  class FileMetadata < Metadata
+    attr_reader :id, :client_modified, :server_modified, :rev, :size
+
+    def initialize(attrs={})
+      @id = attrs.delete('id')
+      if cm = attrs.delete('client_modified')
+        @client_modified = Time.parse(cm)
+      end
+      @server_modified = Time.parse(attrs.delete('server_modified'))
+      @rev = attrs.delete('rev')
+      @size = attrs.delete('size')
+      super(attrs)
+    end
+  end
+
+  class FolderMetadata < Metadata
+    attr_reader :id
+
+    def initialize(attrs={})
+      @id = attrs.delete('id')
+      super(attrs)
+    end
+  end
+
+  class DeletedMetadata < Metadata
+  end
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: dropbox-sdk-v2
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Dylan Waits
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-06-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.9'
+- !ruby/object:Gem::Dependency
+  name: http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: A Ruby library for the new Dropbox API.
+email: dylan@waits.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/dropbox.rb
+- lib/dropbox/account.rb
+- lib/dropbox/client.rb
+- lib/dropbox/errors.rb
+- lib/dropbox/metadata.rb
+homepage: https://github.com/waits/dropbox-sdk-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.3
+signing_key: 
+specification_version: 4
+summary: Dropbox SDK v2
+test_files: []
+has_rdoc: