dbox 0.5.3 → 0.6.0

data/vendor/dropbox-ruby-sdk/web_file_browser.rb

@@ -0,0 +1,184 @@
+# -------------------------------------------------------------------
+# An example webapp that lets you browse and upload files to Dropbox.
+# Demonstrates:
+# - The webapp OAuth process.
+# - The metadata() and put_file() calls.
+#
+# To run:
+# 1. Install Sinatra  $ gem install sinatra
+# 2. Launch server    $ ruby web_file_browser.rb
+# 3. Browse to        http://localhost:4567/
+# -------------------------------------------------------------------
+
+require 'rubygems'
+require 'sinatra'
+require 'pp'
+require './lib/dropbox_sdk'
+
+# Get your app's key and secret from https://www.dropbox.com/developers/
+APP_KEY = ''
+APP_SECRET = ''
+ACCESS_TYPE = :app_folder #The two valid values here are :app_folder and :dropbox
+                          #The default is :app_folder, but your application might be
+                          #set to have full :dropbox access.  Check your app at
+                          #https://www.dropbox.com/developers/apps
+
+# -------------------------------------------------------------------
+# OAuth stuff
+
+get '/oauth-start' do
+    # OAuth Step 1: Get a request token from Dropbox.
+    db_session = DropboxSession.new(APP_KEY, APP_SECRET)
+    begin
+        db_session.get_request_token
+    rescue DropboxError => e
+        return html_page "Exception in OAuth step 1", "<p>#{h e}</p>"
+    end
+
+    session[:request_db_session] = db_session.serialize
+
+    # OAuth Step 2: Send the user to the Dropbox website so they can authorize
+    # our app.  After the user authorizes our app, Dropbox will redirect them
+    # to our '/oauth-callback' endpoint.
+    auth_url = db_session.get_authorize_url url('/oauth-callback')
+    redirect auth_url 
+end
+
+get '/oauth-callback' do
+    # Finish OAuth Step 2
+    ser = session[:request_db_session]
+    unless ser
+        return html_page "Error in OAuth step 2", "<p>Couldn't find OAuth state in session.</p>"
+    end
+    db_session = DropboxSession.deserialize(ser)
+
+    # OAuth Step 3: Get an access token from Dropbox.
+    begin
+        db_session.get_access_token
+    rescue DropboxError => e
+        return html_page "Exception in OAuth step 3", "<p>#{h e}</p>"
+    end
+    session.delete(:request_db_session)
+    session[:authorized_db_session] = db_session.serialize
+    redirect url('/')
+    # In this simple example, we store the authorized DropboxSession in the web
+    # session hash.  A "real" webapp might store it somewhere more persistent.
+end
+
+# If we already have an authorized DropboxSession, returns a DropboxClient.
+def get_db_client
+    if session[:authorized_db_session]
+        db_session = DropboxSession.deserialize(session[:authorized_db_session])
+        begin
+            return DropboxClient.new(db_session, ACCESS_TYPE)
+        rescue DropboxAuthError => e
+            # The stored session didn't work.  Fall through and start OAuth.
+            session[:authorized_db_session].delete
+        end
+    end
+end
+
+# -------------------------------------------------------------------
+# File/folder display stuff
+
+get '/' do
+    # Get the DropboxClient object.  Redirect to OAuth flow if necessary.
+    db_client = get_db_client
+    unless db_client
+        redirect url("/oauth-start")
+    end
+
+    # Call DropboxClient.metadata
+    path = params[:path] || '/'
+    begin
+        entry = db_client.metadata(path)
+    rescue DropboxAuthError => e
+        session.delete(:authorized_db_session)  # An auth error means the db_session is probably bad
+        return html_page "Dropbox auth error", "<p>#{h e}</p>"
+    rescue DropboxError => e
+        if e.http_response.code == '404'
+            return html_page "Path not found: #{h path}", ""
+        else
+            return html_page "Dropbox API error", "<pre>#{h e.http_response}</pre>"
+        end
+    end
+
+    if entry['is_dir']
+        render_folder(db_client, entry)
+    else
+        render_file(db_client, entry)
+    end
+end
+
+def render_folder(db_client, entry)
+    # Provide an upload form (so the user can add files to this folder)
+    out = "<form action='/upload' method='post' enctype='multipart/form-data'>"
+    out += "<label for='file'>Upload file:</label> <input name='file' type='file'/>"
+    out += "<input type='submit' value='Upload'/>"
+    out += "<input name='folder' type='hidden' value='#{h entry['path']}'/>"
+    out += "</form>"  # TODO: Add a token to counter CSRF attacks.
+    # List of folder contents
+    entry['contents'].each do |child|
+        cp = child['path']      # child path
+        cn = File.basename(cp)  # child name
+        if (child['is_dir']) then cn += '/' end
+        out += "<div><a style='text-decoration: none' href='/?path=#{h cp}'>#{h cn}</a></div>"
+    end
+
+    html_page "Folder: #{entry['path']}", out
+end
+
+def render_file(db_client, entry)
+    # Just dump out metadata hash
+    html_page "File: #{entry['path']}", "<pre>#{h entry.pretty_inspect}</pre>"
+end
+
+# -------------------------------------------------------------------
+# File upload handler
+
+post '/upload' do
+    # Check POST parameter.
+    file = params[:file]
+    unless file && (temp_file = file[:tempfile]) && (name = file[:filename])
+        return html_page "Upload error", "<p>No file selected.</p>"
+    end
+
+    # Get the DropboxClient object.
+    db_client = get_db_client
+    unless db_client
+        return html_page "Upload error", "<p>Not linked with a Dropbox account.</p>"
+    end
+
+    # Call DropboxClient.put_file
+    begin
+        entry = db_client.put_file("#{params[:folder]}/#{name}", temp_file.read)
+    rescue DropboxAuthError => e
+        session.delete(:authorized_db_session)  # An auth error means the db_session is probably bad
+        return html_page "Dropbox auth error", "<p>#{h e}</p>"
+    rescue DropboxError => e
+        return html_page "Dropbox API error", "<p>#{h e}</p>"
+    end
+
+    html_page "Upload complete", "<pre>#{h entry.pretty_inspect}</pre>"
+end
+
+# -------------------------------------------------------------------
+
+def html_page(title, body)
+    "<html>" +
+        "<head><title>#{h title}</title></head>" +
+        "<body><h1>#{h title}</h1>#{body}</body>" +
+    "</html>"
+end
+
+enable :sessions
+
+helpers do
+    include Rack::Utils
+    alias_method :h, :escape_html
+end
+
+if APP_KEY == '' or APP_SECRET == ''
+    puts "You must set APP_KEY and APP_SECRET at the top of \"#{__FILE__}\"!"
+    exit 1
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: dbox
 version: !ruby/object:Gem::Version 
-  hash: 13
+  hash: 7
   prerelease: 
   segments: 
   - 0
-  - 5
-  - 3
-  version: 0.5.3
+  - 6
+  - 0
+  version: 0.6.0
 platform: ruby
 authors: 
 - Ken Pratt
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-11-04 00:00:00 Z
+date: 2011-11-24 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: multipart-post
@@ -108,6 +108,7 @@ extra_rdoc_files:
 - README.md
 files: 
 - .document
+- History.txt
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -117,23 +118,24 @@ files:
 - dbox.gemspec
 - lib/dbox.rb
 - lib/dbox/api.rb
+- lib/dbox/cacert.pem
 - lib/dbox/database.rb
 - lib/dbox/db.rb
 - lib/dbox/loggable.rb
 - lib/dbox/parallel_tasks.rb
 - lib/dbox/syncer.rb
+- lib/dbox/utils.rb
 - sample_polling_script.rb
 - spec/dbox_spec.rb
 - spec/spec_helper.rb
-- vendor/dropbox-client-ruby/LICENSE
-- vendor/dropbox-client-ruby/README
-- vendor/dropbox-client-ruby/Rakefile
-- vendor/dropbox-client-ruby/config/testing.json.example
-- vendor/dropbox-client-ruby/lib/dropbox.rb
-- vendor/dropbox-client-ruby/manifest
-- vendor/dropbox-client-ruby/test/authenticator_test.rb
-- vendor/dropbox-client-ruby/test/client_test.rb
-- vendor/dropbox-client-ruby/test/util.rb
+- vendor/dropbox-ruby-sdk/CHANGELOG
+- vendor/dropbox-ruby-sdk/LICENSE
+- vendor/dropbox-ruby-sdk/README
+- vendor/dropbox-ruby-sdk/cli_example.rb
+- vendor/dropbox-ruby-sdk/dropbox_controller.rb
+- vendor/dropbox-ruby-sdk/gemspec.rb
+- vendor/dropbox-ruby-sdk/lib/dropbox_sdk.rb
+- vendor/dropbox-ruby-sdk/web_file_browser.rb
 homepage: http://github.com/kenpratt/dbox
 licenses: 
 - MIT

data/vendor/dropbox-client-ruby/README

@@ -1,17 +0,0 @@
-Forked from Ruby client at https://www.dropbox.com/developers/releases
-
-Getting started with the Dropbox ruby library:
-1. Make sure you have rake and rubygems installed on your system.
-1b. Some of the gems below may need to be compiled locally, so make sure you
-    have any necessary source code around as well.
-    e.g. 'apt-get install ruby1.x-dev libxml2-dev libxslt1-dev' on ubuntu
-2. Install oauth from rubygems
-3. Install multipart-post from rubygems
-4. Install json from rubygems
-5. Install mechanize from rubygems
-6. Install shoulda from rubygems
-7. Copy config/testing.json.example to config/testing.json
-8. In config/testing.json enter your application's consumer key, secret key,
-   and your test user email and password.
-9. Run 'rake test_units' to make sure all the tests pass.
-10. Start developing your Dropbox API application!

data/vendor/dropbox-client-ruby/Rakefile

@@ -1,41 +0,0 @@
-require 'rake'
-require 'rake/testtask'
-require 'rake/gempackagetask'
-require 'rubygems'
-
-manifest = File.readlines('manifest').map! { |x| x.chomp! }
-
-spec = Gem::Specification.new do |s|
-  s.name = %q{dropbox}
-  s.version = '1.0'
-
-  s.authors = ["Dropbox, Inc."]
-  s.date = Time.now.utc.strftime('%Y-%m-%d')
-  s.description = "Dropbox REST API Client Library"
-  s.email = %q{support@dropbox.com}
-  s.executables = %w()
-  s.extensions = %w()
-
-  s.files = manifest
-  s.homepage = %q{http://developers.dropbox.com/}
-
-  summary = %q{Dropbox REST API Client Library}
-  s.require_paths = %w(lib)
-  s.summary = summary
-end
-
-task :default => [:test_units]
-
-desc "Run basic tests"
-Rake::TestTask.new("test_units") { |t|
-  t.pattern = 'test/*_test.rb'
-  t.verbose = true
-  t.warning = true
-}
-
-Rake::GemPackageTask.new(spec) do |pkg|
-    pkg.need_zip = true
-    pkg.need_tar = true
-end
-
-

data/vendor/dropbox-client-ruby/config/testing.json.example

@@ -1,16 +0,0 @@
-{
-"server": "api.dropbox.com",
-"content_server": "api-content.dropbox.com",
-"port": 80,
-"request_token_url": "http://api.dropbox.com/0/oauth/request_token",
-"access_token_url": "http://api.dropbox.com/0/oauth/access_token",
-"authorization_url": "http://www.dropbox.com/0/oauth/authorize",
-"consumer_key": "YOUR CONSUMER KEY",
-"consumer_secret": "YOUR CONSUMER SECRET",
-"verifier": "",
-"testing_user": "USER TO TEST WITH",
-"testing_password": "PASSWORD",
-"root": "dropbox"
-}
-
-

data/vendor/dropbox-client-ruby/lib/dropbox.rb

@@ -1,259 +0,0 @@
-require 'rubygems'
-require 'oauth'
-require 'json'
-require 'uri'
-require 'net/http/post/multipart'
-
-class Authenticator
-
-    def initialize(config, key=nil, secret=nil, is_request=false, server=nil)
-        @consumer_key = config['consumer_key']
-        @consumer_secret = config['consumer_secret']
-        @config = config
-        @oauth_conf = {
-            :site => "http://" + (server || config["server"]),
-            :scheme => :header,
-            :http_method => :post,
-            :request_token_url => config["request_token_url"],
-            :access_token_url => config["access_token_url"],
-            :authorize_url => config["authorization_url"],
-        }
-
-        @consumer = OAuth::Consumer.new @consumer_key, @consumer_secret, @oauth_conf
-
-        @access_token = nil
-        @request_token = nil
-
-        if key and secret
-          if is_request then
-            @request_token = OAuth::RequestToken.new(@consumer, key, secret)
-          else
-            @access_token = OAuth::AccessToken.new(@consumer, key, secret)
-          end            
-        end
-    end
-
-    attr_reader :config
-
-    def Authenticator.load_config(path)
-        open(path) do |f|
-            return JSON.parse(f.read())
-        end
-    end
-
-    def get_request_token(*args)
-        @request_token = @consumer.get_request_token(*args)
-        return @request_token.authorize_url
-    end
-
-    def get_access_token
-        if @access_token == nil
-            @access_token = @request_token.get_access_token
-        end
-
-        return @access_token
-    end
-
-    def authorized?
-      !!@access_token
-    end
-
-    def token
-        return (@access_token ||  @request_token).token
-    end
-
-    def secret
-        return (@access_token || @request_token).secret
-    end
-
-    def sign(request, request_options = {})
-        return @consumer.sign!(request, @access_token || @request_token, request_options)
-    end
-
-    def clone(host)
-        return Authenticator.new(@config, token(), secret(), !authorized?, host)
-    end
-end
-
-# maybe subclass or monkey patch trusted into the oauth stuff
-
-
-API_VERSION = 0
-
-
-class DropboxError < RuntimeError
-end
-
-class DropboxClient
-    attr_reader :token
-
-    def initialize(api_host, content_host, port, auth)
-        @api_host = api_host
-        @content_host = content_host
-        @port = port.to_i
-        @auth = auth
-        @token = auth.get_access_token
-    end
-
-    def initialize_copy(other)
-        @token = other.token.clone()
-        @token.consumer = @token.consumer.clone()
-        @token.consumer.http = nil
-    end
-
-    def parse_response(response, callback=nil)
-        if response.kind_of?(Net::HTTPServerError)
-            raise DropboxError.new("Invalid response #{response}\n#{response.body}")
-        elsif not response.kind_of?(Net::HTTPSuccess)
-            return response
-        end
-
-        if callback
-            return response.body
-        else
-            begin
-                return JSON.parse(response.body)
-            rescue JSON::ParserError
-                return response.body
-            end
-        end
-    end
-
-
-    def account_info(status_in_response=false, callback=nil)
-        response = @token.get build_url(@api_host, @port, "/account/info")
-        return parse_response(response, callback)
-    end
-
-    def put_file(root, to_path, name, file_obj)
-        path = "/files/#{root}#{to_path}"
-        oauth_params = {"file" => name}
-        auth = @auth.clone(@content_host)
-
-        url = URI.parse(build_url(@content_host, @port, path))
-
-        oauth_fake_req = Net::HTTP::Post.new(url.path)
-        oauth_fake_req.set_form_data({ "file" => name })
-        auth.sign(oauth_fake_req)
-
-        oauth_sig = oauth_fake_req.to_hash['authorization']
-
-        req = Net::HTTP::Post::Multipart.new(url.path, {
-            "file" => UploadIO.new(file_obj, "application/octet-stream", name),
-        })
-        req['authorization'] = oauth_sig.join(", ")
-
-        res = Net::HTTP.start(url.host, url.port) do |http|
-            return parse_response(http.request(req))
-        end
-    end
-
-    def get_file(root, from_path, destination_io=nil)
-        path = "/files/#{root}#{from_path}"
-
-        if destination_io
-            url = URI.parse(build_url(@content_host, @port, path))
-
-            # if a destination is given, stream the response into it
-            Net::HTTP.start(url.host, url.port) do |http|
-                # build the request
-                req = Net::HTTP::Get.new(url.path, {})
-                auth = @auth.clone(@content_host)
-                auth.sign(req)
-
-                # make the request
-                http.request(req) do |response|
-                    if response.kind_of?(Net::HTTPServerError)
-                        raise DropboxError.new("Invalid response #{response}\n#{response.body}")
-                    elsif not response.kind_of?(Net::HTTPSuccess)
-                        return response
-                    else
-                        # stream to given io
-                        response.read_body {|segment| destination_io << segment }
-                        return true
-                    end
-                end
-            end
-        else
-            response = @token.get(build_url(@content_host, @port, path))
-            return parse_response(response, true)
-        end
-    end
-
-    def file_copy(root, from_path, to_path, callback=nil)
-        params = {
-            "root" => root,
-            "from_path" => from_path, 
-            "to_path" => to_path,
-            "callback" => callback
-        }
-        response = @token.post(build_url(@api_host, @port, "/fileops/copy"), params)
-        return parse_response(response, callback)
-    end
-
-    def file_create_folder(root, path, callback=nil)
-        params = {
-            "root" => root, 
-            "path" => path, 
-            "callback" => callback
-        }
-        response = @token.post(build_url(@api_host, @port, "/fileops/create_folder"), params)
-
-        return parse_response(response, callback)
-    end
-
-    def file_delete(root, path, callback=nil)
-        params = {
-            "root" => root, 
-            "path" => path, 
-            "callback" => callback
-        }
-        response = @token.post(build_url(@api_host, @port, "/fileops/delete"), params)
-        return parse_response(response, callback)
-    end
-
-    def file_move(root, from_path, to_path, callback=nil)
-        params = {
-            "root" => root,
-            "from_path" => from_path, 
-            "to_path" => to_path,
-            "callback" => callback
-        }
-        response = @token.post(build_url(@api_host, @port, "/fileops/move"), params)
-        return parse_response(response, callback)
-    end
-
-    def metadata(root, path, file_limit=10000, hash=nil, list=true, status_in_response=false, callback=nil)
-        params = {
-            "file_limit" => file_limit.to_s,
-            "list" => list ? "true" : "false",
-            "status_in_response" => status_in_response ? "true" : "false"
-        }
-        params["hash"] = hash if hash
-        params["callback"] = callback if callback
-
-        response = @token.get build_url(@api_host, @port, "/metadata/#{root}#{path}", params=params)
-        return parse_response(response, callback)
-    end
-
-    def links(root, path)
-        full_path = "/links/#{root}#{path}"
-        return build_url(@api_host, @port, full_path)
-    end
-
-    def build_url(host, port, url, params=nil)
-        port = port == 80 ? nil : port
-        versioned_url = "/#{API_VERSION}#{url}"
-
-        target = URI::Generic.new("http", nil, host, port, nil, versioned_url, nil, nil, nil)
-
-        if params
-            target.query = params.collect {|k,v| URI.escape(k) + "=" + URI.escape(v) }.join("&")
-        end
-
-        return target.to_s
-    end
-
-
-end
-