dropbox-api-kilgore5 0.3.3

data/lib/dropbox-api/client.rb

@@ -0,0 +1,73 @@
+require "dropbox-api/client/raw"
+require "dropbox-api/client/files"
+
+module Dropbox
+  module API
+
+    class Client
+
+      attr_accessor :raw, :connection
+
+      def initialize(options = {})
+        @connection = Dropbox::API::Connection.new(:token  => options.delete(:token),
+                                                   :secret => options.delete(:secret))
+        @raw        = Dropbox::API::Raw.new :connection => @connection
+        @options    = options
+      end
+
+      include Dropbox::API::Client::Files
+
+      def find(filename)
+        data = self.raw.metadata(:path => filename)
+        data.delete('contents')
+        Dropbox::API::Object.convert(data, self)
+      end
+
+      def ls(path = '')
+        Dropbox::API::Dir.init({'path' => path}, self).ls
+      end
+      
+      def folder_changed?(path = '', hash = '')
+        meta_response = Dropbox::API::Dir.init({'path' => path}, self).folder_meta(path,hash)
+        return (meta_response.kind_of? Dropbox::API::Response::NotModified) ? false : meta_response
+      end
+        
+      def account
+        Dropbox::API::Object.init(self.raw.account, self)
+      end
+
+      def mkdir(path)
+        # Remove the characters not allowed by Dropbox
+        path = path.gsub(/[\\\:\?\*\<\>\"\|]+/, '')
+        response = raw.create_folder :path => path
+        Dropbox::API::Dir.init(response, self)
+      end
+
+      def search(term, options = {})
+        options[:path] ||= ''
+        results = raw.search({ :query => term }.merge(options))
+        Dropbox::API::Object.convert(results, self)
+      end
+      
+      def delta(cursor=nil)
+        entries  = []
+        has_more = true
+        params   = cursor ? {:cursor => cursor} : {}
+        while has_more
+          response        = raw.delta(params)
+          params[:cursor] = response['cursor']
+          has_more        = response['has_more']
+          entries.push     *response['entries']
+        end
+
+        files = entries.map do |entry|
+          entry.last || {:is_deleted => true, :path => entry.first}
+        end
+
+        Delta.new(params[:cursor], Dropbox::API::Object.convert(files, self))
+      end
+
+    end
+
+  end
+end

data/lib/dropbox-api/client/files.rb

@@ -0,0 +1,40 @@
+module Dropbox
+  module API
+
+    class Client
+
+      module Files
+
+        def download(path, options = {})
+          root     = options.delete(:root) || Dropbox::API::Config.mode
+          path     = Dropbox::API::Util.escape(path)
+          url      = ['', "files", root, path].compact.join('/')
+          connection.get_raw(:content, url)
+        end
+
+        def upload(path, data, options = {})
+          root     = options.delete(:root) || Dropbox::API::Config.mode
+          query    = Dropbox::API::Util.query(options)
+          path     = Dropbox::API::Util.escape(path)
+          url      = ['', "files_put", root, path].compact.join('/')
+          response = connection.put(:content, "#{url}?#{query}", data, {
+            'Content-Type'   => "application/octet-stream",
+            "Content-Length" => data.length.to_s
+          })
+          Dropbox::API::File.init(response, self)
+        end
+
+        def copy_from_copy_ref(copy_ref, to, options = {})
+          raw.copy({ 
+            :from_copy_ref => copy_ref, 
+            :to_path => to 
+          }.merge(options))
+        end
+
+      end
+
+    end
+
+  end
+end
+

data/lib/dropbox-api/client/raw.rb

@@ -0,0 +1,51 @@
+module Dropbox
+  module API
+
+    class Raw
+
+      attr_accessor :connection
+
+      def initialize(options = {})
+        @connection = options[:connection]
+      end
+
+      def self.add_method(method, action, options = {})
+        # Add the default root bit, but allow it to be disabled by a config option
+        root = options[:root] == false ? '' : "options[:root] ||= Dropbox::API::Config.mode"
+        self.class_eval <<-STR
+          def #{options[:as] || action}(options = {})
+            #{root}
+            request(:#{options[:endpoint] || 'main'}, :#{method}, "#{action}", options)
+          end
+        STR
+      end
+
+      def request(endpoint, method, action, data = {})
+        action.sub! ':root', Dropbox::API::Util.escape(data.delete(:root).to_s) if action.match ':root'
+        action.sub! ':path', Dropbox::API::Util.escape(data.delete(:path).to_s) if action.match ':path'
+        action = Dropbox::API::Util.remove_double_slashes(action)
+        connection.send(method, endpoint, action, data)
+      end
+
+      add_method :get,  "/account/info",           :as => 'account', :root => false
+
+      add_method :get,  "/metadata/:root/:path",   :as => 'metadata'
+      add_method :post, "/delta",                  :as => 'delta', :root => false
+      add_method :get,  "/revisions/:root/:path",  :as => 'revisions'
+      add_method :post, "/restore/:root/:path",    :as => 'restore'
+      add_method :get,  "/search/:root/:path",     :as => 'search'
+      add_method :post, "/shares/:root/:path",     :as => 'shares'
+      add_method :post, "/media/:root/:path",      :as => 'media'
+
+      add_method :get_raw, "/thumbnails/:root/:path", :as => 'thumbnails', :endpoint => :content
+
+      add_method :post, "/fileops/copy",           :as => "copy"
+      add_method :get,  "/copy_ref/:root/:path",   :as => 'copy_ref'
+      add_method :post, "/fileops/create_folder",  :as => "create_folder"
+      add_method :post, "/fileops/delete",         :as => "delete"
+      add_method :post, "/fileops/move",           :as => "move"
+
+    end
+
+  end
+end

data/lib/dropbox-api/connection.rb

@@ -0,0 +1,34 @@
+require "dropbox-api/connection/requests"
+
+module Dropbox
+  module API
+
+    class Connection
+
+      include Dropbox::API::Connection::Requests
+
+      attr_accessor :consumers
+      attr_accessor :tokens
+
+      def initialize(options = {})
+        @options   = options
+        @consumers = {}
+        @tokens    = {}
+        Dropbox::API::Config.endpoints.each do |endpoint, url|
+          @consumers[endpoint] = Dropbox::API::OAuth.consumer(endpoint)
+          @tokens[endpoint]    = Dropbox::API::OAuth.access_token(@consumers[endpoint], options)
+        end
+      end
+
+      def consumer(endpoint = :main)
+        @consumers[endpoint]
+      end
+
+      def token(endpoint = :main)
+        @tokens[endpoint]
+      end
+
+    end
+
+  end
+end

data/lib/dropbox-api/connection/requests.rb

@@ -0,0 +1,67 @@
+module Dropbox
+  module API
+
+    class Connection
+
+      module Requests
+
+        def request(options = {})
+          response = yield
+          raise Dropbox::API::Error::ConnectionFailed if !response
+          status = response.code.to_i
+          case status
+            when 401
+              raise Dropbox::API::Error::Unauthorized
+            when 403
+              parsed = MultiJson.decode(response.body)
+              raise Dropbox::API::Error::Forbidden.new(parsed["error"])
+            when 404
+              raise Dropbox::API::Error::NotFound
+            when 400, 406
+              parsed = MultiJson.decode(response.body)
+              raise Dropbox::API::Error.new(parsed["error"])
+            when 300..399
+              raise Dropbox::API::Error::Redirect
+            when 500..599
+              raise Dropbox::API::Error
+            else
+              options[:raw] ? response.body : MultiJson.decode(response.body)
+          end
+        rescue Dropbox::API::Error::Redirect
+          return Dropbox::API::Response::NotModified.new             
+        end
+
+
+
+        def get_raw(endpoint, path, data = {}, headers = {})
+          query = Dropbox::API::Util.query(data)
+          request(:raw => true) do
+            token(endpoint).get "#{Dropbox::API::Config.prefix}#{path}?#{URI.parse(URI.encode(query))}", headers
+          end
+        end
+
+        def get(endpoint, path, data = {}, headers = {})
+          query = Dropbox::API::Util.query(data)
+          request do
+            token(endpoint).get "#{Dropbox::API::Config.prefix}#{path}?#{URI.parse(URI.encode(query))}", headers
+          end
+        end
+
+        def post(endpoint, path, data = {}, headers = {})
+          request do
+            token(endpoint).post "#{Dropbox::API::Config.prefix}#{path}", data, headers
+          end
+        end
+
+        def put(endpoint, path, data = {}, headers = {})
+          request do
+            token(endpoint).put "#{Dropbox::API::Config.prefix}#{path}", data, headers
+          end
+        end
+
+      end
+
+    end
+
+  end
+end

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,30 @@
+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
+      
+      def folder_meta(path,hash = '')
+        data = client.raw.metadata :path => path, :hash => hash
+        
+        if data.kind_of? Dropbox::API::Error::NotModified
+          return Dropbox::API::Error::NotModified
+        else
+          return data  
+        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