dropbox-api-petems 0.4.1

data/lib/dropbox-api/objects/delta.rb

@@ -0,0 +1,11 @@
+module Dropbox
+  module API
+    class Delta
+      attr_reader :cursor, :entries
+      def initialize(cursor, entries)
+        @cursor  = cursor
+        @entries = entries
+      end
+    end
+  end
+end

data/lib/dropbox-api/objects/dir.rb

@@ -0,0 +1,20 @@
+module Dropbox
+  module API
+
+    class Dir < Dropbox::API::Object
+
+      include Dropbox::API::Fileops
+
+      def ls(path_to_list = '')
+        data = client.raw.metadata :path => path + path_to_list
+        if data['is_dir']
+          Dropbox::API::Object.convert(data.delete('contents') || [], client)
+        else
+          [Dropbox::API::Object.convert(data, client)]
+        end
+      end
+
+    end
+
+  end
+end

data/lib/dropbox-api/objects/file.rb

@@ -0,0 +1,44 @@
+module Dropbox
+  module API
+
+    class File < Dropbox::API::Object
+
+      include Dropbox::API::Fileops
+
+      def revisions(options = {})
+        response = client.raw.revisions({ :path => self.path }.merge(options))
+        Dropbox::API::Object.convert(response, client)
+      end
+
+      def restore(rev, options = {})
+        response = client.raw.restore({ :rev => rev, :path => self.path }.merge(options))
+        self.update response
+      end
+
+      def share_url(options = {})
+        response = client.raw.shares({ :path => self.path }.merge(options))
+        Dropbox::API::Object.init(response, client)
+      end
+
+      def direct_url(options = {})
+        response = client.raw.media({ :path => self.path }.merge(options))
+        Dropbox::API::Object.init(response, client)
+      end
+
+      def thumbnail(options = {})
+        client.raw.thumbnails({ :path => self.path }.merge(options))
+      end
+      
+      def copy_ref(options = {})
+        response = client.raw.copy_ref({ :path => self.path }.merge(options))
+        Dropbox::API::Object.init(response, client)
+      end
+      
+      def download
+        client.download(self.path)
+      end
+
+    end
+
+  end
+end

data/lib/dropbox-api/objects/fileops.rb

@@ -0,0 +1,28 @@
+module Dropbox
+  module API
+
+    module Fileops
+
+      def copy(to, options = {})
+        response = client.raw.copy({ :from_path => self.path, :to_path => to }.merge(options))
+        self.update response
+      end
+
+      def move(to, options = {})
+        response = client.raw.move({ :from_path => self.path, :to_path => to }.merge(options))
+        self.update response
+      end
+
+      def destroy(options = {})
+        response = client.raw.delete({ :path => self.path }.merge(options))
+        self.update response
+      end
+
+      def path
+        self['path'].sub(/^\//, '')
+      end
+
+    end
+
+  end
+end

data/lib/dropbox-api/objects/object.rb

@@ -0,0 +1,39 @@
+module Dropbox
+  module API
+
+    class Object < Hashie::Mash
+      attr_accessor :client
+
+      def self.init(response, client)
+        instance = self.new(response)
+        instance.client = client
+        instance
+      end
+
+      def self.resolve_class(hash)
+        hash['is_dir'] == true ? Dropbox::API::Dir : Dropbox::API::File
+      end
+
+      def self.convert(array_or_object, client)
+        if array_or_object.is_a?(Array)
+          array_or_object.collect do |item|
+            resolve_class(item).init(item, client)
+          end
+        else
+          resolve_class(array_or_object).init(array_or_object, client)
+        end
+      end
+
+      # Kill off the ability for recursive conversion
+      def deep_update(other_hash)
+        other_hash.each_pair do |k,v|
+          key = convert_key(k)
+          regular_writer(key, convert_value(v, true))
+        end
+        self
+      end
+
+    end
+
+  end
+end

data/lib/dropbox-api/tasks.rb

@@ -0,0 +1,48 @@
+module Dropbox
+  module API
+
+    class Tasks
+
+      extend Rake::DSL if defined? Rake::DSL
+
+      def self.install
+
+        namespace :dropbox do
+          desc "Authorize wizard for Dropbox API"
+          task :authorize do
+            require "dropbox-api"
+            require "cgi"
+            print "Enter consumer key: "
+            consumer_key = $stdin.gets.chomp
+            print "Enter consumer secret: "
+            consumer_secret = $stdin.gets.chomp
+
+            Dropbox::API::Config.app_key    = consumer_key
+            Dropbox::API::Config.app_secret = consumer_secret
+
+            consumer = Dropbox::API::OAuth.consumer(:authorize)
+            request_token = consumer.get_request_token
+            puts "\nGo to this url and click 'Authorize' to get the token:"
+            puts request_token.authorize_url
+            query  = request_token.authorize_url.split('?').last
+            params = CGI.parse(query)
+            token  = params['oauth_token'].first
+            print "\nOnce you authorize the app on Dropbox, press enter... "
+            $stdin.gets.chomp
+
+            access_token  = request_token.get_access_token(:oauth_verifier => token)
+
+            puts "\nAuthorization complete!:\n\n"
+            puts "  Dropbox::API::Config.app_key    = '#{consumer.key}'"
+            puts "  Dropbox::API::Config.app_secret = '#{consumer.secret}'"
+            puts "  client = Dropbox::API::Client.new(:token  => '#{access_token.token}', :secret => '#{access_token.secret}')"
+            puts "\n"
+          end
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/dropbox-api/util/config.rb

@@ -0,0 +1,27 @@
+module Dropbox
+  module API
+
+    module Config
+
+      class << self
+        attr_accessor :endpoints
+        attr_accessor :prefix
+        attr_accessor :app_key
+        attr_accessor :app_secret
+        attr_accessor :mode
+      end
+
+      self.endpoints = {
+        :main      => "https://api.dropbox.com",
+        :content   => "https://api-content.dropbox.com",
+        :authorize => "https://www.dropbox.com"
+      }
+      self.prefix     = "/1"
+      self.app_key    = nil
+      self.app_secret = nil
+      self.mode       = 'sandbox'
+
+    end
+
+  end
+end

data/lib/dropbox-api/util/error.rb

@@ -0,0 +1,20 @@
+module Dropbox
+  module API
+
+    class Error < StandardError
+
+      class BadInput < Error; end
+      class ConnectionFailed < Error; end
+      class Config < Error; end
+      class Unauthorized < Error; end
+      class Forbidden < Error; end
+      class NotFound < Error; end
+      class Redirect < Error; end
+      class WrongMethod < Error; end
+      class RateLimit < Error; end
+      class StorageQuota < Error; end
+
+    end
+
+  end
+end

data/lib/dropbox-api/util/oauth.rb

@@ -0,0 +1,29 @@
+module Dropbox
+  module API
+
+    module OAuth
+
+      class << self
+
+        def consumer(endpoint)
+          if !Dropbox::API::Config.app_key or !Dropbox::API::Config.app_secret
+            raise Dropbox::API::Error::Config.new("app_key or app_secret not provided")
+          end
+          ::OAuth::Consumer.new(Dropbox::API::Config.app_key, Dropbox::API::Config.app_secret,
+            :site => Dropbox::API::Config.endpoints[endpoint],
+            :request_token_path => Dropbox::API::Config.prefix + "/oauth/request_token",
+            :authorize_path     => Dropbox::API::Config.prefix + "/oauth/authorize",
+            :access_token_path  => Dropbox::API::Config.prefix + "/oauth/access_token")
+        end
+
+        def access_token(consumer, options = {})
+          ::OAuth::AccessToken.new(consumer, options[:token], options[:secret])
+        end
+
+      end
+
+    end
+
+  end
+end
+

data/lib/dropbox-api/util/util.rb

@@ -0,0 +1,27 @@
+module Dropbox
+  module API
+
+    module Util
+
+      class << self
+
+        def escape(string)
+          string.gsub(/([^ a-zA-Z0-9\.\\\-\/\_]+)/) do
+            '%' + $1.unpack('H2' * $1.bytesize).join('%').upcase
+          end.gsub(' ', '%20')
+        end
+
+        def query(data)
+          data.inject([]) { |memo, entry| memo.push(entry.join('=')); memo }.join('&')
+        end
+
+        def remove_double_slashes(path)
+          path.gsub('//', '/')
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/dropbox-api/version.rb

@@ -0,0 +1,5 @@
+module Dropbox
+  module API
+    VERSION = "0.4.1"
+  end
+end

data/lib/dropbox-api.rb

@@ -0,0 +1,22 @@
+require "oauth"
+require "multi_json"
+require "hashie"
+
+module Dropbox
+  module API
+
+  end
+end
+
+require "dropbox-api/version"
+require "dropbox-api/util/config"
+require "dropbox-api/util/oauth"
+require "dropbox-api/util/error"
+require "dropbox-api/util/util"
+require "dropbox-api/objects/object"
+require "dropbox-api/objects/fileops"
+require "dropbox-api/objects/file"
+require "dropbox-api/objects/dir"
+require "dropbox-api/objects/delta"
+require "dropbox-api/connection"
+require "dropbox-api/client"

data/spec/connection.sample.yml

@@ -0,0 +1,5 @@
+app_key:    # CONSUMER KEY
+app_secret: # CONSUMER SECRET
+token:      # ACCESS TOKEN
+secret:     # ACCESS SECRET
+mode:       # 'sandbox' or 'dropbox'

data/spec/lib/dropbox-api/client_spec.rb

@@ -0,0 +1,201 @@
+# encoding: utf-8
+require "spec_helper"
+
+describe Dropbox::API::Client do
+
+  before do
+    # pending
+    @client = Dropbox::Spec.instance
+  end
+
+  describe "#initialize" do
+
+    it "has a handle to the connection" do
+      @client.connection.should be_an_instance_of(Dropbox::API::Connection)
+    end
+
+  end
+
+  describe "#account" do
+
+    it "retrieves the account object" do
+      response = @client.account
+      response.should be_an_instance_of(Dropbox::API::Object)
+    end
+
+  end
+
+  describe "#find" do
+
+    before do
+      @filename = "#{Dropbox::Spec.test_dir}/spec-find-file-test-#{Time.now.to_i}.txt"
+      @file = @client.upload @filename, "spec file"
+
+      @dirname = "#{Dropbox::Spec.test_dir}/spec-find-dir-test-#{Time.now.to_i}"
+      @dir = @client.mkdir @dirname
+    end
+
+    it "returns a single file" do
+      response = @client.find(@filename)
+      response.path.should == @file.path
+      response.should be_an_instance_of(Dropbox::API::File)
+    end
+
+    it "returns a single directory" do
+      response = @client.find(@dirname)
+      response.path.should == @dir.path
+      response.should be_an_instance_of(Dropbox::API::Dir)
+    end
+
+  end
+
+  describe "#ls" do
+
+    it "returns an array of files and dirs" do
+      result = @client.ls
+      result.should be_an_instance_of(Array)
+    end
+
+    it "returns a single item array of if we ls a file" do
+      result     = @client.ls(Dropbox::Spec.test_dir)
+      first_file = result.detect { |f| f.class == Dropbox::API::File }
+      result     = @client.ls first_file.path
+      result.should be_an_instance_of(Array)
+    end
+
+  end
+
+  describe "#mkdir" do
+
+    it "returns an array of files and dirs" do
+      dirname  = "#{Dropbox::Spec.test_dir}/test-dir-#{Dropbox::Spec.namespace}"
+      response = @client.mkdir dirname
+      response.path.should == dirname
+      response.should be_an_instance_of(Dropbox::API::Dir)
+    end
+
+    it "creates dirs with tricky characters" do
+      dirname  = "#{Dropbox::Spec.test_dir}/test-dir |!@\#$%^&*{b}[].;'.,<>?: #{Dropbox::Spec.namespace}"
+      response = @client.mkdir dirname
+      response.path.should == dirname.gsub(/[\\\:\?\*\<\>\"\|]+/, '')
+      response.should be_an_instance_of(Dropbox::API::Dir)
+    end
+
+    it "creates dirs with utf8 characters" do
+      dirname  = "#{Dropbox::Spec.test_dir}/test-dir łółą #{Dropbox::Spec.namespace}"
+      response = @client.mkdir dirname
+      response.path.should == dirname
+      response.should be_an_instance_of(Dropbox::API::Dir)
+    end
+
+  end
+
+  describe "#upload" do
+
+    it "puts the file in dropbox" do
+      filename = "#{Dropbox::Spec.test_dir}/test-#{Dropbox::Spec.namespace}.txt"
+      response = @client.upload filename, "Some file"
+      response.path.should == filename
+      response.bytes.should == 9
+    end
+
+    it "uploads the file with tricky characters" do
+      filename = "#{Dropbox::Spec.test_dir}/test ,|!@\#$%^&*{b}[].;'.,<>?:-#{Dropbox::Spec.namespace}.txt"
+      response = @client.upload filename, "Some file"
+      response.path.should == filename
+      response.bytes.should == 9
+    end
+
+    it "uploads the file with utf8" do
+      filename = "#{Dropbox::Spec.test_dir}/test łołąó-#{Dropbox::Spec.namespace}.txt"
+      response = @client.upload filename, "Some file"
+      response.path.should == filename
+      response.bytes.should == 9
+    end
+  end
+
+  describe "#search" do
+
+    let(:term) { "searchable-test-#{Dropbox::Spec.namespace}" }
+
+    before do
+      filename = "#{Dropbox::Spec.test_dir}/searchable-test-#{Dropbox::Spec.namespace}.txt"
+      @client.upload filename, "Some file"
+    end
+
+    after do
+      @response.size.should == 1
+      @response.first.class.should == Dropbox::API::File
+    end
+
+    it "finds a file" do
+      @response = @client.search term, :path => "#{Dropbox::Spec.test_dir}"
+    end
+
+    it "works if leading slash is present in path" do
+      @response = @client.search term, :path => "/#{Dropbox::Spec.test_dir}"
+    end
+
+  end
+
+  describe "#copy_from_copy_ref" do
+
+    it "copies a file from a copy_ref" do
+      filename = "test/searchable-test-#{Dropbox::Spec.namespace}.txt"
+      @client.upload filename, "Some file"
+      response = @client.search "searchable-test-#{Dropbox::Spec.namespace}", :path => 'test'      
+      ref = response.first.copy_ref['copy_ref']
+      @client.copy_from_copy_ref ref, "#{filename}.copied"
+      response = @client.search "searchable-test-#{Dropbox::Spec.namespace}.txt.copied", :path => 'test'   
+      response.size.should == 1
+      response.first.class.should == Dropbox::API::File
+    end
+
+  end
+
+  describe "#download" do
+
+    it "downloads a file from Dropbox" do
+      @client.upload "#{Dropbox::Spec.test_dir}/test.txt", "Some file"
+      file = @client.download "#{Dropbox::Spec.test_dir}/test.txt"
+      file.should == "Some file"
+    end
+
+    it "raises a 404 when a file is not found in Dropbox" do
+      lambda {
+        @client.download "#{Dropbox::Spec.test_dir}/no.txt"
+      }.should raise_error(Dropbox::API::Error::NotFound)
+    end
+
+  end
+
+  describe "#delta" do
+    it "returns a cursor and list of files" do
+      filename = "#{Dropbox::Spec.test_dir}/delta-test-#{Dropbox::Spec.namespace}.txt"
+      @client.upload filename, 'Some file'
+      response = @client.delta
+      cursor, files = response.cursor, response.entries
+      cursor.should be_an_instance_of(String)
+      files.should be_an_instance_of(Array)
+      files.last.should be_an_instance_of(Dropbox::API::File)
+    end
+
+    it "returns the files that have changed since the cursor was made" do
+      filename = "#{Dropbox::Spec.test_dir}/delta-test-#{Dropbox::Spec.namespace}.txt"
+      delete_filename = "#{Dropbox::Spec.test_dir}/delta-test-delete-#{Dropbox::Spec.namespace}.txt"
+      @client.upload delete_filename, 'Some file'
+      response = @client.delta
+      cursor, files = response.cursor, response.entries
+      files.last.path.should == delete_filename
+      files.last.destroy
+      @client.upload filename, 'Another file'
+      response = @client.delta(cursor)
+      cursor, files = response.cursor, response.entries
+      files.length.should == 2
+      files.first.is_deleted.should == true
+      files.first.path.should == delete_filename
+      files.last.path.should == filename
+    end
+  end
+
+end

data/spec/lib/dropbox-api/connection_spec.rb

@@ -0,0 +1,129 @@
+require "spec_helper"
+
+describe Dropbox::API::Connection do
+
+  before do
+    @connection = Dropbox::API::Connection.new(:token  => Dropbox::Spec.token,
+                                               :secret => Dropbox::Spec.secret)
+  end
+
+  describe "#request" do
+
+    it "returns a parsed response when the response is a 200" do
+      response = double :code => 200, :body => '{ "a":1}'
+      response = @connection.request { response }
+      response.should be_an_instance_of(Hash)
+    end
+
+    it "raises a Dropbox::API::Error::Unauthorized when the response is a 401" do
+      response = double :code => 401, :body => '{ "a":1}'
+      lambda do
+        @connection.request { response }
+      end.should raise_error(Dropbox::API::Error::Unauthorized, '401 - Bad or expired token')
+    end
+
+    it "raises a Dropbox::API::Error::Forbidden when the response is a 403" do
+      response = double :code => 403, :body => '{ "a":1}'
+      lambda do
+        @connection.request { response }
+      end.should raise_error(Dropbox::API::Error::Forbidden, '403 - Bad OAuth request')
+    end
+
+    it "raises a Dropbox::API::Error::NotFound when the response is a 404" do
+      response = double :code => 404, :body => '{ "a":1}'
+      lambda do
+        @connection.request { response }
+      end.should raise_error(Dropbox::API::Error::NotFound, '404 - Not found')
+    end
+
+    it "raises a Dropbox::API::Error::WrongMethod when the response is a 405" do
+      response = double :code => 405, :body => '{ "error": "The requested method GET is not allowed for the URL /foo/." }'
+      lambda do
+        @connection.request { response }
+      end.should raise_error(Dropbox::API::Error::WrongMethod, '405 - Request method not expected - The requested method GET is not allowed for the URL /foo/.')
+    end
+
+    it "raises a Dropbox::API::Error when the response is a 3xx" do
+      response = double :code => 301, :body => '{ "a":1}'
+      lambda do
+        @connection.request { response }
+      end.should raise_error(Dropbox::API::Error::Redirect, '301 - Redirect Error')
+    end
+
+    it "raises a Dropbox::API::Error when the response is a 5xx" do
+      response = double :code => 500, :body => '{ "a":1}'
+      lambda do
+        @connection.request { response }
+      end.should raise_error(Dropbox::API::Error, '500 - Server error. Check http://status.dropbox.com/')
+    end
+
+    it "raises a Dropbox::API::Error when the response is a 400" do
+      response = double :code => 400, :body => '{ "error": "bad request foo" }'
+      lambda do
+        @connection.request { response }
+      end.should raise_error(Dropbox::API::Error::BadInput, '400 - Bad input parameter - bad request foo')
+    end
+
+    it "raises a Dropbox::API::Error when the response is a 406" do
+      response = double :code => 406, :body => '{ "error": "bad request bar" }'
+      lambda do
+        @connection.request { response }
+      end.should raise_error(Dropbox::API::Error, '406 - bad request bar')
+    end
+
+    it "raises a Dropbox::API::Error when the response is a 406" do
+      response = double :code => 429, :body => '{ "error": "rate limited" }'
+      lambda do
+        @connection.request { response }
+      end.should raise_error(Dropbox::API::Error::RateLimit, '429 - Rate Limiting in affect')
+    end
+
+    it "raises a Dropbox::API::Error when the response is a 503" do
+      response = double :code => 503, :body => '{ "error": "rate limited" }'
+      lambda do
+        @connection.request { response }
+      end.should raise_error(Dropbox::API::Error, '503 - Possible Rate Limiting: rate limited')
+    end
+
+    it "raises a Dropbox::API::Error::StorageQuota when the response is a 507" do
+      response = double :code => 507, :body => '{ "error": "quote limit" }'
+      lambda do
+        @connection.request { response }
+      end.should raise_error(Dropbox::API::Error, '507 - Dropbox storage quota exceeded.')
+    end
+
+
+    it "returns the raw response if :raw => true is provided" do
+      response = double :code => 200, :body => '{ "something": "more" }'
+      response = @connection.request(:raw => true) { response }
+      response.should == '{ "something": "more" }'
+    end
+
+  end
+
+  describe "#consumer" do
+
+    it "returns an appropriate consumer object" do
+      @connection.consumer(:main).should be_a(::OAuth::Consumer)
+    end
+
+  end
+
+  describe "errors" do
+
+    it "recovers error with rescue statement modifier" do
+      expect { raise Dropbox::API::Error rescue nil }.to_not raise_error
+    end
+
+    it "recovers any kind of errors with the generic error" do
+      expect do
+        begin
+          raise Dropbox::API::Error::Forbidden
+        rescue Dropbox::API::Error
+        end
+      end.to_not raise_error
+    end
+
+  end
+
+end