boxr 1.22.0 → 1.23.0

data/examples/use_events_to_warn_about_sharing.rb

@@ -1,18 +1,19 @@
-require 'dotenv'; Dotenv.load("../.env")
+require 'dotenv'
+Dotenv.load('../.env')
 require 'boxr'
-require 'mailgun' #make sure you 'gem install mailgun-ruby'
- 
-BOX_TRIGGER_EVENT = 'ITEM_SHARED_UPDATE,COLLABORATION_INVITE'
-FROM_EMAIL = "box-admin@#{ENV['MAILGUN_SENDING_DOMAIN']}"
-VALID_COLLABORATION_DOMAIN=ENV['VALID_COLLABORATION_DOMAIN'] #i.e. 'your-company.com'
+require 'mailgun' # make sure you 'gem install mailgun-ruby'
+
+BOX_TRIGGER_EVENT = 'ITEM_SHARED_UPDATE,COLLABORATION_INVITE'.freeze
+FROM_EMAIL = "box-admin@#{ENV['MAILGUN_SENDING_DOMAIN']}".freeze
+VALID_COLLABORATION_DOMAIN = ENV['VALID_COLLABORATION_DOMAIN'] # i.e. 'your-company.com'
 
 @mailgun_client = Mailgun::Client.new ENV['MAILGUN_API_KEY']
 @box_client = Boxr::Client.new(ENV['BOX_DEVELOPER_TOKEN'])
 
 def file_warning_text(event)
-%(
+  %(
 Our records indicate that you just created an open shared link for the document '#{event.source.item_name}'
-located in the folder '#{event.source.parent.name}'. 
+located in the folder '#{event.source.parent.name}'.
 
 If you meant to do this, please ignore this email.  Otherwise, please update this shared link
 so that it is no longer open access.
@@ -23,8 +24,8 @@ Your Box Admin
 end
 
 def folder_warning_text(event)
-%(
-Our records indicate that you just created an open shared link for the folder '#{event.source.item_name}'. 
+  %(
+Our records indicate that you just created an open shared link for the folder '#{event.source.item_name}'.
 
 If you meant to do this, please ignore this email.  Otherwise, please update this shared link
 so that it is no longer open access.
@@ -35,9 +36,9 @@ Your Box Admin
 end
 
 def collaboration_warning_text(event)
-%(
+  %(
 Our records indicate that you just invited #{event.accessible_by.login} to be an external collaborator
-with the role of #{event.additional_details.role} in the folder '#{event.source.folder_name}'. 
+with the role of #{event.additional_details.role} in the folder '#{event.source.folder_name}'.
 
 If you meant to do this, please ignore this email.  Otherwise, please remove this collaborator.
 
@@ -47,46 +48,49 @@ Your Box Admin
 end
 
 def send_email_to_box_user(from, to, subject, text)
-  #this example code uses Mailgun to send email, but you can use any standard SMTP server
-  message_params = {:from => from, :to => to, :subject => subject, :text => text}
+  # this example code uses Mailgun to send email, but you can use any standard SMTP server
+  message_params = { from: from, to: to, subject: subject, text: text }
   @mailgun_client.send_message ENV['MAILGUN_SENDING_DOMAIN'], message_params
 
   puts "Sent email to #{to} with subject '#{subject}'"
 end
 
-#need to look back in time to make sure we get a valid stream position; 
-#normally your app will be persisting the last known stream position and you wouldn't have to look this up
+# need to look back in time to make sure we get a valid stream position;
+# normally your app will be persisting the last known stream position and you wouldn't have to look this up
 now = Time.now.utc
-start_date = now - (60*60*24) #one day ago
+start_date = now - (60 * 60 * 24) # one day ago
 result = @box_client.enterprise_events(created_after: start_date, created_before: now)
 
-#now that we have the latest stream position let's start monitoring in real-time
-@box_client.enterprise_events_stream(result.next_stream_position, event_type: BOX_TRIGGER_EVENT, refresh_period: 60) do |result|
-  if result.events.count==0
+# now that we have the latest stream position let's start monitoring in real-time
+@box_client.enterprise_events_stream(result.next_stream_position, event_type: BOX_TRIGGER_EVENT,
+                                                                  refresh_period: 60) do |result|
+  if result.events.count.zero?
     puts "no new #{BOX_TRIGGER_EVENT} events..."
   else
     result.events.each do |e|
       puts "detected new #{e.event_type}"
-      if e.event_type=='ITEM_SHARED_UPDATE'
-        if e.source.item_type=='file'
+      if e.event_type == 'ITEM_SHARED_UPDATE'
+        if e.source.item_type == 'file'
           file = @box_client.file(e.source.item_id)
-          if file.shared_link.effective_access=='open'
-            send_email_to_box_user(FROM_EMAIL, e.created_by.login, "WARNING: Open Shared Link Detected", file_warning_text(e))
+          if file.shared_link.effective_access == 'open'
+            send_email_to_box_user(FROM_EMAIL, e.created_by.login,
+                                   'WARNING: Open Shared Link Detected', file_warning_text(e))
           end
-        elsif e.source.item_type=='folder'
+        elsif e.source.item_type == 'folder'
           folder = @box_client.folder(e.source.item_id)
-          if folder.shared_link.effective_access=='open'
-            send_email_to_box_user(FROM_EMAIL, e.created_by.login, "WARNING: Open Shared Link Detected", folder_warning_text(e))
+          if folder.shared_link.effective_access == 'open'
+            send_email_to_box_user(FROM_EMAIL, e.created_by.login,
+                                   'WARNING: Open Shared Link Detected', folder_warning_text(e))
           end
         end
-      elsif e.event_type=='COLLABORATION_INVITE'
+      elsif e.event_type == 'COLLABORATION_INVITE'
         email = e.accessible_by.login
         domain = email.split('@').last
-        unless domain.downcase==VALID_COLLABORATION_DOMAIN.downcase
-          send_email_to_box_user(FROM_EMAIL, e.created_by.login, "WARNING: External Collaborator Detected", collaboration_warning_text(e))
+        unless domain.downcase == VALID_COLLABORATION_DOMAIN.downcase
+          send_email_to_box_user(FROM_EMAIL, e.created_by.login,
+                                 'WARNING: External Collaborator Detected', collaboration_warning_text(e))
         end
       end
     end
   end
 end
-

data/examples/user_events.rb

@@ -1,23 +1,24 @@
-require 'dotenv'; Dotenv.load("../.env")
+require 'dotenv'
+Dotenv.load('../.env')
 require 'boxr'
 require 'awesome_print'
 require 'lru_redux'
 
 client = Boxr::Client.new(ENV['BOX_DEVELOPER_TOKEN'])
-cache = LruRedux::Cache.new(1000)
+cache = LruRedux::Cache.new(1000, true)
 
 stream_position = :now
-loop do 
-  puts "fetching events..."
+loop do
+  puts 'fetching events...'
   event_response = client.user_events(stream_position)
   event_response.events.each do |event|
-    #we need to de-dupe the events because we will receive multiple events with the same event_id; Box does this to ensure that we get the event
+    # we need to de-dupe the events because we will receive multiple events with the same event_id; Box does this to ensure that we get the event
     key = "/box-event/#{event.event_id}"
-    if (cache.fetch(key)==nil)
+    if cache.fetch(key).nil?
       cache[key] = true
       puts event.event_type
     end
   end
   stream_position = event_response.next_stream_position
   sleep 5
-end
+end

data/lib/boxr/auth.rb

@@ -1,29 +1,32 @@
-module Boxr
+# frozen_string_literal: true
 
-  JWT_GRANT_TYPE="urn:ietf:params:oauth:grant-type:jwt-bearer"
-  TOKEN_EXCHANGE_TOKEN_TYPE="urn:ietf:params:oauth:token-type:access_token"
-  TOKEN_EXCHANGE_GRANT_TYPE="urn:ietf:params:oauth:grant-type:token-exchange"
+module Boxr
+  JWT_GRANT_TYPE = 'urn:ietf:params:oauth:grant-type:jwt-bearer'
+  TOKEN_EXCHANGE_TOKEN_TYPE = 'urn:ietf:params:oauth:token-type:access_token'
+  TOKEN_EXCHANGE_GRANT_TYPE = 'urn:ietf:params:oauth:grant-type:token-exchange'
 
-  def self.oauth_url(state, host: "app.box.com", response_type: "code", scope: nil, folder_id: nil, client_id: ENV['BOX_CLIENT_ID'])
-    template = Addressable::Template.new("https://{host}/api/oauth2/authorize{?query*}")
+  def self.oauth_url(state, host: 'app.box.com', response_type: 'code', scope: nil, folder_id: nil,
+                     client_id: ENV['BOX_CLIENT_ID'])
+    template = Addressable::Template.new('https://{host}/api/oauth2/authorize{?query*}')
 
-    query = {"response_type" => "#{response_type}", "state" => "#{state}", "client_id" => "#{client_id}"}
-    query["scope"] = "#{scope}" unless scope.nil?
-    query["folder_id"] = "#{folder_id}" unless folder_id.nil?
+    query = { 'response_type' => response_type.to_s, 'state' => state.to_s,
+              'client_id' => client_id.to_s }
+    query['scope'] = scope.to_s unless scope.nil?
+    query['folder_id'] = folder_id.to_s unless folder_id.nil?
 
-    uri = template.expand({"host" => "#{host}", "query" => query})
-    uri
+    template.expand({ 'host' => host.to_s, 'query' => query })
   end
 
-  def self.get_tokens(code=nil, grant_type: "authorization_code", assertion: nil, scope: nil, username: nil, client_id: ENV['BOX_CLIENT_ID'], client_secret: ENV['BOX_CLIENT_SECRET'], box_subject_type: nil, box_subject_id: nil)
+  def self.get_tokens(code = nil, grant_type: 'authorization_code', assertion: nil, scope: nil,
+                      username: nil, client_id: ENV['BOX_CLIENT_ID'], client_secret: ENV['BOX_CLIENT_SECRET'], box_subject_type: nil, box_subject_id: nil)
     uri = Boxr::Client::AUTH_URI
     body = "grant_type=#{grant_type}&client_id=#{client_id}&client_secret=#{client_secret}"
-    body = body + "&code=#{code}" unless code.nil?
-    body = body + "&scope=#{scope}" unless scope.nil?
-    body = body + "&username=#{username}" unless username.nil?
-    body = body + "&assertion=#{assertion}" unless assertion.nil?
-    body = body + "&box_subject_type=#{box_subject_type}" unless box_subject_type.nil?
-    body = body + "&box_subject_id=#{box_subject_id}" unless box_subject_id.nil?
+    body += "&code=#{code}" unless code.nil?
+    body += "&scope=#{scope}" unless scope.nil?
+    body += "&username=#{username}" unless username.nil?
+    body += "&assertion=#{assertion}" unless assertion.nil?
+    body += "&box_subject_type=#{box_subject_type}" unless box_subject_type.nil?
+    body += "&box_subject_id=#{box_subject_id}" unless box_subject_id.nil?
 
     auth_post(uri, body)
   end
@@ -32,25 +35,30 @@ module Boxr
                                 public_key_id: ENV['JWT_PUBLIC_KEY_ID'], enterprise_id: ENV['BOX_ENTERPRISE_ID'],
                                 client_id: ENV['BOX_CLIENT_ID'], client_secret: ENV['BOX_CLIENT_SECRET'])
     unlocked_private_key = unlock_key(private_key, private_key_password)
-    assertion = jwt_assertion(unlocked_private_key, client_id, enterprise_id, "enterprise", public_key_id)
-    get_token(grant_type: JWT_GRANT_TYPE, assertion: assertion, client_id: client_id, client_secret: client_secret)
+    assertion = jwt_assertion(unlocked_private_key, client_id, enterprise_id, 'enterprise',
+                              public_key_id)
+    get_token(grant_type: JWT_GRANT_TYPE, assertion: assertion, client_id: client_id,
+              client_secret: client_secret)
   end
 
   def self.get_user_token(user_id, private_key: ENV['JWT_PRIVATE_KEY'], private_key_password: ENV['JWT_PRIVATE_KEY_PASSWORD'],
                           public_key_id: ENV['JWT_PUBLIC_KEY_ID'], client_id: ENV['BOX_CLIENT_ID'], client_secret: ENV['BOX_CLIENT_SECRET'])
     unlocked_private_key = unlock_key(private_key, private_key_password)
-    assertion = jwt_assertion(unlocked_private_key, client_id, user_id, "user", public_key_id)
-    get_token(grant_type: JWT_GRANT_TYPE, assertion: assertion, client_id: client_id, client_secret: client_secret)
+    assertion = jwt_assertion(unlocked_private_key, client_id, user_id, 'user', public_key_id)
+    get_token(grant_type: JWT_GRANT_TYPE, assertion: assertion, client_id: client_id,
+              client_secret: client_secret)
   end
 
-  def self.refresh_tokens(refresh_token, client_id: ENV['BOX_CLIENT_ID'], client_secret: ENV['BOX_CLIENT_SECRET'])
+  def self.refresh_tokens(refresh_token, client_id: ENV['BOX_CLIENT_ID'],
+                          client_secret: ENV['BOX_CLIENT_SECRET'])
     uri = Boxr::Client::AUTH_URI
     body = "grant_type=refresh_token&refresh_token=#{refresh_token}&client_id=#{client_id}&client_secret=#{client_secret}"
 
     auth_post(uri, body)
   end
 
-  def self.revoke_tokens(token, client_id: ENV['BOX_CLIENT_ID'], client_secret: ENV['BOX_CLIENT_SECRET'])
+  def self.revoke_tokens(token, client_id: ENV['BOX_CLIENT_ID'],
+                         client_secret: ENV['BOX_CLIENT_SECRET'])
     uri = Boxr::Client::REVOKE_AUTH_URI
     body = "client_id=#{client_id}&client_secret=#{client_secret}&token=#{token}"
 
@@ -64,20 +72,17 @@ module Boxr
     resource_url = "#{resouce_uri}/#{resource_id}"
 
     body = "subject_token=#{subject_token}&subject_token_type=#{TOKEN_EXCHANGE_TOKEN_TYPE}&scope=#{scope}&grant_type=#{TOKEN_EXCHANGE_GRANT_TYPE}"
-    body = body + "&resource=#{resource_url}" unless resource_id.nil?
+    body += "&resource=#{resource_url}" unless resource_id.nil?
 
     auth_post(uri, body)
   end
 
   class << self
-    alias :get_token :get_tokens
-    alias :refresh_token :refresh_tokens
-    alias :revoke_token :revoke_tokens
+    alias get_token get_tokens
+    alias refresh_token refresh_tokens
+    alias revoke_token revoke_tokens
   end
 
-  private
-
-
   def self.jwt_assertion(private_key, iss, sub, box_sub_type, public_key_id)
     payload = {
       iss: iss,
@@ -91,7 +96,7 @@ module Boxr
     additional_headers = {}
     additional_headers['kid'] = public_key_id unless public_key_id.nil?
 
-    JWT.encode(payload, private_key, "RS256", additional_headers)
+    JWT.encode(payload, private_key, 'RS256', additional_headers)
   end
 
   def self.auth_post(uri, body)
@@ -99,12 +104,12 @@ module Boxr
 
     res = BOX_CLIENT.post(uri, body: body)
 
-    if(res.status==200)
-      body_json = JSON.load(res.body)
-      return BoxrMash.new(body_json)
-    else
+    unless res.status == 200
       raise BoxrError.new(status: res.status, body: res.body, header: res.header)
     end
+
+    body_json = JSON.parse(res.body)
+    BoxrMash.new(body_json)
   end
 
   def self.unlock_key(private_key, private_key_password)

data/lib/boxr/chunked_uploads.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 module Boxr
   class Client
-
     def chunked_upload_create_session_new_file(path_to_file, parent, name: nil)
-      filename = name ? name : File.basename(path_to_file)
+      filename = name || File.basename(path_to_file)
 
       File.open(path_to_file) do |file|
         chunked_upload_create_session_new_file_from_io(file, parent, filename)
@@ -13,14 +14,15 @@ module Boxr
       parent_id = ensure_id(parent)
 
       uri = "#{UPLOAD_URI}/files/upload_sessions"
-      body = {folder_id: parent_id, file_size: io.size, file_name: name}
-      session_info, response = post(uri, body, content_type: "application/json", success_codes: [200,201,202])
+      body = { folder_id: parent_id, file_size: io.size, file_name: name }
+      session_info, = post(uri, body, content_type: 'application/json',
+                                      success_codes: [200, 201, 202])
 
       session_info
     end
 
     def chunked_upload_create_session_new_version(path_to_file, file, name: nil)
-      filename = name ? name : File.basename(path_to_file)
+      filename = name || File.basename(path_to_file)
 
       File.open(path_to_file) do |io|
         chunked_upload_create_session_new_version_from_io(io, file, filename)
@@ -30,15 +32,16 @@ module Boxr
     def chunked_upload_create_session_new_version_from_io(io, file, name)
       file_id = ensure_id(file)
       uri = "#{UPLOAD_URI}/files/#{file_id}/upload_sessions"
-      body = {file_size: io.size, file_name: name}
-      session_info, response = post(uri, body, content_type: "application/json", success_codes: [200,201,202])
+      body = { file_size: io.size, file_name: name }
+      session_info, = post(uri, body, content_type: 'application/json',
+                                      success_codes: [200, 201, 202])
 
       session_info
     end
 
     def chunked_upload_get_session(session_id)
       uri = "#{UPLOAD_URI}/files/upload_sessions/#{session_id}"
-      session_info, response = get(uri)
+      session_info, = get(uri)
 
       session_info
     end
@@ -60,7 +63,8 @@ module Boxr
 
       uri = "#{UPLOAD_URI}/files/upload_sessions/#{session_id}"
       body = data
-      part_info, response = put(uri, body, process_body: false, digest: digest, content_type: "application/octet-stream", content_range: range, success_codes: [200,201,202])
+      part_info, = put(uri, body, process_body: false, digest: digest,
+                                  content_type: 'application/octet-stream', content_range: range, success_codes: [200, 201, 202])
 
       part_info.part
     end
@@ -70,82 +74,100 @@ module Boxr
       query = {}
       query[:limit] = limit unless limit.nil?
       query[:offset] = offset unless offset.nil?
-      parts_info, response = get(uri, query: query)
+      parts_info, = get(uri, query: query)
 
       parts_info.entries
     end
 
-    def chunked_upload_commit(path_to_file, session_id, parts, content_created_at: nil, content_modified_at: nil, if_match: nil, if_non_match: nil)
+    def chunked_upload_commit(path_to_file, session_id, parts, content_created_at: nil,
+                              content_modified_at: nil, if_match: nil, if_non_match: nil)
       File.open(path_to_file) do |file|
-        chunked_upload_commit_from_io(file, session_id, parts, content_created_at: content_created_at, content_modified_at: content_modified_at, if_match: if_match, if_non_match: if_non_match)
+        chunked_upload_commit_from_io(file, session_id, parts,
+                                      content_created_at: content_created_at, content_modified_at: content_modified_at, if_match: if_match, if_non_match: if_non_match)
       end
     end
 
-    def chunked_upload_commit_from_io(io, session_id, parts, content_created_at: nil, content_modified_at: nil, if_match: nil, if_non_match: nil)
+    def chunked_upload_commit_from_io(io, session_id, parts, content_created_at: nil,
+                                      content_modified_at: nil, if_match: nil, if_non_match: nil)
       io.pos = 0
       digest = Digest::SHA1.new
-      while (buf = io.read(8 * 1024**2)) && buf.size > 0
+      while (buf = io.read(8 * 1024**2)) && buf.size.positive?
         digest.update(buf)
       end
       io.rewind
       digest = "sha=#{digest.base64digest}"
 
       attributes = {}
-      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?
+      unless content_created_at.nil?
+        attributes[:content_created_at] =
+          content_created_at.to_datetime.rfc3339
+      end
+      unless content_modified_at.nil?
+        attributes[:content_modified_at] =
+          content_modified_at.to_datetime.rfc3339
+      end
 
       uri = "#{UPLOAD_URI}/files/upload_sessions/#{session_id}/commit"
       body = {
         parts: parts,
         attributes: attributes
       }
-      commit_info, response = post(uri, body, process_body: true, digest: digest, content_type: "application/json", if_match: if_match, if_non_match: if_non_match, success_codes: [200,201,202])
+      commit_info, = post(uri, body, process_body: true, digest: digest,
+                                     content_type: 'application/json', if_match: if_match, if_non_match: if_non_match, success_codes: [200, 201, 202])
 
       commit_info
     end
 
     def chunked_upload_abort_session(session_id)
       uri = "#{UPLOAD_URI}/files/upload_sessions/#{session_id}"
-      abort_info, response = delete(uri)
+      abort_info, = delete(uri)
 
       abort_info
     end
 
-    def chunked_upload_file(path_to_file, parent, name: nil, n_threads: 1, content_created_at: nil, content_modified_at: nil)
-      filename = name ? name : File.basename(path_to_file)
+    def chunked_upload_file(path_to_file, parent, name: nil, n_threads: 1, content_created_at: nil,
+                            content_modified_at: nil)
+      filename = name || File.basename(path_to_file)
 
       File.open(path_to_file) do |file|
-        chunked_upload_file_from_io(file, parent, filename, n_threads: n_threads, content_created_at: content_created_at, content_modified_at: content_modified_at)
+        chunked_upload_file_from_io(file, parent, filename, n_threads: n_threads,
+                                                            content_created_at: content_created_at, content_modified_at: content_modified_at)
       end
     end
 
-    def chunked_upload_file_from_io(io, parent, name, n_threads: 1, content_created_at: nil, content_modified_at: nil)
+    def chunked_upload_file_from_io(io, parent, name, n_threads: 1, content_created_at: nil,
+                                    content_modified_at: nil)
       session = nil
       file_info = nil
 
       session = chunked_upload_create_session_new_file_from_io(io, parent, name)
 
-      file_info = chunked_upload_to_session_from_io(io, session, n_threads: n_threads, content_created_at: nil, content_modified_at: nil)
+      file_info = chunked_upload_to_session_from_io(io, session, n_threads: n_threads,
+                                                                 content_created_at: nil, content_modified_at: nil)
       file_info
     ensure
       chunked_upload_abort_session(session.id) if file_info.nil? && !session.nil?
     end
 
-    def chunked_upload_new_version_of_file(path_to_file, file, name: nil, n_threads: 1, content_created_at: nil, content_modified_at: nil)
-      filename = name ? name : File.basename(path_to_file)
+    def chunked_upload_new_version_of_file(path_to_file, file, name: nil, n_threads: 1,
+                                           content_created_at: nil, content_modified_at: nil)
+      filename = name || File.basename(path_to_file)
 
       File.open(path_to_file) do |io|
-        chunked_upload_new_version_of_file_from_io(io, file, filename, n_threads: n_threads, content_created_at: content_created_at, content_modified_at: content_modified_at)
+        chunked_upload_new_version_of_file_from_io(io, file, filename, n_threads: n_threads,
+                                                                       content_created_at: content_created_at, content_modified_at: content_modified_at)
       end
     end
 
-    def chunked_upload_new_version_of_file_from_io(io, file, name, n_threads: 1, content_created_at: nil, content_modified_at: nil)
+    def chunked_upload_new_version_of_file_from_io(io, file, name, n_threads: 1,
+                                                   content_created_at: nil, content_modified_at: nil)
       session = nil
       file_info = nil
 
       session = chunked_upload_create_session_new_version_from_io(io, file, name)
 
-      file_info = chunked_upload_to_session_from_io(io, session, n_threads: n_threads, content_created_at: nil, content_modified_at: nil)
+      file_info = chunked_upload_to_session_from_io(io, session, n_threads: n_threads,
+                                                                 content_created_at: nil, content_modified_at: nil)
       file_info
     ensure
       chunked_upload_abort_session(session.id) if file_info.nil? && !session.nil?
@@ -155,7 +177,8 @@ module Boxr
 
     PARALLEL_GEM_REQUIREMENT = Gem::Requirement.create('~> 1.0').freeze
 
-    def chunked_upload_to_session_from_io(io, session, n_threads: 1, content_created_at: nil, content_modified_at: nil)
+    def chunked_upload_to_session_from_io(io, session, n_threads: 1, content_created_at: nil,
+                                          content_modified_at: nil)
       content_ranges = []
       offset = 0
       loop do
@@ -168,7 +191,9 @@ module Boxr
 
       parts =
         if n_threads > 1
-          raise BoxrError.new(boxr_message: "parallel chunked uploads requires gem parallel (#{PARALLEL_GEM_REQUIREMENT}) to be loaded") unless gem_parallel_available?
+          unless gem_parallel_available?
+            raise BoxrError.new(boxr_message: "parallel chunked uploads requires gem parallel (#{PARALLEL_GEM_REQUIREMENT}) to be loaded")
+          end
 
           Parallel.map(content_ranges, in_threads: n_threads) do |content_range|
             File.open(io.path) do |io_dup|
@@ -187,11 +212,10 @@ module Boxr
     end
 
     def gem_parallel_available?
-      gem_spec  = Gem.loaded_specs['parallel']
+      gem_spec = Gem.loaded_specs['parallel']
       return false if gem_spec.nil?
 
       PARALLEL_GEM_REQUIREMENT.satisfied_by?(gem_spec.version) && defined?(Parallel)
     end
-
   end
 end