kloudless 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: aadd0e43b6426a49c8172bbc0e5f5dcae993744c
-  data.tar.gz: 69dde9fd66257fa64f3a05e87ab8fa7c88596695
+  metadata.gz: 87e04e539ed7a1b806e462f1e156ad3fa60241d4
+  data.tar.gz: 5d2b394818e6db3824ef1287b39bcad1284081ef
 SHA512:
-  metadata.gz: 4c61c7453b87e8e0b8e333d91ecfb8dd1783433a183882764ec13287f9c5e409f30cb06cbcdae9836ff10cf3da786ccf5a00ffc8fdc7ce50cb738b31a9f76b96
-  data.tar.gz: c487c4ce1952757c2c84e332c3d6294b6a17f84b51df1b343fba952b329a4b68dc0add13763c45783c097d1200e8ec0beb907b57a6ffcc7b429a044a40cb87a7
+  metadata.gz: 66a884a58eb3ccb6722facf07cb3096b4379c02e857c79693193dc0faf5d80783aa7b950e545316bed6e80d317ce518e68988fb6e9cd016f7567a0a82b6903b8
+  data.tar.gz: 3d42f44a173284b6204333bf1a47dc060d33c8b53d8da17aeb8a96fc5725e6a88bb30e79bf0ddf466ab0f143b079d13055d1fd51e9de6caa55283e9227b98151

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+# upcoming
+
+# 0.2.0
+
+- Query parameters for POST/PUT/PATCH requests.
+- Bearer Tokens instead of Account Keys.
+- Better/fixed file upload and download methods.
+- Fixed gemspec warnings
+- Fixed gemspec homepage. @tyrust
+
+# 0.1.0
+
+Initial release

data/Rakefile

@@ -8,3 +8,7 @@ Rake::TestTask.new do |t|
 end
 
 task :default => :test
+
+task :console do
+  exec "irb -r byebug -r kloudless -I ./lib"
+end

data/kloudless.gemspec

@@ -8,8 +8,9 @@ Gem::Specification.new do |spec|
   spec.version       = Kloudless::VERSION
   spec.authors       = ["Jerry Cheung"]
   spec.email         = ["jollyjerry@gmail.com"]
-  spec.summary       = %q{Kloudless API client}
-  spec.homepage      = "https://github.com/jch/kloudless"
+  spec.summary       = %q{Ruby Kloudless API client. The last cloud storage API you’ll ever need.}
+  spec.description   = %q{Ruby Kloudless API client}
+  spec.homepage      = "https://github.com/jch/kloudless-ruby"
   spec.license       = "MIT"
   spec.required_ruby_version = ">= 2.1"
 
@@ -19,7 +20,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler", "~> 1.6"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "byebug"
-  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "rake", "~> 10"
+  spec.add_development_dependency "byebug", "~> 3"
+  spec.add_development_dependency "minitest", "~> 5"
 end

data/lib/kloudless.rb

@@ -3,7 +3,6 @@ require_relative "kloudless/error"
 require_relative "kloudless/http"
 require_relative "kloudless/model"
 require_relative "kloudless/account"
-require_relative "kloudless/account_key"
 require_relative "kloudless/team"
 require_relative "kloudless/file"
 require_relative "kloudless/multipart_upload"
@@ -18,20 +17,20 @@ module Kloudless
   API_VERSION = "v0".freeze
   API_URL = "https://api.kloudless.com/#{API_VERSION}".freeze
 
-  # Public: Authorize with API Key or Account Key. Returns nothing.
+  # Public: Authorize with API Key or Bearer Token. Returns nothing.
   #
   # Options:
   #  :api_key
-  #  :account_key
+  #  :token
   #
   # https://developers.kloudless.com/docs#authorization
   def self.authorize(options = {})
     Kloudless::HTTP.headers["Authorization"] = if options[:api_key]
       "ApiKey #{options[:api_key]}"
-    elsif options[:account_key]
-      "AccountKey #{options[:account_key]}"
+    elsif options[:token]
+      "Bearer #{options[:token]}"
     else
-      raise ArgumentError.new(":api_key or :account_key required")
+      raise ArgumentError.new(":api_key or :token required")
     end
   end
 

data/lib/kloudless/account.rb

@@ -5,7 +5,7 @@ module Kloudless
   # https://developers.kloudless.com/docs#accounts
   class Account < Model
     # Public: Returns Kloudless::Collection. Raises Kloudless::Error.
-    def self.list(params = {})
+    def self.list(**params)
       Kloudless::Collection.new(self, http.get("/accounts", params: params))
     end
 
@@ -13,8 +13,8 @@ module Kloudless
       new(http.get("/accounts/#{account_id}", params: params))
     end
 
-    def self.update(account_id:, **params)
-      new(http.patch("/accounts/#{account_id}", params: params))
+    def self.update(account_id:, params: {}, **data)
+      new(http.patch("/accounts/#{account_id}", params: params, data: data))
     end
 
     def self.delete(account_id:)
@@ -22,8 +22,8 @@ module Kloudless
     end
 
     # Public: TODO: Returns ???. Raises Kloudless::Error.
-    def self.import(params = {})
-      http.post("/accounts", params: params)
+    def self.import(params: {}, **data)
+      http.post("/accounts", params: params, data: data)
     end
 
     class << self

data/lib/kloudless/error.rb

@@ -153,8 +153,6 @@ module Kloudless
       forbidden: ForbiddenError,
       service_forbidden: ServiceForbiddenError,
       not_found: NotFoundError,
-      method_not_allowed: MethodNotAllowedError,
-      not_acceptable: NotAcceptableError,
       naming_conflict: NamingConflictError,
       too_many_requests: TooManyRequestsError,
       too_many_service_requests: TooManyServiceRequestsError,
@@ -167,6 +165,7 @@ module Kloudless
       bad_gateway: BadGatewayError,
       service_not_available: ServiceNotAvailableError,
       gateway_timeout: GatewayTimeoutError,
-      insufficient_storage: InsufficientStorageError    }
+      insufficient_storage: InsufficientStorageError
+    }
   end
 end

data/lib/kloudless/file.rb

@@ -1,35 +1,48 @@
+require 'json'
+
 module Kloudless
   # https://developers.kloudless.com/docs#files
   class File < Model
-    def self.upload(account_id:, **params)
+    def self.upload(account_id:, data:, parent_id:, file_name:, **params)
+      headers = {
+        'X-Kloudless-Metadata' => {parent_id: parent_id, name: file_name}.to_json,
+        'Content-Type' => 'application/octet-stream'
+      }
       path = "/accounts/#{account_id}/files"
-      new(http.post(path, params: params))
+      new(http.post(path, params: params, data: data, headers: headers,
+                    parse_request: false))
     end
 
-    def self.metadata(account_id:, file_id:)
+    def self.upload_from_url(account_id:, params: {}, **data)
+      path = "/accounts/#{account_id}/files"
+      new(http.post(path, params: params, data: data))
+    end
+
+    def self.metadata(account_id:, file_id:, **params)
       path = "/accounts/#{account_id}/files/#{file_id}"
-      new(http.get(path))
+      new(http.get(path, params: params))
     end
 
-    def self.rename(account_id:, file_id:, **params)
+    def self.rename(account_id:, file_id:, params: {}, **data)
       path = "/accounts/#{account_id}/files/#{file_id}"
-      new(http.patch(path, params: params))
+      new(http.patch(path, params: params, data: data))
     end
 
-    # TODO: unclear how to post binary data over net-http
-    def self.update
-      raise NotImplementedError
+    def self.update(account_id:, file_id:, data:)
+      path = "/accounts/#{account_id}/files/#{file_id}"
+      new(http.put(path, data: data, parse_request: false,
+                   headers: {'Content-Type' => 'application/octet-stream'}))
     end
 
-    def self.download(account_id:, file_id:)
+    def self.download(account_id:, file_id:, **params)
       path = "/accounts/#{account_id}/files/#{file_id}/contents"
-      http.get_raw(path)
+      http.get(path, params: params, parse_response: false)
     end
 
-    def self.copy(account_id:, file_id:, parent_id:, **params)
+    def self.copy(account_id:, file_id:, parent_id:, params: {}, **data)
       path = "/accounts/#{account_id}/files/#{file_id}/copy"
-      params[:parent_id] = parent_id
-      new(http.post(path, params: params))
+      data[:parent_id] = parent_id
+      new(http.post(path, params: params, data: data))
     end
 
     def self.delete(account_id:, file_id:, **params)

data/lib/kloudless/folder.rb

@@ -2,15 +2,15 @@ module Kloudless
   # https://developers.kloudless.com/docs#folders
   class Folder < Model
     # https://developers.kloudless.com/docs#folders-create-a-folder
-    def self.create(account_id:, **params)
+    def self.create(account_id:, params: {}, **data)
       path = "/accounts/#{account_id}/folders"
-      new(http.post(path, params: params))
+      new(http.post(path, params: params, data: data))
     end
 
     # https://developers.kloudless.com/docs#folders-retrieve-folder-metadata
-    def self.metadata(account_id:, folder_id:)
+    def self.metadata(account_id:, folder_id:, **params)
       path = "/accounts/#{account_id}/folders/#{folder_id}"
-      new(http.get(path))
+      new(http.get(path, params: params))
     end
 
     # https://developers.kloudless.com/docs#folders-retrieve-folder-contents
@@ -20,16 +20,16 @@ module Kloudless
     end
 
     # https://developers.kloudless.com/docs#folders-rename/move-a-folder
-    def self.rename(account_id:, folder_id:, **params)
+    def self.rename(account_id:, folder_id:, params: {}, **data)
       path = "/accounts/#{account_id}/folders/#{folder_id}"
-      new(http.patch(path, params: params))
+      new(http.patch(path, params: params, data: data))
     end
 
     # https://developers.kloudless.com/docs#folders-copy-a-folder
-    def self.copy(account_id:, folder_id:, parent_id:, **params)
-      params[:parent_id] = parent_id
+    def self.copy(account_id:, folder_id:, parent_id:, params: {}, **data)
       path = "/accounts/#{account_id}/folders/#{folder_id}/copy"
-      new(http.post(path, params: params))
+      data[:parent_id] = parent_id
+      new(http.post(path, params: params, data: data))
     end
 
     # https://developers.kloudless.com/docs#folders-delete-a-folder

data/lib/kloudless/http.rb

@@ -1,4 +1,5 @@
 require "net/http"
+require "json"
 
 module Kloudless
   # Net::HTTP wrapper
@@ -8,60 +9,50 @@ module Kloudless
       @headers ||= {}
     end
 
-    def self.get(path, params: {}, headers: {})
+    def self.request(method, path, params: {}, data: {}, headers: {},
+                     parse_request: true, parse_response: true)
       uri = URI.parse(Kloudless::API_URL + path)
       uri.query = URI.encode_www_form(params) if !params.empty?
 
-      request = Net::HTTP::Get.new(uri)
-      request.initialize_http_header(headers)
-
-      execute(request)
-    end
+      if ['post', 'put', 'patch'].member?(method)
+        headers["Content-Type"] ||= "application/json"
+      end
 
-    # TODO: decouple Kloudless::HTTP methods from #execute. Have methods return
-    # request object, defaults to json parsing, but allow the option for raw
-    def self.get_raw(path)
-      uri = URI.parse(Kloudless::API_URL + path)
-      request = Net::HTTP::Get.new(uri)
+      request = Net::HTTP.const_get(method.capitalize).new(uri)
       request.initialize_http_header(headers)
 
-      execute(request, parse_json: false)
-    end
-
-
-    def self.post(path, params: {}, headers: {})
-      uri = URI.parse(Kloudless::API_URL + path)
-      headers["Content-Type"] = "application/json"
-
-      request = Net::HTTP::Post.new(uri)
-      request.initialize_http_header(headers)
-      request.set_form_data(params) if !params.empty?
+      if !data.empty?
+        data = data.to_json if parse_request
+        request.body = data
+      end
 
-      execute(request)
+      execute(request, parse_response: parse_response)
     end
 
-    def self.patch(path, params: {}, headers: {})
-      uri = URI.parse(Kloudless::API_URL + path)
-      headers["Content-Type"] = "application/json"
-
-      request = Net::HTTP::Post.new(uri)
-      request.initialize_http_header(headers)
-      request.set_form_data(params) if !params.empty?
+    def self.get(path, **kwargs)
+      self.request('get', path, **kwargs)
+    end
 
-      execute(request)
+    def self.post(path, params: {}, data: {}, headers: {}, **kwargs)
+      self.request('post', path, params: params, data: data,
+                   headers: headers, **kwargs)
     end
 
-    def self.delete(path, params: {}, headers: {})
-      uri = URI.parse(Kloudless::API_URL + path)
-      uri.query = URI.encode_www_form(params) if !params.empty?
+    def self.put(path, params: {}, data: {}, headers: {}, **kwargs)
+      self.request('put', path, params: params, data: data,
+                   headers: headers, **kwargs)
+    end
 
-      request = Net::HTTP::Delete.new(uri)
-      request.initialize_http_header(headers)
+    def self.patch(path, params: {}, data: {}, headers: {}, **kwargs)
+      self.request('patch', path, params: params, data: data,
+                   headers: headers, **kwargs)
+    end
 
-      execute(request)
+    def self.delete(path, params: {}, headers: {}, **kwargs)
+      self.request('delete', path, params: params, headers: headers, **kwargs)
     end
 
-    def self.execute(request, parse_json: true)
+    def self.execute(request, parse_response: true)
       uri = request.uri
       @last_request = request
       headers.each {|k,v| request[k] = v}
@@ -70,12 +61,12 @@ module Kloudless
         http.request(request)
       }
 
-      if parse_json
+      if parse_response
         json = JSON.parse(response.body)
         raise Kloudless::Error.from_json(json) if json["error_code"]
         json
       else
-        response
+        response.body
       end
     end
 

data/lib/kloudless/link.rb

@@ -7,10 +7,10 @@ module Kloudless
     end
 
     # https://developers.kloudless.com/docs#links-create-a-link
-    def self.create(account_id:, file_id:, **params)
-      params[:file_id] = file_id
+    def self.create(account_id:, file_id:, params: {}, **data)
+      data[:file_id] = file_id
       path = "/accounts/#{account_id}/links"
-      new(http.post(path, params: params))
+      new(http.post(path, params: params, data: data))
     end
 
     # https://developers.kloudless.com/docs#links-retrieve-a-link
@@ -20,15 +20,15 @@ module Kloudless
     end
 
     # https://developers.kloudless.com/docs#links-update-a-link
-    def self.update(account_id:, link_id:, **params)
+    def self.update(account_id:, link_id:, params: {}, **data)
       path = "/accounts/#{account_id}/links/#{link_id}"
-      new(http.patch(path, params: params))
+      new(http.patch(path, params: params, data: data))
     end
 
     # https://developers.kloudless.com/docs#links-delete-a-link
-    def self.delete(account_id:, link_id:)
+    def self.delete(account_id:, link_id:, **params)
       path = "/accounts/#{account_id}/links/#{link_id}"
-      new(http.delete(path))
+      new(http.delete(path, params: params))
     end
   end
 end

data/lib/kloudless/multipart_upload.rb

@@ -1,9 +1,9 @@
 module Kloudless
   # https://developers.kloudless.com/docs#multipart-upload
   class MultipartUpload < Model
-    def self.init(account_id:, **params)
+    def self.init(account_id:, params: {}, **data)
       path = "/accounts/#{account_id}/multipart"
-      new(http.post(path, params: params))
+      new(http.post(path, params: params, data: data))
     end
 
     def self.retrieve(account_id:, multipart_id:)
@@ -12,25 +12,28 @@ module Kloudless
     end
 
     # https://developers.kloudless.com/docs#multipart-upload-upload-part
-    def self.upload(account_id:, multipart_id:, part_number:, **params)
+    def self.upload(account_id:, multipart_id:, data:, part_number:, **params)
       path = "/accounts/#{account_id}/multipart/#{multipart_id}"
       params[:part_number] = part_number
-      new(http.put(path, params: params))
+      headers = {'Content-Type' => 'application/octet-stream'}
+      new(http.put(path, params: params, data: data, headers: headers,
+                   parse_request: false))
     end
 
     # https://developers.kloudless.com/docs#multipart-upload-finalize-multipart-session
-    def self.finalize(account_id:, multipart_id:)
+    def self.finalize(account_id:, multipart_id:, params: {}, **data)
       path = "/accounts/#{account_id}/multipart/#{multipart_id}/complete"
-      new(http.post(path))
+      new(http.post(path, params: params, data: data))
     end
 
     # https://developers.kloudless.com/docs#multipart-upload-abort-multipart-session
-    def self.abort(account_id:, multipart_id:)
+    def self.abort(account_id:, multipart_id:, **params)
       path = "/accounts/#{account_id}/multipart/#{multipart_id}"
-      new(http.delete(path))
+      new(http.delete(path, params: params))
     end
 
     class << self
+      alias_method :create, :init
       alias_method :delete, :abort
     end
   end

data/lib/kloudless/version.rb

@@ -1,3 +1,3 @@
 module Kloudless
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/test/kloudless/account_test.rb

@@ -50,8 +50,8 @@ class Kloudless::AccountTest < Minitest::Test
       token: "foo",
       token_secret: "bar"
     }
-    Kloudless.http.expect(:post, args: ["/accounts", {params: attributes}]) do
-      Kloudless::Account.import(attributes)
+    Kloudless.http.expect(:post, args: ["/accounts", {params: {}, data: attributes}]) do
+      Kloudless::Account.import(**attributes)
     end
   end
 
@@ -63,7 +63,7 @@ class Kloudless::AccountTest < Minitest::Test
   end
 
   def test_update_account
-    Kloudless.http.expect(:patch, args: ["/accounts/1", {params: {active: true}}]) do
+    Kloudless.http.expect(:patch, args: ["/accounts/1", {params: {}, data: {active: true}}]) do
       account = Kloudless::Account.update(account_id: 1, active: true)
       assert_kind_of Kloudless::Account, account
     end

data/test/kloudless/file_test.rb

@@ -2,35 +2,51 @@ require_relative "../test_helper"
 
 class Kloudless::FileTest < Minitest::Test
   def test_upload_file
-    Kloudless.http.expect(:post, returns: {"id" => "foo"}, args: ["/accounts/1/files", params: {}]) do
-      file = Kloudless::File.upload(account_id: 1)
+    metadata = {parent_id: "parent", name: "foo.txt"}
+    Kloudless.http.expect(:post, returns: {"id" => "foo"}, args: [
+                            "/accounts/1/files", data: "FILE CONTENTS",
+                            headers: {'X-Kloudless-Metadata' => metadata.to_json,
+                                      "Content-Type" => 'application/octet-stream'},
+                            params: {}, parse_request: false]) do
+      file = Kloudless::File.upload(account_id: 1, data: "FILE CONTENTS",
+                                    parent_id: metadata[:parent_id],
+                                    file_name: metadata[:name])
       assert_kind_of Kloudless::File, file
     end
   end
 
   def test_retrieve_file_metadata
-    Kloudless.http.expect(:get, returns: {"id" => "foo"}, args:["/accounts/1/files/2"]) do
+    Kloudless.http.expect(:get, returns: {"id" => "foo"}, args:["/accounts/1/files/2", params: {}]) do
       metadata = Kloudless::File.metadata(account_id: 1, file_id: 2)
       assert_kind_of Kloudless::File, metadata  # TODO: not really a type
     end
   end
 
   def test_rename_file
-    Kloudless.http.expect(:patch, returns: {"id" => "foo"}, args:["/accounts/1/files/2", params: {name: "new-name.txt"}]) do
+    Kloudless.http.expect(:patch, returns: {"id" => "foo"}, args:["/accounts/1/files/2", params: {}, data: {name: "new-name.txt"}]) do
       file = Kloudless::File.rename(account_id: 1, file_id: 2, name: "new-name.txt")
       assert_kind_of Kloudless::File, file
     end
   end
 
+  def test_update
+    Kloudless.http.expect(:put, returns: {"id" => "foo"}, args: [
+                            "/accounts/1/files/2", data: "FILE CONTENTS", parse_request: false,
+                            headers: {'Content-Type' => 'application/octet-stream'}]) do
+      file = Kloudless::File.update(account_id: 1, file_id: 2, data: "FILE CONTENTS")
+      assert_kind_of Kloudless::File, file
+    end
+  end
+  
   def test_download
-    Kloudless.http.expect(:get_raw, returns: "FILE CONTENTS", args:["/accounts/1/files/2/contents"]) do
+    Kloudless.http.expect(:get, returns: "FILE CONTENTS", args:["/accounts/1/files/2/contents", params: {}, parse_response: false]) do
       contents = Kloudless::File.download(account_id: 1, file_id: 2)
       assert_equal "FILE CONTENTS", contents
     end
   end
 
   def test_copy
-    Kloudless.http.expect(:post, returns: {"id" => "foo"}, args:["/accounts/1/files/2/copy", params: {parent_id: "parent-id"}]) do
+    Kloudless.http.expect(:post, returns: {"id" => "foo"}, args:["/accounts/1/files/2/copy", params: {}, data: {parent_id: "parent-id"}]) do
       file = Kloudless::File.copy(account_id: 1, file_id: 2, parent_id: "parent-id")
       assert_kind_of Kloudless::File, file
     end

data/test/kloudless/folder_test.rb

@@ -2,14 +2,14 @@ require_relative "../test_helper"
 
 class Kloudless::FolderTest < Minitest::Test
   def test_create
-    Kloudless.http.expect(:post, args: ["/accounts/1/folders", params: {}]) do
-      folder = Kloudless::Folder.create(account_id: 1)
+    Kloudless.http.expect(:post, args: ["/accounts/1/folders", params: {}, data: {name: "foo"}]) do
+      folder = Kloudless::Folder.create(account_id: 1, name: "foo")
       assert_kind_of Kloudless::Folder, folder
     end
   end
 
   def test_metadata
-    Kloudless.http.expect(:get, args: ["/accounts/1/folders/2"]) do
+    Kloudless.http.expect(:get, args: ["/accounts/1/folders/2", params: {}]) do
       folder = Kloudless::Folder.metadata(account_id: 1, folder_id: 2)
       assert_kind_of Kloudless::Folder, folder
     end
@@ -25,14 +25,14 @@ class Kloudless::FolderTest < Minitest::Test
   end
 
   def test_rename
-    Kloudless.http.expect(:patch, args: ["/accounts/1/folders/2", params: {name: "foo.md"}]) do
+    Kloudless.http.expect(:patch, args: ["/accounts/1/folders/2", params: {}, data: {name: "foo.md"}]) do
       folder = Kloudless::Folder.rename(account_id: 1, folder_id: 2, name: "foo.md")
       assert_kind_of Kloudless::Folder, folder
     end
   end
 
   def test_copy
-    Kloudless.http.expect(:post, args: ["/accounts/1/folders/2/copy", params: {parent_id: "parent-id"}]) do
+    Kloudless.http.expect(:post, args: ["/accounts/1/folders/2/copy", params: {}, data: {parent_id: "parent-id"}]) do
       folder = Kloudless::Folder.copy(account_id: 1, folder_id: 2, parent_id: "parent-id")
       assert_kind_of Kloudless::Folder, folder
     end

data/test/kloudless/link_test.rb

@@ -11,7 +11,7 @@ class Kloudless::LinkTest < Minitest::Test
   end
 
   def test_create_link
-    Kloudless.http.expect(:post, args: ["/accounts/1/links", params: {file_id: "file-id"}]) do
+    Kloudless.http.expect(:post, args: ["/accounts/1/links", params: {}, data: {file_id: "file-id"}]) do
       link = Kloudless::Link.create(account_id: 1, file_id: "file-id")
       assert_kind_of Kloudless::Link, link
     end
@@ -25,14 +25,14 @@ class Kloudless::LinkTest < Minitest::Test
   end
 
   def test_update_link
-    Kloudless.http.expect(:patch, args: ["/accounts/1/links/2", params: {password: "foo"}]) do
+    Kloudless.http.expect(:patch, args: ["/accounts/1/links/2", params: {}, data: {password: "foo"}]) do
       link = Kloudless::Link.update(account_id: 1, link_id: 2, password: "foo")
       assert_kind_of Kloudless::Link, link
     end
   end
 
   def test_delete_link
-    Kloudless.http.expect(:delete, args: ["/accounts/1/links/2"]) do
+    Kloudless.http.expect(:delete, args: ["/accounts/1/links/2", params: {}]) do
       link = Kloudless::Link.delete(account_id: 1, link_id: 2)
       assert_kind_of Kloudless::Link, link
     end

data/test/kloudless/multipart_upload_test.rb

@@ -2,8 +2,9 @@ require_relative "../test_helper"
 
 class Kloudless::MultipartUploadTest < Minitest::Test
   def test_init_multipart_upload
-    Kloudless.http.expect(:post, returns: {"id" => "foo"}, args:["/accounts/1/multipart", params: {overwrite: true}]) do
-      upload = Kloudless::MultipartUpload.init(account_id: 1, overwrite: true)
+    Kloudless.http.expect(:post, returns: {"id" => "foo"}, args:[
+                            "/accounts/1/multipart", params: {overwrite: true}, data: {parent_id: "foo"}]) do
+      upload = Kloudless::MultipartUpload.create(account_id: 1, params: {overwrite: true}, parent_id: "foo")
       assert_kind_of Kloudless::MultipartUpload, upload
     end
   end
@@ -16,21 +17,25 @@ class Kloudless::MultipartUploadTest < Minitest::Test
   end
 
   def test_upload_multipart_upload
-    Kloudless.http.expect(:put, args: ["/accounts/1/multipart/2", params: {part_number: 1}]) do
-      upload = Kloudless::MultipartUpload.upload(account_id: 1, multipart_id: 2, part_number: 1)
+    Kloudless.http.expect(:put, args: ["/accounts/1/multipart/2", data: "FILE CONTENTS",
+                                       headers: {'Content-Type' => 'application/octet-stream'},
+                                       params: {part_number: 1},
+                                       parse_request: false]) do
+      upload = Kloudless::MultipartUpload.upload(account_id: 1, multipart_id: 2,
+                                                 data: "FILE CONTENTS", part_number: 1)
       assert_kind_of Kloudless::MultipartUpload, upload
     end
   end
 
   def test_finalize_multipart_upload
-    Kloudless.http.expect(:post, args: ["/accounts/1/multipart/2/complete"]) do
+    Kloudless.http.expect(:post, args: ["/accounts/1/multipart/2/complete", params: {}, data: {}]) do
       upload = Kloudless::MultipartUpload.finalize(account_id: 1, multipart_id: 2)
       assert_kind_of Kloudless::MultipartUpload, upload
     end
   end
 
   def test_abort_multipart_upload
-    Kloudless.http.expect(:delete, args: ["/accounts/1/multipart/2"]) do
+    Kloudless.http.expect(:delete, args: ["/accounts/1/multipart/2", params: {}]) do
       upload = Kloudless::MultipartUpload.abort(account_id: 1, multipart_id: 2)
       assert_kind_of Kloudless::MultipartUpload, upload
     end

data/test/kloudless_test.rb

@@ -15,11 +15,11 @@ class KloudlessTest < Minitest::Test
     end
   end
 
-  def test_authorize_account_key
-    Kloudless.authorize(account_key: "ACCOUNT_KEY")
+  def test_authorize_bearer_token
+    Kloudless.authorize(token: "BEARER_TOKEN")
     Kloudless.http.mock_response(Struct.new(:body).new('{}')) do
       Kloudless::Account.list
-      assert_equal "AccountKey ACCOUNT_KEY", Kloudless::HTTP.last_request["Authorization"]
+      assert_equal "Bearer BEARER_TOKEN", Kloudless::HTTP.last_request["Authorization"]
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kloudless
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Jerry Cheung
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-13 00:00:00.000000000 Z
+date: 2016-04-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -28,45 +28,45 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '10'
 - !ruby/object:Gem::Dependency
   name: byebug
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-description: 
+        version: '5'
+description: Ruby Kloudless API client
 email:
 - jollyjerry@gmail.com
 executables: []
@@ -74,6 +74,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -82,7 +83,6 @@ files:
 - kloudless.gemspec
 - lib/kloudless.rb
 - lib/kloudless/account.rb
-- lib/kloudless/account_key.rb
 - lib/kloudless/collection.rb
 - lib/kloudless/error.rb
 - lib/kloudless/event.rb
@@ -97,7 +97,6 @@ files:
 - script/changelog
 - script/package
 - script/release
-- test/kloudless/account_key_test.rb
 - test/kloudless/account_test.rb
 - test/kloudless/collection_test.rb
 - test/kloudless/error_test.rb
@@ -110,7 +109,7 @@ files:
 - test/kloudless/team_test.rb
 - test/kloudless_test.rb
 - test/test_helper.rb
-homepage: https://github.com/jch/kloudless
+homepage: https://github.com/jch/kloudless-ruby
 licenses:
 - MIT
 metadata: {}
@@ -130,12 +129,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
-summary: Kloudless API client
+summary: Ruby Kloudless API client. The last cloud storage API you’ll ever need.
 test_files:
-- test/kloudless/account_key_test.rb
 - test/kloudless/account_test.rb
 - test/kloudless/collection_test.rb
 - test/kloudless/error_test.rb

data/lib/kloudless/account_key.rb

@@ -1,26 +0,0 @@
-module Kloudless
-  # Account Keys can be used instead of API Keys to restrict access to a
-  # specific account’s data. This is most useful for client-side requests.
-  #
-  # https://developers.kloudless.com/docs#account-keys
-  class AccountKey < Model
-    # Public: Returns Kloudless::Collection of AccountKey. Raises
-    # Kloudless::Error.
-    #
-    #  :account_ids - Array of account_ids to fetch keys for
-    def self.list(account_ids:, **params)
-      path = "/accounts/#{account_ids.join(',')}/keys"
-      Kloudless::Collection.new(self, http.get(path, params: params))
-    end
-
-    def self.retrieve(account_id:, key_id:, **params)
-      path = "/accounts/#{account_id}/keys/#{key_id}"
-      new(http.get(path, params: params))
-    end
-
-    def self.delete(account_id:, key_id:)
-      path = "/accounts/#{account_id}/keys/#{key_id}"
-      new(http.delete(path))
-    end
-  end
-end

data/test/kloudless/account_key_test.rb

@@ -1,26 +0,0 @@
-require_relative "../test_helper"
-require 'minitest'
-
-class Kloudless::AccountKeyTest < Minitest::Test
-  def test_list_account_keys
-    Kloudless.http.expect(:get, returns: {"objects" => [{}]}, args: ["/accounts/1,2/keys", params: {}]) do
-      account_keys = Kloudless::AccountKey.list(account_ids: [1,2])
-      assert_kind_of Kloudless::Collection, account_keys
-      assert_kind_of Kloudless::AccountKey, account_keys.first
-    end
-  end
-
-  def test_retrieve_account_key
-    Kloudless.http.expect(:get, args: ["/accounts/1/keys/2", params: {}]) do
-      account_key = Kloudless::AccountKey.retrieve(account_id: 1, key_id: 2)
-      assert_kind_of Kloudless::AccountKey, account_key
-    end
-  end
-
-  def test_delete_account_key
-    Kloudless.http.expect(:delete, args: ["/accounts/1/keys/2"]) do
-      account_key = Kloudless::AccountKey.delete(account_id: 1, key_id: 2)
-      assert_kind_of Kloudless::AccountKey, account_key
-    end
-  end
-end