dbox 0.1.0

data/test/helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'dbox'
+
+class Test::Unit::TestCase
+end

data/test/test_dbox.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestDbox < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

data/vendor/dropbox-client-ruby/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Dropbox (Evenflow, Inc.), http://getdropbox.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/vendor/dropbox-client-ruby/README

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,16 @@
+{
+"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

@@ -0,0 +1,226 @@
+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
+
+    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 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)
+        path = "/files/#{root}#{from_path}"
+        response = @token.get(build_url(@content_host, @port, path))
+        return parse_response(response, callback=true)
+    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
+

data/vendor/dropbox-client-ruby/manifest

@@ -0,0 +1,9 @@
+F LICENSE eee4b82f8ec32762095d12613d633f24ac242ebe
+F README da39a3ee5e6b4b0d3255bfef95601890afd80709
+F Rakefile 30ac5c2002b9bccb9064e956fefa88f687e6d719
+F config/testing.json.example 4f833212f80566278dfe78c216f05f16db92ce4d
+F example/test_pingback.rb 082e0b515333e3c495e1b3cbce179a4e7c69bd6b
+F lib/dropbox.rb d7d8960fb725f046b83f17fe54f64f603fbb2cf6
+F test/authenticator_test.rb b476e8fbbaa73cf6d1db227c549e43860e85f60b
+F test/client_test.rb aa34080cc5dcb369d39f0fa4c602be89100a535b
+F test/util.rb 0d49786886f9aee3b2f60ba1f56e7f861b3480b4

data/vendor/dropbox-client-ruby/test/authenticator_test.rb

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'lib/dropbox'
+require 'test/unit'
+require 'shoulda'
+require './test/util'
+
+CONF = Authenticator.load_config("config/testing.json")
+
+class AuthenticatorTest < Test::Unit::TestCase
+  context "Authenticator" do
+    should "load json config" do
+        assert CONF
+        auth = Authenticator.new(CONF)
+    end
+
+    should "get request token" do
+        auth = Authenticator.new(CONF)
+        authorize_url = auth.get_request_token
+        assert authorize_url
+    end
+
+    should "get access token" do
+        auth = Authenticator.new(CONF)
+        authorize_url = auth.get_request_token
+        assert authorize_url
+
+        login_and_authorize(authorize_url, CONF)
+
+        access_token = auth.get_access_token
+        assert access_token
+
+        assert access_token.token
+        assert access_token.secret
+
+        CONF['access_token_key'] = access_token.token
+        CONF['access_token_secret'] = access_token.secret
+
+        response = access_token.get "http://" + CONF['server'] + "/0/oauth/echo"
+        assert response
+        assert response.code == "200"
+    end
+
+    should "reuse an existing token" do
+        auth = Authenticator.new(CONF, CONF['access_token_key'], CONF['access_token_secret'])
+        access_token = auth.get_access_token
+
+        response = access_token.get "http://" + CONF['server'] + "/0/oauth/echo"
+        assert response
+        assert response.code == "200"
+    end
+  end
+end
+

data/vendor/dropbox-client-ruby/test/client_test.rb

@@ -0,0 +1,100 @@
+require 'rubygems'
+require 'lib/dropbox'
+require 'test/unit'
+require 'shoulda'
+require './test/util'
+require 'pp'
+
+CONF = Authenticator.load_config("config/testing.json") unless defined?(CONF)
+AUTH = Authenticator.new(CONF) unless defined?(AUTH)
+login_and_authorize(AUTH.get_request_token, CONF)
+ACCESS_TOKEN = AUTH.get_access_token
+
+
+class DropboxClientTest < Test::Unit::TestCase
+
+    context "DropboxClient" do
+        setup do
+            assert ACCESS_TOKEN
+            assert AUTH
+            assert CONF
+
+            begin
+                client = DropboxClient.new(CONF['server'], CONF['content_server'], CONF['port'], AUTH)
+                client.file_delete(CONF['root'], "/tests")
+            rescue
+                # ignored
+            end
+        end
+
+        should "be able to access account info" do
+            client = DropboxClient.new(CONF['server'], CONF['content_server'], CONF['port'], AUTH)
+            info = client.account_info
+            assert info
+            assert info["country"]
+            assert info["uid"]
+        end
+
+        should "build full urls" do
+            client = DropboxClient.new(CONF['server'], CONF['content_server'], CONF['port'], AUTH)
+            url = client.build_url(CONF['server'], CONF['port'], "/account/info")
+            assert_equal url, "http://" + CONF['server'] + "/0/account/info"
+
+            url = client.build_url(CONF['server'], CONF['port'], "/account/info")
+            assert_equal url, "http://" + CONF['server'] + "/0/account/info"
+
+            url = client.build_url(CONF['server'], CONF['port'], "/account/info", params={"one" => "1", "two" => "2"})
+            assert_equal url, "http://" + CONF['server'] + "/0/account/info?two=2&one=1"
+
+            url = client.build_url(CONF['server'], CONF['port'], "/account/info", params={"one" => "1", "two" => "2"})
+            assert_equal url, "http://" + CONF['server'] + "/0/account/info?two=2&one=1"
+        end
+
+
+        should "create links" do
+            client = DropboxClient.new(CONF['server'], CONF['content_server'] ,CONF['port'], AUTH)
+            assert_equal "http://" + CONF['server'] + "/0/links/" + CONF['root'] + "/to/the/file", client.links(CONF['root'], "/to/the/file")
+        end
+
+        should "get metadata" do
+            client = DropboxClient.new(CONF['server'], CONF['content_server'] ,CONF['port'], AUTH)
+            results = client.metadata(CONF['root'], "/")
+            assert results
+            assert results["hash"]
+        end
+
+        should "be able to perform file ops on folders" do
+            client = DropboxClient.new(CONF['server'], CONF['content_server'], CONF['port'], AUTH)
+            results = client.file_create_folder(CONF['root'], "/tests/that")
+            assert results
+            assert results["bytes"]
+
+            assert client.file_copy(CONF['root'], "/tests/that", "/tests/those")
+            assert client.metadata(CONF['root'], "/tests/those")
+            assert client.file_delete(CONF['root'], "/tests/those")
+
+            results = client.file_move(CONF['root'], "/tests/that", "/tests/those")
+            assert results
+
+            assert client.metadata(CONF['root'], "/tests/those")
+            assert client.file_delete(CONF['root'], "/tests/those")
+
+        end
+       
+        should "be able to get files" do
+            client = DropboxClient.new(CONF['server'], CONF['content_server'], CONF['port'], AUTH)
+            results = client.get_file(CONF['root'], "/client_tests.py")
+            assert results
+        end
+
+        should "be able to put files" do
+            client = DropboxClient.new(CONF['server'], CONF['content_server'], CONF['port'], AUTH)
+            results = client.put_file(CONF['root'], "/", "LICENSE", open("LICENSE"))
+            assert results
+            assert client.file_delete(CONF['root'], "/LICENSE")
+        end
+
+    end
+
+end
+