boxr 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4ecd063a6d71a477dc1aa7d50d53b2f649354599
-  data.tar.gz: 16fbb18c677d990d8dba2071226d1ce8f59ee145
+  metadata.gz: 9cdb5f7265259244d249458468620150e7a64f19
+  data.tar.gz: 0adf2236b65d01221f5b5b00d249387ac613e6a8
 SHA512:
-  metadata.gz: 657845370199ea7d468ea248c06038febfa0e58ba126b2bfb35cc6b7140262b0f078485ad4de83cf9b8bf8a8a7944831a498d6315cfc95e71dc706e10259cde7
-  data.tar.gz: 4dd7d41e230f9729cbb9ff2a90ecbca5e31cf7116800e034e9f9e4a3dc1195f15dd4e45aca0d0840c9dbf5e5d66ca13d512bca46a51fbf7533ea9ac52b764dd0
+  metadata.gz: 1113cc5af8e5de187b8c6ebd15625ae2164120ccde300b1e70dd484079ff6139d5eb4871605c1a6473c25e54e9a0896a07aef5ec63a62ff25d9429e3b3dd4963
+  data.tar.gz: 5a9985a2d4799935c622c0120cd477e7f3c8fd5a2061494dc0ac2cd3046729bb522daf747bd03c09ef7acded42a1863fd895ee069f6977254e3b2cb7386030a1

data/README.md

@@ -3,7 +3,7 @@ Boxr is a Ruby client library for the Box V2 Content API that covers 100% of the
 
 The purpose of this gem is to provide a clear, efficient, and intentional method of interacting with the Box Content API. As with any SDK that wraps a REST API, it is important to fully understand the Box Content API at the REST endpoint level.  You are strongly encouraged to read through the Box documentation located [here](https://developers.box.com/docs/).
 
-The full RubyDocs for Boxr can be found [here](http://www.rubydoc.info/gems/boxr).  You are also encouraged to rely heavily on the source code found in the [lib/boxr](https://github.com/cburnette/boxr/tree/master/lib/boxr) directory of this gem, as well as on the integration test found [here](https://github.com/cburnette/boxr/blob/master/spec/boxr_spec.rb).
+The full RubyDocs for Boxr can be found [here](http://www.rubydoc.info/gems/boxr/Boxr/Client).  You are also encouraged to rely heavily on the source code found in the [lib/boxr](https://github.com/cburnette/boxr/tree/master/lib/boxr) directory of this gem, as well as on the integration test found [here](https://github.com/cburnette/boxr/blob/master/spec/boxr_spec.rb).
 
 ## Installation
 Add this line to your application's Gemfile:

data/lib/boxr/client.rb

@@ -82,7 +82,7 @@ module Boxr
 
     def get(uri, query: nil, success_codes: [200], process_response: true, if_match: nil, box_api_header: nil)
       res = with_auto_token_refresh do
-        headers = standard_headers()
+        headers = standard_headers
         headers['If-Match'] = if_match unless if_match.nil?
         headers['BoxApi'] = box_api_header unless box_api_header.nil?
 
@@ -92,21 +92,20 @@ module Boxr
       check_response_status(res, success_codes)
 
       if process_response
-        return processed_response res
+        return processed_response(res)
       else
         return res.body, res
       end
     end
 
-    def get_with_pagination(uri, query: {}, limit: DEFAULT_LIMIT)
+    def get_with_pagination(uri, query: {}, offset: 0, limit: DEFAULT_LIMIT)
       entries = []
-      offset = 0
 
       begin
         query[:limit] = limit
         query[:offset] = offset
         res = with_auto_token_refresh do
-          headers = standard_headers()
+          headers = standard_headers
           BOX_CLIENT.get(uri, query: query, header: headers)
         end
         
@@ -128,7 +127,7 @@ module Boxr
       body = Oj.dump(body) if process_body
 
       res = with_auto_token_refresh do
-        headers = standard_headers()
+        headers = standard_headers
         headers['If-Match'] = if_match unless if_match.nil?
         headers["Content-MD5"] = content_md5 unless content_md5.nil?
         headers["Content-Type"] = content_type unless content_type.nil?
@@ -138,12 +137,12 @@ module Boxr
 
       check_response_status(res, success_codes)
 
-      processed_response res
+      processed_response(res)
     end
 
     def put(uri, body, query: nil, success_codes: [200], content_type: nil, if_match: nil)
       res = with_auto_token_refresh do
-        headers = standard_headers()
+        headers = standard_headers
         headers['If-Match'] = if_match unless if_match.nil?
         headers["Content-Type"] = content_type unless content_type.nil?
         
@@ -152,12 +151,12 @@ module Boxr
 
       check_response_status(res, success_codes)
 
-      processed_response res
+      processed_response(res)
     end
 
     def delete(uri, query: nil, success_codes: [204], if_match: nil)
       res = with_auto_token_refresh do
-        headers = standard_headers()
+        headers = standard_headers
         headers['If-Match'] = if_match unless if_match.nil?
         
         BOX_CLIENT.delete(uri, query: query, header: headers)
@@ -165,18 +164,18 @@ module Boxr
 
       check_response_status(res, success_codes)
 
-      processed_response res
+      processed_response(res)
     end
 
     def options(uri, body, success_codes: [200])
       res = with_auto_token_refresh do
-        headers = standard_headers()
+        headers = standard_headers
         BOX_CLIENT.options(uri, body: Oj.dump(body), header: headers)
       end
 
       check_response_status(res, success_codes)
 
-      processed_response res
+      processed_response(res)
     end
 
     def standard_headers()
@@ -233,7 +232,7 @@ module Boxr
       attributes[:name] = name unless name.nil?
       attributes[:parent] = {id: parent_id} unless parent_id.nil?
       
-      restored_item, response = post uri, attributes
+      restored_item, response = post(uri, attributes)
       restored_item
     end
 
@@ -248,14 +247,14 @@ module Boxr
         attributes[:shared_link][:permissions][:can_preview] = can_preview unless can_preview.nil?
       end
 
-      updated_item, response = put uri, attributes
+      updated_item, response = put(uri, attributes)
       updated_item
     end
 
     def disable_shared_link(uri, item_id)
       attributes = {shared_link: nil}
 
-      updated_item, response = put uri, attributes
+      updated_item, response = put(uri, attributes)
       updated_item
     end
 

data/lib/boxr/collaborations.rb

@@ -1,16 +1,16 @@
 module Boxr
   class Client
 
-    def folder_collaborations(folder_id)
-      folder_id = ensure_id(folder_id)
+    def folder_collaborations(folder)
+      folder_id = ensure_id(folder)
       uri = "#{FOLDERS_URI}/#{folder_id}/collaborations"
       collaborations, response = get(uri)
       collaborations['entries']
     end
 
     #make sure 'role' value is a string as Box has role values with spaces and dashes; e.g. 'previewer uploader'
-    def add_collaboration(folder_id, accessible_by, role, fields: [], notify: nil)
-      folder_id = ensure_id(folder_id)
+    def add_collaboration(folder, accessible_by, role, fields: [], notify: nil)
+      folder_id = ensure_id(folder)
       query = build_fields_query(fields, COLLABORATION_FIELDS_QUERY)
       query[:notify] = :notify unless notify.nil?
 
@@ -22,8 +22,8 @@ module Boxr
       collaboration
     end
 
-    def edit_collaboration(collaboration_id, role: nil, status: nil)
-      collaboration_id = ensure_id(collaboration_id)
+    def edit_collaboration(collaboration, role: nil, status: nil)
+      collaboration_id = ensure_id(collaboration)
       uri = "#{COLLABORATIONS_URI}/#{collaboration_id}"
       attributes = {}
       attributes[:role] = role unless role.nil?
@@ -33,15 +33,15 @@ module Boxr
       updated_collaboration
     end
 
-    def remove_collaboration(collaboration_id)
-      collaboration_id = ensure_id(collaboration_id)
+    def remove_collaboration(collaboration)
+      collaboration_id = ensure_id(collaboration)
       uri = "#{COLLABORATIONS_URI}/#{collaboration_id}"
       result, response = delete(uri)
       result
     end
 
-    def collaboration(collaboration_id, fields: [], status: nil)
-      collaboration_id = ensure_id(collaboration_id)
+    def collaboration(collaboration, fields: [], status: nil)
+      collaboration_id = ensure_id(collaboration)
       uri = "#{COLLABORATIONS_URI}/#{collaboration_id}"
 
       query = build_fields_query(fields, COLLABORATION_FIELDS_QUERY)

data/lib/boxr/comments.rb

@@ -1,16 +1,16 @@
 module Boxr
   class Client
 
-    def file_comments(file_id, fields: [])
-      file_id = ensure_id(file_id)
+    def file_comments(file, fields: [], offset: 0, limit: DEFAULT_LIMIT)
+      file_id = ensure_id(file)
       uri = "#{FILES_URI}/#{file_id}/comments"
       query = build_fields_query(fields, COMMENT_FIELDS_QUERY)
 
-      comments = get_with_pagination uri, query: query
+      comments = get_with_pagination(uri, query: query, offset: offset, limit: limit)
     end
 
-    def add_comment_to_file(file_id, message: nil, tagged_message: nil)
-      file_id = ensure_id(file_id)
+    def add_comment_to_file(file, message: nil, tagged_message: nil)
+      file_id = ensure_id(file)
       add_comment(:file, file_id, message, tagged_message)
     end
 
@@ -19,25 +19,25 @@ module Boxr
       add_comment(:comment, comment_id, message, tagged_message)
     end
 
-    def change_comment(comment_id, message)
-      comment_id = ensure_id(comment_id)
+    def change_comment(comment, message)
+      comment_id = ensure_id(comment)
       uri = "#{COMMENTS_URI}/#{comment_id}"
       attributes = {message: message}
-      updated_comment, response = put uri, attributes
+      updated_comment, response = put(uri, attributes)
       updated_comment
     end
 
-    def comment(comment_id, fields: [])
-      comment_id = ensure_id(comment_id)
+    def comment(comment, fields: [])
+      comment_id = ensure_id(comment)
       uri ="#{COMMENTS_URI}/#{comment_id}"
-      comment, response = get uri
+      comment, response = get(uri)
       comment
     end
 
-    def delete_comment(comment_id)
-      comment_id = ensure_id(comment_id)
+    def delete_comment(comment)
+      comment_id = ensure_id(comment)
       uri = "#{COMMENTS_URI}/#{comment_id}"
-      result, response = delete uri
+      result, response = delete(uri)
       result
     end
 
@@ -50,7 +50,7 @@ module Boxr
       attributes[:message] = message unless message.nil?
       attributes[:tagged_message] = tagged_message unless tagged_message.nil?
 
-      new_comment, response = post uri, attributes
+      new_comment, response = post(uri, attributes)
       new_comment
     end
 

data/lib/boxr/files.rb

@@ -11,22 +11,22 @@ module Boxr
 
       folder = folder_from_path(path_items.join('/'))
 
-      files = folder_items(folder.id, fields: [:id, :name]).files
+      files = folder_items(folder, fields: [:id, :name]).files
       file = files.select{|f| f.name == file_name}.first
       raise BoxrException.new(boxr_message: "File not found: '#{file_name}'") if file.nil?
       file
     end
 
-    def file(file_id, fields: [])
-      file_id = ensure_id(file_id)
+    def file(file, fields: [])
+      file_id = ensure_id(file)
       uri = "#{FILES_URI}/#{file_id}"
       query = build_fields_query(fields, FOLDER_AND_FILE_FIELDS_QUERY)
-      file, response = get uri, query: query
+      file, response = get(uri, query: query)
       file
     end
 
-    def update_file(file_id, name: nil, description: nil, parent_id: nil, shared_link: nil, tags: nil, if_match: nil)
-      file_id = ensure_id(file_id)
+    def update_file(file, name: nil, description: nil, parent_id: nil, shared_link: nil, tags: nil, if_match: nil)
+      file_id = ensure_id(file)
       uri = "#{FILES_URI}/#{file_id}"
 
       attributes = {}
@@ -36,23 +36,23 @@ module Boxr
       attributes[:shared_link] = shared_link unless shared_link.nil?
       attributes[:tags] = tags unless tags.nil? 
 
-      updated_file, response = put uri, attributes, if_match: if_match
+      updated_file, response = put(uri, attributes, if_match: if_match)
       updated_file
     end
 
-    def download_file(file_id, version: nil, follow_redirect: true)
-      file_id = ensure_id(file_id)
+    def download_file(file, version: nil, follow_redirect: true)
+      file_id = ensure_id(file)
       begin
         uri = "#{FILES_URI}/#{file_id}/content"
         query = {}
         query[:version] = version unless version.nil?
-        body_json, response = get uri, query: query, success_codes: [302,202]
+        body_json, response = get(uri, query: query, success_codes: [302,202])
 
         if(response.status==302)
           location = response.header['Location'][0]
 
           if(follow_redirect)
-            file, response = get location, process_response: false
+            file, response = get(location, process_response: false)
           else
             return location #simply return the url
           end
@@ -65,14 +65,14 @@ module Boxr
       file
     end
 
-    def download_url(file_id, version: nil)
-      download_file(file_id, version: version, follow_redirect: false)
+    def download_url(file, version: nil)
+      download_file(file, version: version, follow_redirect: false)
     end
 
-    def upload_file(path_to_file, parent_id, content_created_at: nil, content_modified_at: nil, 
+    def upload_file(path_to_file, parent, content_created_at: nil, content_modified_at: nil, 
                     preflight_check: true, send_content_md5: true)
 
-      parent_id = ensure_id(parent_id)
+      parent_id = ensure_id(parent)
       preflight_check(path_to_file, parent_id) if preflight_check
 
       file_info = nil
@@ -83,22 +83,22 @@ module Boxr
         attributes = {filename: file, parent_id: parent_id}
         attributes[:content_created_at] = content_created_at.to_datetime.rfc3339 unless content_created_at.nil?
         attributes[:content_modified_at] = content_modified_at.to_datetime.rfc3339 unless content_modified_at.nil?
-        file_info, response = post FILES_UPLOAD_URI, attributes, process_body: false, content_md5: content_md5
+        file_info, response = post(FILES_UPLOAD_URI, attributes, process_body: false, content_md5: content_md5)
       end
 
       file_info["entries"][0]
     end
 
-    def delete_file(file_id, if_match: nil)
-      file_id = ensure_id(file_id)
+    def delete_file(file, if_match: nil)
+      file_id = ensure_id(file)
       uri = "#{FILES_URI}/#{file_id}"
-      result, response = delete uri, if_match: if_match
+      result, response = delete(uri, if_match: if_match)
       result
     end
 
-    def upload_new_version_of_file(path_to_file, file_id, content_modified_at: nil, send_content_md5: true, 
+    def upload_new_version_of_file(path_to_file, file, content_modified_at: nil, send_content_md5: true, 
                                     preflight_check: true, if_match: nil)
-      file_id = ensure_id(file_id)
+      file_id = ensure_id(file)
       preflight_check_new_version_of_file(path_to_file, file_id) if preflight_check
 
       uri = "#{UPLOAD_URI}/files/#{file_id}/content"
@@ -109,62 +109,62 @@ module Boxr
         content_md5 = send_content_md5 ? Digest::SHA1.file(file).hexdigest : nil
         attributes = {filename: file}
         attributes[:content_modified_at] = content_modified_at.to_datetime.rfc3339 unless content_modified_at.nil?
-        file_info, response = post uri, attributes, process_body: false, content_md5: content_md5, if_match: if_match
+        file_info, response = post(uri, attributes, process_body: false, content_md5: content_md5, if_match: if_match)
       end
 
       file_info["entries"][0]
     end
 
-    def versions_of_file(file_id)
-      file_id = ensure_id(file_id)
+    def versions_of_file(file)
+      file_id = ensure_id(file)
       uri = "#{FILES_URI}/#{file_id}/versions"
-      versions, response = get uri
+      versions, response = get(uri)
       versions["entries"]
     end
 
-    def promote_old_version_of_file(file_id, file_version_id)
-      file_id = ensure_id(file_id)
-      file_version_id = ensure_id(file_version_id)
+    def promote_old_version_of_file(file, file_version)
+      file_id = ensure_id(file)
+      file_version_id = ensure_id(file_version)
 
       uri = "#{FILES_URI}/#{file_id}/versions/current"
       attributes = {:type => 'file_version', :id => file_version_id}
-      new_version, res = post uri, attributes
+      new_version, res = post(uri, attributes)
       new_version
     end
 
-    def delete_old_version_of_file(file_id, file_version_id, if_match: nil)
-      file_id = ensure_id(file_id)
-      file_version_id = ensure_id(file_version_id)
+    def delete_old_version_of_file(file, file_version, if_match: nil)
+      file_id = ensure_id(file)
+      file_version_id = ensure_id(file_version)
       
       uri = "#{FILES_URI}/#{file_id}/versions/#{file_version_id}"
-      result, response = delete uri, if_match: if_match
+      result, response = delete(uri, if_match: if_match)
       result
     end
 
-    def copy_file(file_id, parent_id, name: nil)
-      file_id = ensure_id(file_id)
-      parent_id = ensure_id(parent_id)
+    def copy_file(file, parent, name: nil)
+      file_id = ensure_id(file)
+      parent_id = ensure_id(parent)
 
       uri = "#{FILES_URI}/#{file_id}/copy"
       attributes = {:parent => {:id => parent_id}}
       attributes[:name] = name unless name.nil?
-      new_file, res = post uri, attributes
+      new_file, res = post(uri, attributes)
       new_file
     end
 
-    def thumbnail(file_id, min_height: nil, min_width: nil, max_height: nil, max_width: nil)
-      file_id = ensure_id(file_id)
+    def thumbnail(file, min_height: nil, min_width: nil, max_height: nil, max_width: nil)
+      file_id = ensure_id(file)
       uri = "#{FILES_URI}/#{file_id}/thumbnail.png"
       query = {}
       query[:min_height] = min_height unless min_height.nil?
       query[:min_width] = min_width unless min_width.nil?
       query[:max_height] = max_height unless max_height.nil?
       query[:max_width] = max_width unless max_width.nil?
-      body, response = get uri, query: query, success_codes: [302,202,200], process_response: false
+      body, response = get(uri, query: query, success_codes: [302,202,200], process_response: false)
 
       if(response.status==202 || response.status==302)
         location = response.header['Location'][0]
-        thumbnail, response = get location, process_response: false
+        thumbnail, response = get(location, process_response: false)
       else #200
         thumbnail = body
       end
@@ -172,37 +172,37 @@ module Boxr
       thumbnail
     end
 
-    def create_shared_link_for_file(file_id, access: nil, unshared_at: nil, can_download: nil, can_preview: nil)
-      file_id = ensure_id(file_id)
+    def create_shared_link_for_file(file, access: nil, unshared_at: nil, can_download: nil, can_preview: nil)
+      file_id = ensure_id(file)
       uri = "#{FILES_URI}/#{file_id}"
       create_shared_link(uri, file_id, access, unshared_at, can_download, can_preview)
     end
 
-    def disable_shared_link_for_file(file_id)
-      file_id = ensure_id(file_id)
+    def disable_shared_link_for_file(file)
+      file_id = ensure_id(file)
       uri = "#{FILES_URI}/#{file_id}"
       disable_shared_link(uri, file_id)
     end
 
-    def trashed_file(file_id, fields: [])
-      file_id = ensure_id(file_id)
+    def trashed_file(file, fields: [])
+      file_id = ensure_id(file)
       uri = "#{FILES_URI}/#{file_id}/trash"
       query = build_fields_query(fields, FOLDER_AND_FILE_FIELDS_QUERY)
 
-      trashed_file, response = get uri, query: query
+      trashed_file, response = get(uri, query: query)
       trashed_file
     end
 
-    def delete_trashed_file(file_id)
-      file_id = ensure_id(file_id)
+    def delete_trashed_file(file)
+      file_id = ensure_id(file)
       uri = "#{FILES_URI}/#{file_id}/trash"
 
-      result, response = delete uri
+      result, response = delete(uri)
       result
     end
 
-    def restore_trashed_file(file_id, name: nil, parent_id: nil)
-      file_id = ensure_id(file_id)
+    def restore_trashed_file(file, name: nil, parent_id: nil)
+      file_id = ensure_id(file)
       uri = "#{FILES_URI}/#{file_id}"
       restore_trashed_item(uri, name, parent_id)
     end
@@ -216,13 +216,13 @@ module Boxr
       #TODO: need to make sure that figuring out the filename from the path_to_file works for people using Winblows
       filename = File.basename(path_to_file)
       attributes = {"name" => filename, "parent" => {"id" => "#{parent_id}"}, "size" => size}
-      body_json, res = options "#{FILES_URI}/content", attributes
+      body_json, res = options("#{FILES_URI}/content", attributes)
     end
 
     def preflight_check_new_version_of_file(path_to_file, file_id)
       size = File.size(path_to_file)
       attributes = {"size" => size}
-      body_json, res = options "#{FILES_URI}/#{file_id}/content", attributes
+      body_json, res = options("#{FILES_URI}/#{file_id}/content", attributes)
     end
 
   end

data/lib/boxr/folders.rb

@@ -8,49 +8,48 @@ module Boxr
 
       path_folders = path.split('/')
 
-      root_folder = Hashie::Mash.new({id: Boxr::ROOT})
-      folder = path_folders.inject(root_folder) do |parent_folder, folder_name|
-        folders = folder_items(parent_folder.id, fields: [:id, :name]).folders
+      folder = path_folders.inject(Boxr::ROOT) do |parent_folder, folder_name|
+        folders = folder_items(parent_folder, fields: [:id, :name]).folders
         folder = folders.select{|f| f.name == folder_name}.first
         raise BoxrException.new(boxr_message: "Folder not found: '#{folder_name}'") if folder.nil?
         folder
       end
     end
 
-    def folder_items(folder_id, fields: [])
-      folder_id = ensure_id(folder_id)
+    def folder_items(folder, fields: [], offset: 0, limit: FOLDER_ITEMS_LIMIT)
+      folder_id = ensure_id(folder)
       query = build_fields_query(fields, FOLDER_AND_FILE_FIELDS_QUERY)
       uri = "#{FOLDERS_URI}/#{folder_id}/items"
 
-      items = get_with_pagination uri, query: query, limit: FOLDER_ITEMS_LIMIT
+      items = get_with_pagination(uri, query: query, offset: offset, limit: limit)
     end
 
     def root_folder_items(fields: [])
       folder_items(Boxr::ROOT, fields: fields)
     end
 
-    def create_folder(name, parent_id)
-      parent_id = ensure_id(parent_id)
+    def create_folder(name, parent)
+      parent_id = ensure_id(parent)
       uri = "#{FOLDERS_URI}"
       attributes = {:name => name, :parent => {:id => parent_id}}
       
-      created_folder, response = post uri, attributes
+      created_folder, response = post(uri, attributes)
       created_folder
     end
 
-    def folder(folder_id, fields: [])
-      folder_id = ensure_id(folder_id)
+    def folder(folder, fields: [])
+      folder_id = ensure_id(folder)
       query = build_fields_query(fields, FOLDER_AND_FILE_FIELDS_QUERY)
       uri = "#{FOLDERS_URI}/#{folder_id}"
 
-      folder, response = get uri, query: query
+      folder, response = get(uri, query: query)
       folder
     end
 
-    def update_folder(folder_id, name: nil, description: nil, parent_id: nil, shared_link: nil,
+    def update_folder(folder, name: nil, description: nil, parent_id: nil, shared_link: nil,
                            folder_upload_email_access: nil, owned_by_id: nil, sync_state: nil, tags: nil,
                            can_non_owners_invite: nil, if_match: nil)
-      folder_id = ensure_id(folder_id)
+      folder_id = ensure_id(folder)
       uri = "#{FOLDERS_URI}/#{folder_id}"
 
       attributes = {}
@@ -64,68 +63,68 @@ module Boxr
       attributes[:tags] = tags unless tags.nil? 
       attributes[:can_non_owners_invite] = can_non_owners_invite unless can_non_owners_invite.nil?
 
-      updated_folder, response = put uri, attributes, if_match: if_match
+      updated_folder, response = put(uri, attributes, if_match: if_match)
       updated_folder
     end
 
-    def delete_folder(folder_id, recursive: false, if_match: nil)
-      folder_id = ensure_id(folder_id)
+    def delete_folder(folder, recursive: false, if_match: nil)
+      folder_id = ensure_id(folder)
       uri = "#{FOLDERS_URI}/#{folder_id}"
       query = {:recursive => recursive}
 
-      result, response = delete uri, query: query, if_match: if_match
+      result, response = delete(uri, query: query, if_match: if_match)
       result
     end
 
-    def copy_folder(folder_id, dest_folder_id, name: nil)
-      folder_id = ensure_id(folder_id)
-      dest_folder_id = ensure_id(dest_folder_id)
+    def copy_folder(folder, dest_folder, name: nil)
+      folder_id = ensure_id(folder)
+      dest_folder_id = ensure_id(dest_folder)
 
       uri = "#{FOLDERS_URI}/#{folder_id}/copy"
       attributes = {:parent => {:id => dest_folder_id}}
       attributes[:name] = name unless name.nil?
 
-      new_folder, response = post uri, attributes
+      new_folder, response = post(uri, attributes)
       new_folder
     end
 
-    def create_shared_link_for_folder(folder_id, access: nil, unshared_at: nil, can_download: nil, can_preview: nil)
-      folder_id = ensure_id(folder_id)
+    def create_shared_link_for_folder(folder, access: nil, unshared_at: nil, can_download: nil, can_preview: nil)
+      folder_id = ensure_id(folder)
       uri = "#{FOLDERS_URI}/#{folder_id}"
       create_shared_link(uri, folder_id, access, unshared_at, can_download, can_preview)
     end
 
-    def disable_shared_link_for_folder(folder_id)
-      folder_id = ensure_id(folder_id)
+    def disable_shared_link_for_folder(folder)
+      folder_id = ensure_id(folder)
       uri = "#{FOLDERS_URI}/#{folder_id}"
       disable_shared_link(uri, folder_id)
     end
 
-    def trash(fields: [])
+    def trash(fields: [], offset: 0, limit: FOLDER_ITEMS_LIMIT)
       uri = "#{FOLDERS_URI}/trash/items"
       query = build_fields_query(fields, FOLDER_AND_FILE_FIELDS_QUERY)
 
-      items = get_with_pagination uri, query: query, limit: FOLDER_ITEMS_LIMIT
+      items = get_with_pagination(uri, query: query, offset: offset, limit: limit)
     end
 
-    def trashed_folder(folder_id, fields: [])
-      folder_id = ensure_id(folder_id)
+    def trashed_folder(folder, fields: [])
+      folder_id = ensure_id(folder)
       uri = "#{FOLDERS_URI}/#{folder_id}/trash"
       query = build_fields_query(fields, FOLDER_AND_FILE_FIELDS_QUERY)
       
-      folder, response = get uri, query: query
+      folder, response = get(uri, query: query)
       folder
     end
 
-    def delete_trashed_folder(folder_id)
-      folder_id = ensure_id(folder_id)
+    def delete_trashed_folder(folder)
+      folder_id = ensure_id(folder)
       uri = "#{FOLDERS_URI}/#{folder_id}/trash"
-      result, response = delete uri
+      result, response = delete(uri)
       result
     end
 
-    def restore_trashed_folder(folder_id, name: nil, parent_id: nil)
-      folder_id = ensure_id(folder_id)
+    def restore_trashed_folder(folder, name: nil, parent_id: nil)
+      folder_id = ensure_id(folder)
       uri = "#{FOLDERS_URI}/#{folder_id}"
       restore_trashed_item(uri, name, parent_id)
     end

data/lib/boxr/groups.rb

@@ -1,9 +1,9 @@
 module Boxr
   class Client
 
-    def groups(fields: [])
+    def groups(fields: [], offset: 0, limit: DEFAULT_LIMIT)
       query = build_fields_query(fields, GROUP_FIELDS_QUERY)
-      groups = get_with_pagination(GROUPS_URI, query: query)
+      groups = get_with_pagination(GROUPS_URI, query: query, offset: offset, limit: limit)
     end
 
     def create_group(name)
@@ -12,8 +12,8 @@ module Boxr
       new_group 
     end
 
-    def update_group(group_id, name)
-      group_id = ensure_id(group_id)
+    def update_group(group, name)
+      group_id = ensure_id(group)
       uri = "#{GROUPS_URI}/#{group_id}"
       attributes = {name: name}
 
@@ -23,40 +23,40 @@ module Boxr
 
     alias :rename_group :update_group
 
-    def delete_group(group_id)
-      group_id = ensure_id(group_id)
+    def delete_group(group)
+      group_id = ensure_id(group)
       uri = "#{GROUPS_URI}/#{group_id}"
       result, response = delete(uri)
       result
     end
 
-    def group_memberships(group_id)
-      group_id = ensure_id(group_id)
+    def group_memberships(group, offset: 0, limit: DEFAULT_LIMIT)
+      group_id = ensure_id(group)
       uri = "#{GROUPS_URI}/#{group_id}/memberships"
-      memberships = get_with_pagination(uri)
+      memberships = get_with_pagination(uri, offset: offset, limit: limit)
     end
 
-    def group_memberships_for_user(user_id)
-      user_id = ensure_id(user_id)
+    def group_memberships_for_user(user, offset: 0, limit: DEFAULT_LIMIT)
+      user_id = ensure_id(user)
       uri = "#{USERS_URI}/#{user_id}/memberships"
-      memberships = get_with_pagination(uri)
+      memberships = get_with_pagination(uri, offset: offset, limit: limit)
     end
 
-    def group_memberships_for_me
+    def group_memberships_for_me(offset: 0, limit: DEFAULT_LIMIT)
       uri = "#{USERS_URI}/me/memberships"
-      memberships = get_with_pagination(uri)
+      memberships = get_with_pagination(uri, offset: offset, limit: limit)
     end
 
-    def group_membership(membership_id)
-      membership_id = ensure_id(membership_id)
+    def group_membership(membership)
+      membership_id = ensure_id(membership)
       uri = "#{GROUP_MEMBERSHIPS_URI}/#{membership_id}"
       membership, response = get(uri)
       membership
     end
 
-    def add_user_to_group(user_id, group_id, role: nil)
-      user_id = ensure_id(user_id)
-      group_id = ensure_id(group_id)
+    def add_user_to_group(user, group, role: nil)
+      user_id = ensure_id(user)
+      group_id = ensure_id(group)
 
       attributes = {user: {id: user_id}, group: {id: group_id}}
       attributes[:role] = role unless role.nil?
@@ -64,25 +64,25 @@ module Boxr
       membership
     end
 
-    def update_group_membership(membership_id, role)
-      membership_id = ensure_id(membership_id)
+    def update_group_membership(membership, role)
+      membership_id = ensure_id(membership)
       uri = "#{GROUP_MEMBERSHIPS_URI}/#{membership_id}"
       attributes = {role: role}
       updated_membership, response = put(uri, attributes)
       updated_membership
     end
 
-    def delete_group_membership(membership_id)
-      membership_id = ensure_id(membership_id)
+    def delete_group_membership(membership)
+      membership_id = ensure_id(membership)
       uri = "#{GROUP_MEMBERSHIPS_URI}/#{membership_id}"
       result, response = delete(uri)
       result
     end
 
-    def group_collaborations(group_id)
-      group_id = ensure_id(group_id)
+    def group_collaborations(group, offset: 0, limit: DEFAULT_LIMIT)
+      group_id = ensure_id(group)
       uri = "#{GROUPS_URI}/#{group_id}/collaborations"
-      collaborations = get_with_pagination(uri)
+      collaborations = get_with_pagination(uri, offset: offset, limit: limit)
     end
 
   end

data/lib/boxr/metadata.rb

@@ -1,31 +1,31 @@
 module Boxr
   class Client
 
-    def create_metadata(file_id, metadata, type: :properties)
-      file_id = ensure_id(file_id)
+    def create_metadata(file, metadata, type: :properties)
+      file_id = ensure_id(file)
       uri = "#{METADATA_URI}/#{file_id}/metadata/#{type}"
-      metadata, response = post uri, metadata, content_type: "application/json"
+      metadata, response = post(uri, metadata, content_type: "application/json")
       metadata
     end
 
-    def metadata(file_id, type: :properties)
-      file_id = ensure_id(file_id)
+    def metadata(file, type: :properties)
+      file_id = ensure_id(file)
       uri = "#{METADATA_URI}/#{file_id}/metadata/#{type}"
-      metadata, response = get uri
+      metadata, response = get(uri)
       metadata
     end
 
-    def update_metadata(file_id, updates, type: :properties)
-      file_id = ensure_id(file_id)
+    def update_metadata(file, updates, type: :properties)
+      file_id = ensure_id(file)
       uri = "#{METADATA_URI}/#{file_id}/metadata/#{type}"
-      metadata, response = put uri, updates, content_type: "application/json-patch+json"
+      metadata, response = put(uri, updates, content_type: "application/json-patch+json")
       metadata
     end
 
-    def delete_metadata(file_id, type: :properties)
-      file_id = ensure_id(file_id)
+    def delete_metadata(file, type: :properties)
+      file_id = ensure_id(file)
       uri = "#{METADATA_URI}/#{file_id}/metadata/#{type}"
-      result, response = delete uri
+      result, response = delete(uri)
       result
     end
 

data/lib/boxr/search.rb

@@ -18,7 +18,7 @@ module Boxr
       query[:limit] = limit unless limit.nil?
       query[:offset] = offset unless offset.nil?
 
-      results, response = get SEARCH_URI, query: query
+      results, response = get(SEARCH_URI, query: query)
       results["entries"]
     end
 

data/lib/boxr/tasks.rb

@@ -1,93 +1,93 @@
 module Boxr
   class Client
 
-    def file_tasks(file_id, fields: [])
-      file_id = ensure_id(file_id)
+    def file_tasks(file, fields: [])
+      file_id = ensure_id(file)
       uri = "#{FILES_URI}/#{file_id}/tasks"
       query = build_fields_query(fields, TASK_FIELDS_QUERY)
 
-      tasks, response = get uri, query: query
+      tasks, response = get(uri, query: query)
       tasks["entries"]
     end
 
-    def create_task(file_id, action: :review, message: nil, due_at: nil)
-      file_id = ensure_id(file_id)
+    def create_task(file, action: :review, message: nil, due_at: nil)
+      file_id = ensure_id(file)
       attributes = {item: {type: :file, id: file_id}}
       attributes[:action] = action unless action.nil?
       attributes[:message] = message unless message.nil?
       attributes[:due_at] = due_at.to_datetime.rfc3339 unless due_at.nil?
 
-      new_task, response = post TASKS_URI, attributes
+      new_task, response = post(TASKS_URI, attributes)
       new_task
     end
 
-    def task(task_id)
-      task_id = ensure_id(task_id)
+    def task(task)
+      task_id = ensure_id(task)
       uri = "#{TASKS_URI}/#{task_id}"
-      task, response = get uri
+      task, response = get(uri)
       task
     end
 
-    def update_task(task_id, action: :review, message: nil, due_at: nil)
-      task_id = ensure_id(task_id)
+    def update_task(task, action: :review, message: nil, due_at: nil)
+      task_id = ensure_id(task)
       uri = "#{TASKS_URI}/#{task_id}"
       attributes = {}
       attributes[:action] = action unless action.nil?
       attributes[:message] = message unless message.nil?
       attributes[:due_at] = due_at.to_datetime.rfc3339 unless due_at.nil?
 
-      task, response = put uri, attributes
+      task, response = put(uri, attributes)
       task
     end
 
-    def delete_task(task_id)
-      task_id = ensure_id(task_id)
+    def delete_task(task)
+      task_id = ensure_id(task)
       uri = "#{TASKS_URI}/#{task_id}"
-      result, response = delete uri
+      result, response = delete(uri)
       result
     end
 
-    def task_assignments(task_id)
-      task_id = ensure_id(task_id)
+    def task_assignments(task)
+      task_id = ensure_id(task)
       uri = "#{TASKS_URI}/#{task_id}/assignments"
-      assignments, response = get uri
+      assignments, response = get(uri)
       assignments['entries']
     end
 
-    def create_task_assignment(task_id, assign_to_id: nil, assign_to_login: nil)
-      task_id = ensure_id(task_id)
+    def create_task_assignment(task, assign_to_id: nil, assign_to_login: nil)
+      task_id = ensure_id(task)
       attributes = {task: {type: :task, id: "#{task_id}"}}
       
       attributes[:assign_to] = {} 
       attributes[:assign_to][:login] = assign_to_login unless assign_to_login.nil?
       attributes[:assign_to][:id] = assign_to_id unless assign_to_id.nil?
 
-      new_task_assignment, response = post TASK_ASSIGNMENTS_URI, attributes
+      new_task_assignment, response = post(TASK_ASSIGNMENTS_URI, attributes)
       new_task_assignment
     end
 
-    def task_assignment(task_id)
-      task_id = ensure_id(task_id)
+    def task_assignment(task)
+      task_id = ensure_id(task)
       uri = "#{TASK_ASSIGNMENTS_URI}/#{task_id}"
-      task_assignment, response = get uri
+      task_assignment, response = get(uri)
       task_assignment
     end
 
-    def delete_task_assignment(task_id)
-      task_id = ensure_id(task_id)
+    def delete_task_assignment(task)
+      task_id = ensure_id(task)
       uri = "#{TASK_ASSIGNMENTS_URI}/#{task_id}"
-      result, response = delete uri
+      result, response = delete(uri)
       result
     end
 
-    def update_task_assignment(task_id, message: nil, resolution_state: nil)
-      task_id = ensure_id(task_id)
+    def update_task_assignment(task, message: nil, resolution_state: nil)
+      task_id = ensure_id(task)
       uri = "#{TASK_ASSIGNMENTS_URI}/#{task_id}"
       attributes = {}
       attributes[:message] = message unless message.nil?
       attributes[:resolution_state] = resolution_state unless resolution_state.nil?
 
-      updated_task, response = put uri, attributes
+      updated_task, response = put(uri, attributes)
       updated_task
     end
 

data/lib/boxr/users.rb

@@ -10,19 +10,19 @@ module Boxr
 
     alias :me :current_user
 
-    def user(user_id, fields: [])
-      user_id = ensure_id(user_id)
+    def user(user, fields: [])
+      user_id = ensure_id(user)
       uri = "#{USERS_URI}/#{user_id}"
       query = build_fields_query(fields, USER_FIELDS_QUERY)
       user, response = get(uri, query: query)
       user
     end
 
-    def all_users(filter_term: nil, fields: [])
+    def all_users(filter_term: nil, fields: [], offset: 0, limit: DEFAULT_LIMIT)
       uri = USERS_URI
       query = build_fields_query(fields, USER_FIELDS_QUERY)
       query[:filter_term] = filter_term unless filter_term.nil?
-      users = get_with_pagination(uri, query: query)
+      users = get_with_pagination(uri, query: query, offset: offset, limit: limit)
     end
 
     def create_user(login, name, role: nil, language: nil, is_sync_enabled: nil, job_title: nil,
@@ -51,12 +51,12 @@ module Boxr
       new_user
     end
 
-    def update_user(user_id, notify: nil, enterprise: true, name: nil, role: nil, language: nil, is_sync_enabled: nil,
+    def update_user(user, notify: nil, enterprise: true, name: nil, role: nil, language: nil, is_sync_enabled: nil,
                              job_title: nil, phone: nil, address: nil, space_amount: nil, tracking_codes: nil,
                              can_see_managed_users: nil, status: nil, timezone: nil, is_exempt_from_device_limits: nil,
                              is_exempt_from_login_verification: nil, is_exempt_from_reset_required: nil, is_external_collab_restricted: nil)
 
-      user_id = ensure_id(user_id)
+      user_id = ensure_id(user)
       uri = "#{USERS_URI}/#{user_id}"
       query = {notify: notify} unless notify.nil?
       
@@ -83,8 +83,8 @@ module Boxr
       updated_user
     end
 
-    def delete_user(user_id, notify: nil, force: nil)
-      user_id = ensure_id(user_id)
+    def delete_user(user, notify: nil, force: nil)
+      user_id = ensure_id(user)
       uri = "#{USERS_URI}/#{user_id}"
       query = {}
       query[:notify] = notify unless notify.nil?

data/lib/boxr/version.rb

@@ -1,3 +1,3 @@
 module Boxr
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: boxr
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Chad Burnette