disrb 0.1.0 → 0.1.1

data/lib/disrb/guild.rb

@@ -3,9 +3,9 @@
 # DiscordApi
 # The class that contains everything that interacts with the Discord API.
 class DiscordApi
-  def create_guild(name, region = nil, icon = nil, verification_level = nil, default_message_notifications = nil,
-                   explicit_content_filter = nil, roles = nil, channels = nil, afk_channel_id = nil, afk_timeout = nil,
-                   system_channel_id = nil, system_channel_flags = nil)
+  def create_guild(name, region: nil, icon: nil, verification_level: nil, default_message_notifications: nil,
+                   explicit_content_filter: nil, roles: nil, channels: nil, afk_channel_id: nil, afk_timeout: nil,
+                   system_channel_id: nil, system_channel_flags: nil)
     output = {}
     output[:name] = name
     unless region.nil?
@@ -22,11 +22,11 @@ class DiscordApi
     output[:afk_timeout] = afk_timeout unless afk_timeout.nil?
     output[:system_channel_id] = system_channel_id unless system_channel_id.nil?
     output[:system_channel_flags] = system_channel_flags unless system_channel_flags.nil?
-    url = URI("#{@base_url}/guilds")
+    url = "#{@base_url}/guilds"
     data = JSON.generate(output)
     headers = { 'Authorization': @authorization_header, 'Content-Type': 'application/json' }
-    response = Net::HTTP.post(url, data, headers)
-    return response unless response.code != '200'
+    response = DiscordApi.post(url, data, headers)
+    return response unless response.status != 200
 
     @logger.error("Could not create guild. Response: #{response.body}")
     response
@@ -49,19 +49,19 @@ class DiscordApi
   def get_guild_preview(guild_id)
     url = URI("#{@base_url}/guilds/#{guild_id}/preview")
     headers = { 'Authorization': @authorization_header }
-    response = Net::HTTP.get(url, headers)
-    return response unless response.code != '200'
+    response = DiscordApi.get(url, headers)
+    return response unless response.status != 200
 
     @logger.error("Could not get guild preview with Guild ID #{guild_id}. Response: #{response.body}")
     response
   end
 
-  def modify_guild(guild_id, name = nil, region = nil, verification_level = nil, default_message_notifications = nil,
-                   explicit_content_filter = nil, afk_channel_id = nil, afk_timeout = nil, icon = nil, owner_id = nil,
-                   splash = nil, discovery_splash = nil, banner = nil, system_channel_id = nil,
-                   system_channel_flags = nil, rules_channel_id = nil, public_updates_channel_id = nil,
-                   preferred_locale = nil, features = nil, description = nil, premium_progress_bar_enabled = nil,
-                   safety_alerts_channel_id = nil, audit_reason = nil)
+  def modify_guild(guild_id, name: nil, region: nil, verification_level: nil, default_message_notifications: nil,
+                   explicit_content_filter: nil, afk_channel_id: nil, afk_timeout: nil, icon: nil, owner_id: nil,
+                   splash: nil, discovery_splash: nil, banner: nil, system_channel_id: nil,
+                   system_channel_flags: nil, rules_channel_id: nil, public_updates_channel_id: nil,
+                   preferred_locale: nil, features: nil, description: nil, premium_progress_bar_enabled: nil,
+                   safety_alerts_channel_id: nil, audit_reason: nil)
     output = {}
     output[:name] = name unless name.nil?
     unless region.nil?
@@ -85,44 +85,44 @@ class DiscordApi
     output[:preferred_locale] = preferred_locale unless preferred_locale.nil?
     output[:features] = features unless features.nil?
     output[:description] = description unless description.nil?
-    output[:premium_progress_bar_enabled] = !premium_progress_bar_enabled.nil?
+    output[:premium_progress_bar_enabled] = premium_progress_bar_enabled unless premium_progress_bar_enabled.nil?
     output[:safety_alerts_channel_id] = safety_alerts_channel_id unless safety_alerts_channel_id.nil?
-    url = URI("#{@base_url}/guilds/#{guild_id}")
+    url = "#{@base_url}/guilds/#{guild_id}"
     data = JSON.generate(output)
     headers = { 'Authorization': @authorization_header, 'Content-Type': 'application/json' }
     headers['X-Audit-Log-Reason'] = audit_reason unless audit_reason.nil?
-    response = Net::HTTP.patch(url, headers, data)
-    return response unless response.code != '200'
+    response = DiscordApi.patch(url, headers, data)
+    return response unless response.status != 200
 
     @logger.error("Could not modify guild with Guild ID #{guild_id}. Response: #{response.body}")
     response
   end
 
   def delete_guild(guild_id)
-    url = URI("#{@base_url}/guilds/#{guild_id}")
+    url = "#{@base_url}/guilds/#{guild_id}"
     headers = { 'Authorization': @authorization_header }
-    response = Net::HTTP.delete(url, headers)
-    return response unless response.code != '204'
+    response = DiscordApi.delete(url, headers)
+    return response unless response.status != 204
 
     @logger.error("Could not delete guild with Guild ID #{guild_id}. Response: #{response.body}")
     response
   end
 
   def get_guild_channels(guild_id)
-    url = URI("#{@base_url}/guilds/#{guild_id}/channels")
+    url = "#{@base_url}/guilds/#{guild_id}/channels"
     headers = { 'Authorization': @authorization_header }
-    response = Net::HTTP.get(url, headers)
-    return response unless response.code != '200'
+    response = DiscordApi.get(url, headers)
+    return response unless response.status != 200
 
     @logger.error("Could not get guild channels with Guild ID #{guild_id}. Response: #{response.body}")
     response
   end
 
-  def create_guild_channel(guild_id, name, type = nil, topic = nil, bitrate = nil, user_limit = nil,
-                           rate_limit_per_user = nil, position = nil, permission_overwrites = nil, parent_id = nil,
-                           nsfw = nil, rtc_region = nil, video_quality_mode = nil, default_auto_archive_duration = nil,
-                           default_reaction_emoji = nil, available_tags = nil, default_sort_order = nil,
-                           default_forum_layout = nil, default_thread_rate_limit_per_user = nil, audit_reason = nil)
+  def create_guild_channel(guild_id, name, type: nil, topic: nil, bitrate: nil, user_limit: nil,
+                           rate_limit_per_user: nil, position: nil, permission_overwrites: nil, parent_id: nil,
+                           nsfw: nil, rtc_region: nil, video_quality_mode: nil, default_auto_archive_duration: nil,
+                           default_reaction_emoji: nil, available_tags: nil, default_sort_order: nil,
+                           default_forum_layout: nil, default_thread_rate_limit_per_user: nil, audit_reason: nil)
     output = {}
     output[:name] = name
     output[:type] = type unless type.nil?
@@ -142,41 +142,40 @@ class DiscordApi
     output[:default_sort_order] = default_sort_order unless default_sort_order.nil?
     output[:default_forum_layout] = default_forum_layout unless default_forum_layout.nil?
     unless default_thread_rate_limit_per_user.nil?
-      output[:default_thread_rate_limit_per_user] =
-        default_thread_rate_limit_per_user
+      output[:default_thread_rate_limit_per_user] = default_thread_rate_limit_per_user
     end
-    url = URI("#{@base_url}/guilds/#{guild_id}/channels")
+    url = "#{@base_url}/guilds/#{guild_id}/channels"
     data = JSON.generate(output)
     headers = { 'Authorization': @authorization_header, 'Content-Type': 'application/json' }
     headers['X-Audit-Log-Reason'] = audit_reason unless audit_reason.nil?
-    response = Net::HTTP.post(url, data, headers)
-    return response unless response.code != '200'
+    response = DiscordApi.post(url, data, headers)
+    return response unless response.status != 200
 
     @logger.error("Could not create guild channel in Guild ID #{guild_id}. Response: #{response.body}")
     response
   end
 
-  def modify_guild_channel_positions(guild_id, channel_id, position = nil, lock_permissions = nil, parent_id = nil)
+  def modify_guild_channel_positions(guild_id, channel_id, position: nil, lock_permissions: nil, parent_id: nil)
     output = {}
     output[:id] = channel_id
     output[:position] = position unless position.nil?
     output[:lock_permissions] = lock_permissions unless lock_permissions.nil?
     output[:parent_id] = parent_id unless parent_id.nil?
-    url = URI("#{@base_url}/guilds/#{guild_id}/channels")
+    url = "#{@base_url}/guilds/#{guild_id}/channels"
     data = JSON.generate(output)
     headers = { 'Authorization': @authorization_header, 'Content-Type': 'application/json' }
-    response = Net::HTTP.patch(url, headers, data)
-    return response unless response.code != '204'
+    response = DiscordApi.patch(url, headers, data)
+    return response unless response.status != 200
 
     @logger.error("Could not modify guild channel positions with Guild ID #{guild_id}. Response: #{response.body}")
     response
   end
 
   def list_active_guild_threads(guild_id)
-    url = URI("#{@base_url}/guilds/#{guild_id}/threads/active")
+    url = "#{@base_url}/guilds/#{guild_id}/threads/active"
     headers = { 'Authorization': @authorization_header }
-    response = Net::HTTP.get(url, headers)
-    return response unless response.code != '200'
+    response = DiscordApi.get(url, headers)
+    return response unless response.status != 200
 
     @logger.error("Could not list active guild threads with Guild ID #{guild_id}. Response: #{response.body}")
     response
@@ -193,15 +192,15 @@ class DiscordApi
     response
   end
 
-  def list_guild_members(guild_id, limit = nil, after = nil)
+  def list_guild_members(guild_id, limit: nil, after: nil)
     query_string_hash = {}
-    query_string_hash[:limit] = limit
-    query_string_hash[:after] = after
+    query_string_hash[:limit] = limit unless limit.nil?
+    query_string_hash[:after] = after unless after.nil?
     query_string = DiscordApi.handle_query_strings(query_string_hash)
-    url = URI("#{@base_url}/guilds/#{guild_id}/members#{query_string}")
+    url = "#{@base_url}/guilds/#{guild_id}/members#{query_string}"
     headers = { 'Authorization': @authorization_header }
-    response = Net::HTTP.get(url, headers)
-    return response unless response.code != '200'
+    response = DiscordApi.get(url, headers)
+    return response unless response.status != 200
 
     @logger.error("Could not list members with Guild ID #{guild_id}. Response: #{response.body}")
     response
@@ -210,7 +209,7 @@ class DiscordApi
   def search_guild_members(guild_id, query, limit = nil)
     query_string_hash = {}
     query_string_hash[:query] = query
-    query_string_hash[:limit] = limit
+    query_string_hash[:limit] = limit unless limit.nil?
     query_string = DiscordApi.handle_query_strings(query_string_hash)
     url = "#{@base_url}/guilds/#{guild_id}/members/search#{query_string}"
     headers = { 'Authorization': @authorization_header }
@@ -221,20 +220,20 @@ class DiscordApi
     response
   end
 
-  def add_guild_member(guild_id, user_id, access_token, nick = nil, roles = nil, mute = nil, deaf = nil)
+  def add_guild_member(guild_id, user_id, access_token, nick: nil, roles: nil, mute: nil, deaf: nil)
     output = {}
     output[:access_token] = access_token
     output[:nick] = nick unless nick.nil?
     output[:roles] = roles unless roles.nil?
     output[:mute] = mute unless mute.nil?
     output[:deaf] = deaf unless deaf.nil?
-    url = URI("#{@base_url}/guilds/#{guild_id}/members/#{user_id}")
+    url = "#{@base_url}/guilds/#{guild_id}/members/#{user_id}"
     data = JSON.generate(output)
     headers = { 'Authorization': @authorization_header, 'Content-Type': 'application/json' }
-    response = Net::HTTP.put(url, data, headers)
-    if response.code == '204'
+    response = DiscordApi.put(url, data, headers)
+    if response.status == 204
       @logger.warn("User with ID #{user_id} is already a member of the guild with ID #{guild_id}.")
-    elsif response.code == '201'
+    elsif response.status == 201
       @logger.info("Added user with ID #{user_id} to guild with ID #{guild_id}.")
     else
       @logger.error("Could not add user with ID #{user_id} to guild with ID #{guild_id}. Response: #{response.body}")
@@ -242,63 +241,63 @@ class DiscordApi
     response
   end
 
-  def modify_guild_member(guild_id, user_id, nick = nil, roles = nil, mute = nil, deaf = nil, channel_id = nil,
-                          communication_disabled_until = nil, flags = nil, audit_reason = nil)
+  def modify_guild_member(guild_id, user_id, nick: nil, roles: nil, mute: nil, deaf: nil, channel_id: nil,
+                          communication_disabled_until: nil, flags: nil, audit_reason: nil)
     output = {}
     output[:nick] = nick unless nick.nil?
     output[:roles] = roles unless roles.nil?
     output[:mute] = mute unless mute.nil?
     output[:deaf] = deaf unless deaf.nil?
     output[:channel_id] = channel_id unless channel_id.nil?
-    output[:communication_disabled_until] = communication_disabled_until
+    output[:communication_disabled_until] = communication_disabled_until unless communication_disabled_until.nil?
     output[:flags] = flags unless flags.nil?
-    url = URI("#{@base_url}/guilds/#{guild_id}/members/#{user_id}")
+    url = "#{@base_url}/guilds/#{guild_id}/members/#{user_id}"
     data = JSON.generate(output)
     headers = { 'Authorization': @authorization_header, 'Content-Type': 'application/json' }
     headers['X-Audit-Log-Reason'] = audit_reason unless audit_reason.nil?
-    response = Net::HTTP.patch(url, data, headers)
-    return response unless response.code != '200'
+    response = DiscordApi.patch(url, data, headers)
+    return response unless response.status != 200
 
     @logger.error("Could not modify guild member with Guild ID #{guild_id} and User ID #{user_id}. " \
     "Response: #{response.body}")
     response
   end
 
-  def modify_current_member(guild_id, nick = nil, audit_reason = nil)
+  def modify_current_member(guild_id, nick: nil, audit_reason: nil)
     output = {}
     output[:nick] = nick unless nick.nil?
-    url = URI("#{@base_url}/guilds/#{guild_id}/members/@me")
+    url = "#{@base_url}/guilds/#{guild_id}/members/@me"
     data = JSON.generate(output)
     headers = { 'Authorization': @authorization_header, 'Content-Type': 'application/json' }
     headers['X-Audit-Log-Reason'] = audit_reason unless audit_reason.nil?
-    response = Net::HTTP.patch(url, data, headers)
-    return response unless response.code != '200'
+    response = DiscordApi.patch(url, data, headers)
+    return response unless response.status != 200
 
     @logger.error("Could not modify current member in guild with Guild ID #{guild_id}. Response: #{response.body}")
     response
   end
 
-  def modify_current_user_nick(guild_id, nick = nil, audit_reason = nil)
+  def modify_current_user_nick(guild_id, nick: nil, audit_reason: nil)
     @logger.warn('The "Modify Current User Nick" endpoint has been deprecated and should not be used!')
     output = {}
     output[:nick] = nick unless nick.nil?
-    url = URI("#{@base_url}/guilds/#{guild_id}/users/@me/nick")
+    url = "#{@base_url}/guilds/#{guild_id}/users/@me/nick"
     data = JSON.generate(output)
     headers = { 'Authorization': @authorization_header, 'Content-Type': 'application/json' }
     headers['X-Audit-Log-Reason'] = audit_reason unless audit_reason.nil?
-    response = Net::HTTP.patch(url, data, headers)
-    return response unless response.code != '200'
+    response = DiscordApi.patch(url, data, headers)
+    return response unless response.status != 200
 
     @logger.error("Could not modify current user nick in guild with ID #{guild_id}. Response: #{response.body}")
     response
   end
 
   def add_guild_member_role(guild_id, user_id, role_id, audit_reason = nil)
-    url = URI("#{@base_url}/guilds/#{guild_id}/members/#{user_id}/roles/#{role_id}")
+    url = "#{@base_url}/guilds/#{guild_id}/members/#{user_id}/roles/#{role_id}"
     headers = { 'Authorization': @authorization_header }
     headers['X-Audit-Log-Reason'] = audit_reason unless audit_reason.nil?
-    response = Net::HTTP.put(url, nil, headers)
-    return response unless response.code != '204'
+    response = DiscordApi.put(url, nil, headers)
+    return response unless response.status != 204
 
     @logger.error("Could not add role with ID #{role_id}, to user with ID #{user_id} in guild with ID #{guild_id}." \
                    " Response: #{response.body}")
@@ -306,20 +305,18 @@ class DiscordApi
   end
 
   def remove_guild_member_role(guild_id, user_id, role_id, audit_reason = nil)
-    url = URI("#{@base_url}/guilds/#{guild_id}/members/#{user_id}/roles/#{role_id}")
+    url = "#{@base_url}/guilds/#{guild_id}/members/#{user_id}/roles/#{role_id}"
     headers = { 'Authorization': @authorization_header }
     headers['x-Audit-Log-Reason'] = audit_reason unless audit_reason.nil?
-    response = Net::HTTP.delete(url, headers)
-    return response unless response.code != '204'
+    response = DiscordApi.delete(url, headers)
+    return response unless response.status != 204
 
     @logger.error("Could not remove role with ID #{role_id}, from user with ID #{user_id}" \
                   " in guild with ID #{guild_id}. Response: #{response.body}")
     response
   end
 
-  # For some reason when i use Net::HTTP in this function it doesn't work, but when i use Faraday it does.
-  # I should probably migrate to Faraday everywhere, but for now just a temporary fix.
-  def remove_guild_member(guild_id, user_id, audit_reason: nil)
+  def remove_guild_member(guild_id, user_id, audit_reason = nil)
     url = "#{@base_url}/guilds/#{guild_id}/members/#{user_id}"
     headers = { 'Authorization' => @authorization_header }
     headers['X-Audit-Log-Reason'] = audit_reason unless audit_reason.nil?
@@ -330,7 +327,7 @@ class DiscordApi
     response
   end
 
-  def get_guild_bans(guild_id, limit = nil, before = nil, after = nil)
+  def get_guild_bans(guild_id, limit: nil, before: nil, after: nil)
     query_string_hash = {}
     query_string_hash[:limit] = limit unless limit.nil?
     query_string_hash[:before] = before unless before.nil?
@@ -339,7 +336,7 @@ class DiscordApi
     url = "#{@base_url}/guilds/#{guild_id}/bans#{query_string}"
     headers = { 'Authorization' => @authorization_header }
     response = DiscordApi.get(url, headers)
-    return response unless response.status != '200'
+    return response unless response.status != 200
 
     @logger.error("Could not get guild bans with Guild ID #{guild_id}. Response: #{response.body}")
     response
@@ -367,12 +364,12 @@ class DiscordApi
       output[:delete_message_days] = delete_message_days
     end
     output[:delete_message_seconds] = delete_message_seconds unless delete_message_seconds.nil?
-    url = URI("#{@base_url}/guilds/#{guild_id}/bans/#{user_id}")
+    url = "#{@base_url}/guilds/#{guild_id}/bans/#{user_id}"
     data = JSON.generate(output)
     headers = { 'Authorization': @authorization_header, 'Content-Type': 'application/json' }
     headers['X-Audit-Log-Reason'] = audit_reason unless audit_reason.nil?
-    response = Net::HTTP.put(url, data, headers)
-    return response unless response.code != '204'
+    response = DiscordApi.put(url, data, headers)
+    return response unless response.status != 204
 
     @logger.error("Could not create guild ban for user with ID #{user_id} in guild with ID #{guild_id}." \
                    " Response: #{response.body}")
@@ -380,29 +377,29 @@ class DiscordApi
   end
 
   def remove_guild_ban(guild_id, user_id, audit_reason = nil)
-    url = URI("#{@base_url}/guilds/#{guild_id}/bans/#{user_id}")
+    url = "#{@base_url}/guilds/#{guild_id}/bans/#{user_id}"
     headers = { 'Authorization': @authorization_header }
     headers['X-Audit-Log-Reason'] = audit_reason unless audit_reason.nil?
-    response = Net::HTTP.delete(url, headers)
-    return response unless response.code != '204'
+    response = DiscordApi.delete(url, headers)
+    return response unless response.status != 204
 
     @logger.error("Could not remove guild ban for user with ID #{user_id} in guild with ID #{guild_id}" \
                   " Response: #{response.body}")
     response
   end
 
-  def bulk_guild_ban(guild_id, user_ids, delete_message_seconds = nil, audit_reason = nil)
+  def bulk_guild_ban(guild_id, user_ids, delete_message_seconds: nil, audit_reason: nil)
     output = {}
     output[:user_ids] = user_ids unless user_ids.nil?
     output[:delete_message_seconds] = delete_message_seconds unless delete_message_seconds.nil?
-    url = URI("#{@base_url}/guilds/#{guild_id}/bulk-ban")
+    url = "#{@base_url}/guilds/#{guild_id}/bulk-ban"
     data = JSON.generate(output)
     headers = { 'Authorization': @authorization_header, 'Content-Type': 'application/json' }
     headers['X-Audit-Log-Reason'] = audit_reason unless audit_reason.nil?
-    response = Net::HTTP.post(url, data, headers)
-    return response unless response.code != '200'
+    response = DiscordApi.post(url, data, headers)
+    return response unless response.status != 200
 
-    if response.code == '500000'
+    if response.status == 500_000
       @logger.error("No users were banned in bulk ban in guild with ID #{guild_id}. Response: #{response.body}")
     else
       @logger.error("Could not bulk ban users in guild with ID #{guild_id}. Response: #{response.body}")
@@ -411,63 +408,67 @@ class DiscordApi
   end
 
   def get_guild_roles(guild_id)
-    url = URI("#{@base_url}/guilds/#{guild_id}/roles")
+    url = "#{@base_url}/guilds/#{guild_id}/roles"
     headers = { 'Authorization': @authorization_header }
-    response = Net::HTTP.get(url, headers)
-    return response unless response.code != '200'
+    response = DiscordApi.get(url, headers)
+    return response unless response.status != 200
 
     @logger.error("Could not get guild roles with Guild ID #{guild_id}. Response: #{response.body}")
     response
   end
 
   def get_guild_role(guild_id, role_id)
-    url = URI("#{@base_url}/guilds/#{guild_id}/roles/#{role_id}")
+    url = "#{@base_url}/guilds/#{guild_id}/roles/#{role_id}"
     headers = { 'Authorization': @authorization_header }
-    response = Net::HTTP.get(url, headers)
-    return response unless response.code != '200'
+    response = DiscordApi.get(url, headers)
+    return response unless response.status != 200
 
     @logger.error("Could not get role with ID #{role_id} in guild with ID #{guild_id}. Response: #{response.body}")
     response
   end
 
-  def create_guild_role(guild_id, name = nil, permissions = nil, color = nil, hoist = nil, icon = nil,
-                        unicode_emoji = nil, mentionable = nil, audit_reason = nil)
+  def create_guild_role(guild_id, name: nil, permissions: nil, color: nil, colors: nil, hoist: nil, icon: nil,
+                        unicode_emoji: nil, mentionable: nil, audit_reason: nil)
     output = {}
     output[:name] = name unless name.nil?
     output[:permissions] = permissions unless permissions.nil?
-    output[:color] = color unless color.nil?
+    unless color.nil?
+      @logger.warn('The "color" parameter has been deprecated and should not be used!')
+      output[:color] = color
+    end
+    output[:colors] = colors unless colors.nil?
     output[:hoist] = hoist unless hoist.nil?
     output[:icon] = icon unless icon.nil?
     output[:unicode_emoji] = unicode_emoji unless unicode_emoji.nil?
     output[:mentionable] = mentionable unless mentionable.nil?
-    url = URI("#{@base_url}/guilds/#{guild_id}/roles")
+    url = "#{@base_url}/guilds/#{guild_id}/roles"
     data = JSON.generate(output)
     headers = { 'Authorization': @authorization_header, 'Content-Type': 'application/json' }
     headers['X-Audit-Log-Reason'] = audit_reason unless audit_reason.nil?
-    response = Net::HTTP.post(url, data, headers)
-    return response unless response.code != '200'
+    response = DiscordApi.post(url, data, headers)
+    return response unless response.status != 200
 
     @logger.error("Could not create guild role in guild with ID #{guild_id}. Response: #{response.body}")
     response
   end
 
-  def modify_guild_role_positions(guild_id, id, position = nil, audit_reason = nil)
+  def modify_guild_role_positions(guild_id, id, position: nil, audit_reason: nil)
     output = {}
     output[:id] = id
     output[:position] = position unless position.nil?
-    url = URI("#{@base_url}/guilds/#{guild_id}/roles")
+    url = "#{@base_url}/guilds/#{guild_id}/roles"
     data = JSON.generate(output)
     headers = { 'Authorization': @authorization_header, 'Content-Type': 'application/json' }
     headers['X-Audit-Log-Reason'] = audit_reason unless audit_reason.nil?
-    response = Net::HTTP.patch(url, data, headers)
-    return response unless response.code != '200'
+    response = DiscordApi.patch(url, data, headers)
+    return response unless response.status != 200
 
     @logger.error("Could not modify guild role positions in guild with ID #{guild_id}. Response: #{response.body}")
     response
   end
 
-  def modify_guild_role(guild_id, role_id, name = nil, permissions = nil, color = nil, hoist = nil, icon = nil,
-                        unicode_emoji = nil, mentionable = nil, audit_reason = nil)
+  def modify_guild_role(guild_id, role_id, name: nil, permissions: nil, color: nil, hoist: nil, icon: nil,
+                        unicode_emoji: nil, mentionable: nil, audit_reason: nil)
     output = {}
     output[:name] = name unless name.nil?
     output[:permissions] = permissions unless permissions.nil?
@@ -476,12 +477,12 @@ class DiscordApi
     output[:icon] = icon unless icon.nil?
     output[:unicode_emoji] = unicode_emoji unless unicode_emoji.nil?
     output[:mentionable] = mentionable unless mentionable.nil?
-    url = URI("#{@base_url}/guilds/#{guild_id}/roles/#{role_id}")
+    url = "#{@base_url}/guilds/#{guild_id}/roles/#{role_id}"
     data = JSON.generate(output)
     headers = { 'Authorization': @authorization_header, 'Content-Type': 'application/json' }
     headers['X-Audit-Log-Reason'] = audit_reason unless audit_reason.nil?
-    response = Net::HTTP.patch(url, data, headers)
-    return response unless response.code != '200'
+    response = DiscordApi.patch(url, data, headers)
+    return response unless response.status != 200
 
     @logger.error("Could not modify guild role with ID #{role_id} in guild with ID #{guild_id}." \
                  " Response: #{response.body}")
@@ -490,45 +491,45 @@ class DiscordApi
 
   def modify_guild_mfa_level(guild_id, level, audit_reason = nil)
     output = {}
-    output[:level] = level unless level.nil?
-    url = URI("#{@base_url}/guilds/#{guild_id}/mfa")
+    output[:level] = level
+    url = "#{@base_url}/guilds/#{guild_id}/mfa"
     data = JSON.generate(output)
     headers = { 'Authorization': @authorization_header, 'Content-Type': 'application/json' }
     headers['X-Audit-Log-Reason'] = audit_reason unless audit_reason.nil?
-    response = Net::HTTP.post(url, data, headers)
-    return unless response != JSON.generate({ level: level }) # might not be the correct way to check for success
+    response = DiscordApi.post(url, data, headers)
+    return unless response.status != 200
 
     @logger.error("Failed to modify guild MFA level. Response: #{response.body}")
     response
   end
 
   def delete_guild_role(guild_id, role_id, audit_reason = nil)
-    url = URI("#{@base_url}/guilds/#{guild_id}/roles/#{role_id}")
+    url = "#{@base_url}/guilds/#{guild_id}/roles/#{role_id}"
     headers = { 'Authorization': @authorization_header }
     headers['X-Audit-Log-Reason'] = audit_reason unless audit_reason.nil?
-    response = Net::HTTP.delete(url, headers)
-    return response unless response.code != '204'
+    response = DiscordApi.delete(url, headers)
+    return response unless response.status != 204
 
     @logger.error("Failed to delete guild role. Response: #{response.body}")
     response
   end
 
-  def get_guild_prune_count(guild_id, days = nil, include_roles = nil)
+  def get_guild_prune_count(guild_id, days: nil, include_roles: nil)
     query_string_hash = {}
     query_string_hash[:days] = days unless days.nil?
     query_string_hash[:include_roles] = include_roles unless include_roles.nil?
     query_string = DiscordApi.handle_query_strings(query_string_hash)
-    url = URI("#{@base_url}/guilds/#{guild_id}/prune#{query_string}")
+    url = "#{@base_url}/guilds/#{guild_id}/prune#{query_string}"
     headers = { 'Authorization': @authorization_header }
-    response = Net::HTTP.get(url, headers)
-    return response unless response.code != '200'
+    response = DiscordApi.get(url, headers)
+    return response unless response.status != 200
 
     @logger.error("Failed to get guild prune count. Response: #{response.body}")
     response
   end
 
-  def begin_guild_prune(guild_id, days = 7, include_roles = 'none', reason = nil, audit_reason = nil,
-                        compute_prune_count: true)
+  def begin_guild_prune(guild_id, days: nil, compute_prune_count: nil, include_roles: nil, reason: nil,
+                        audit_reason: nil)
     output = {}
     output[:days] = days unless days.nil?
     output[:compute_prune_count] = compute_prune_count unless compute_prune_count.nil?
@@ -537,46 +538,46 @@ class DiscordApi
       @logger.warn('The "reason" parameter has been deprecated and should not be used!')
       output[:reason] = reason
     end
-    url = URI("#{@base_url}/guilds/#{guild_id}/prune")
+    url = "#{@base_url}/guilds/#{guild_id}/prune"
     data = JSON.generate(output)
     headers = { 'Authorization': @authorization_header, 'Content-Type': 'application/json' }
     headers['X-Audit-Log-Reason'] = audit_reason unless audit_reason.nil?
-    response = Net::HTTP.post(url, data, headers)
-    return response unless response.code != '200'
+    response = DiscordApi.post(url, data, headers)
+    return response unless response.status != 200
 
     @logger.error("Failed to begin guild prune. Response: #{response.body}")
     response
   end
 
   def get_guild_voice_regions(guild_id)
-    url = URI("#{@base_url}/guilds/#{guild_id}/regions")
+    url = "#{@base_url}/guilds/#{guild_id}/regions"
     headers = { 'Authorization': @authorization_header }
-    response = Net::HTTP.get(url, headers)
-    return response unless response.code != '200'
+    response = DiscordApi.get(url, headers)
+    return response unless response.status != 200
 
     @logger.error("Failed to get guild voice regions. Response: #{response.body}")
     response
   end
 
   def get_guild_invites(guild_id)
-    url = URI("#{@base_url}/guilds/#{guild_id}/invites")
+    url = "#{@base_url}/guilds/#{guild_id}/invites"
     headers = { 'Authorization': @authorization_header }
-    response = Net::HTTP.get(url, headers)
-    return response unless response.code != '200'
+    response = DiscordApi.get(url, headers)
+    return response unless response.status != 200
 
     @logger.error("Failed to get guild invites. Response: #{response.body}")
     response
   end
 
   def get_guild_integrations(guild_id)
-    url = URI("#{@base_url}/guilds/#{guild_id}/integrations")
+    url = "#{@base_url}/guilds/#{guild_id}/integrations"
     headers = { 'Authorization': @authorization_header }
-    response = Net::HTTP.get(url, headers)
-    unless response.code != '200'
+    response = DiscordApi.get(url, headers)
+    if response.status == 200
       if JSON.parse(response.body).length == 50
         @logger.warn('The endpoint returned 50 integrations, which means there could be more integrations not shown.')
       end
-      response
+      return response
     end
 
     @logger.error("Failed to get guild integrations. Response: #{response.body}")
@@ -584,59 +585,58 @@ class DiscordApi
   end
 
   def delete_guild_integration(guild_id, integration_id, audit_reason = nil)
-    url = URI("#{@base_url}/guilds/#{guild_id}/integrations/#{integration_id}")
+    url = "#{@base_url}/guilds/#{guild_id}/integrations/#{integration_id}"
     headers = { 'Authorization': @authorization_header }
     headers['X-Audit-Log-Reason'] = audit_reason unless audit_reason.nil?
-    response = Net::HTTP.delete(url, headers)
-    return response unless response.code != '204'
+    response = DiscordApi.delete(url, headers)
+    return response unless response.status != 204
 
     @logger.error("Failed to delete guild integration. Response: #{response.body}")
     response
   end
 
   def get_guild_widget_settings(guild_id)
-    url = URI("#{@base_url}/guilds/#{guild_id}/widget")
+    url = "#{@base_url}/guilds/#{guild_id}/widget"
     headers = { 'Authorization': @authorization_header }
-    response = Net::HTTP.get(url, headers)
-    return response unless response.code != '200'
+    response = DiscordApi.get(url, headers)
+    return response unless response.status != 200
 
     @logger.error("Failed to get guild widget settings. Response: #{response.body}")
     response
   end
 
-  def modify_guild_widget(guild_id, enabled, channel_id = nil, audit_reason = nil)
+  def modify_guild_widget(guild_id, enabled, channel_id, audit_reason: nil)
     output = {}
     output[:enabled] = enabled
-    output[:channel_id] = channel_id unless channel_id.nil?
-    url = URI("#{@base_url}/guilds/#{guild_id}/widget")
+    output[:channel_id] = channel_id
+    url = "#{@base_url}/guilds/#{guild_id}/widget"
     data = JSON.generate(output)
     headers = { 'Authorization': @authorization_header, 'Content-Type': 'application/json' }
     headers['X-Audit-Log-Reason'] = audit_reason unless audit_reason.nil?
-    response = Net::HTTP.patch(url, data, headers)
-    return response unless response.code != '200'
+    response = DiscordApi.patch(url, data, headers)
+    return response unless response.status != 200
 
     @logger.error("Failed to modify guild widget. Response: #{response.body}")
     response
   end
 
   def get_guild_wiget(guild_id)
-    url = URI("#{@base_url}/guilds/#{guild_id}/widget.json")
+    url = "#{@base_url}/guilds/#{guild_id}/widget.json"
     headers = { 'Authorization': @authorization_header }
-    response = Net::HTTP.get(url, headers)
-    return response unless response.code != '200'
+    response = DiscordApi.get(url, headers)
+    return response unless response.status != 200
 
     @logger.error("Failed to get guild widget. Response: #{response.body}")
     response
   end
 
   def get_guild_vanity_url(guild_id)
-    url = URI("#{@base_url}/guilds/#{guild_id}/vanity-url")
+    url = "#{@base_url}/guilds/#{guild_id}/vanity-url"
     headers = { 'Authorization': @authorization_header }
-    response = Net::HTTP.get(url, headers)
-    return response unless response.code != '200'
+    response = DiscordApi.get(url, headers)
+    return response unless response.status != 200
 
-    @logger.error('Failed to get guild vanity URL, perhaps you do not have the MANAGE_GUILD permission. ' \
-                 "If you only want to get the Vanity URL, use the get_guild endpoint. Response: #{response.body}")
+    @logger.error("Failed to get guild vanity URL. Response: #{response.body}")
     response
   end
 
@@ -649,93 +649,94 @@ class DiscordApi
       nil
     elsif true_keys.size == 1
       style = true_keys.first.to_s
+    else
+      style = nil
     end
 
     query_string_hash = {}
     query_string_hash[:style] = style unless style.nil?
     query_string = DiscordApi.handle_query_strings(query_string_hash)
 
-    url = URI("#{@base_url}/guilds/#{guild_id}/widget.png#{query_string}")
-    response = Net::HTTP.get(url)
-    return unless response.code != '200'
+    url = "#{@base_url}/guilds/#{guild_id}/widget.png#{query_string}"
+    response = DiscordApi.get(url)
+    return unless response.status != 200
 
     @logger.error("Failed to get guild widget image. Response: #{response.body}")
     response
   end
 
   def get_guild_welcome_screen(guild_id)
-    url = URI("#{@base_url}/guilds/#{guild_id}/welcome-screen")
+    url = "#{@base_url}/guilds/#{guild_id}/welcome-screen"
     headers = { 'Authorization': @authorization_header }
-    response = Net::HTTP.get(url, headers)
-    return response unless response.code != '200'
+    response = DiscordApi.get(url, headers)
+    return response unless response.status != 200
 
     @logger.error("Failed to get guild welcome screen. Response: #{response.body}")
     response
   end
 
-  def modify_guild_welcome_screen(guild_id, enabled = nil, welcome_channels = nil, description = nil,
-                                  audit_reason = nil)
+  def modify_guild_welcome_screen(guild_id, enabled: nil, welcome_channels: nil, description: nil,
+                                  audit_reason: nil)
     output = {}
     output[:enabled] = enabled unless enabled.nil?
     output[:welcome_channels] = welcome_channels unless welcome_channels.nil?
     output[:description] = description unless description.nil?
-    url = URI("#{@base_url}/guilds/#{guild_id}/welcome-screen")
+    url = "#{@base_url}/guilds/#{guild_id}/welcome-screen"
     data = JSON.generate(output)
     headers = { 'Authorization': @authorization_header, 'Content-Type': 'application/json' }
     headers['X-Audit-Log-Reason'] = audit_reason unless audit_reason.nil?
-    response = Net::HTTP.patch(url, data, headers)
-    return response unless response.code != '200'
+    response = DiscordApi.patch(url, data, headers)
+    return response unless response.status != 200
 
     @logger.error("Failed to modify guild welcome screen. Response: #{response.body}")
     response
   end
 
   def get_guild_onboarding(guild_id)
-    url = URI("#{@base_url}/guilds/#{guild_id}/onboarding")
+    url = "#{@base_url}/guilds/#{guild_id}/onboarding"
     headers = { 'Authorization': @authorization_header }
-    response = Net::HTTP.get(url, headers)
-    return response unless response.code != '200'
+    response = DiscordApi.get(url, headers)
+    return response unless response.status != 200
 
     @logger.error("Failed to get guild onboarding. Response: #{response.body}")
     response
   end
 
-  def modify_guild_onboarding(guild_id, prompts, default_channel_ids, enabled, mode, audit_reason = nil)
+  def modify_guild_onboarding(guild_id, prompts: nil, default_channel_ids: nil, enabled: nil, mode: nil,
+                              audit_reason: nil)
     output = {}
-    output[:prompts] = prompts
-    output[:default_channel_ids] = default_channel_ids
-    output[:enabled] = enabled
-    output[:mode] = mode
-    url = URI("#{@base_url}/guilds/#{guild_id}/onboarding")
+    output[:prompts] = prompts unless prompts.nil?
+    output[:default_channel_ids] = default_channel_ids unless default_channel_ids.nil?
+    output[:enabled] = enabled unless enabled.nil?
+    output[:mode] = mode unless mode.nil?
+    url = "#{@base_url}/guilds/#{guild_id}/onboarding"
     data = JSON.generate(output)
     headers = { 'Authorization': @authorization_header, 'Content-Type': 'application/json' }
     headers['X-Audit-Log-Reason'] = audit_reason unless audit_reason.nil?
-    response = Net::HTTP.put(url, data, headers)
-    return response unless response.code != '200'
+    response = DiscordApi.put(url, data, headers)
+    return response unless response.status != 200
 
     @logger.error("Failed to modify guild onboarding. Response: #{response.body}")
     response
   end
 
-  def modify_guild_incident_actions(guild_id, invites_disabled_until = nil, dms_disabled_until = nil)
+  def modify_guild_incident_actions(guild_id, invites_disabled_until: nil, dms_disabled_until: nil)
     output = {}
-    # if only discord wouldn't of have required to set a variable to null for some functionality
     if invites_disabled_until == false
       output[:invites_disabled_until] = nil
-    elsif !invites_disabled_until.nil? && invites_disabled_until != false
+    elsif !invites_disabled_until.nil?
       output[:invites_disabled_until] = invites_disabled_until
     end
     if dms_disabled_until == false
       output[:dms_disabled_until] = nil
-    elsif !dms_disabled_until.nil? && dms_disabled_until != false
+    elsif !dms_disabled_until.nil?
       output[:dms_disabled_until] = dms_disabled_until
     end
-    url = URI("#{@base_url}/guilds/#{guild_id}/incident-actions")
+    url = "#{@base_url}/guilds/#{guild_id}/incident-actions"
     data = JSON.generate(output)
     headers = { 'Authorization': @authorization_header, 'Content-Type': 'application/json' }
-    response = Net::HTTP.put(url, data, headers)
-    # same problem with as above
-    return response unless response.code != '200'
+    response = DiscordApi.put(url, data, headers)
+    return response unless response.status != 200
 
     @logger.error("Failed to modify guild incident actions. Response: #{response.body}")
     response