rublox 0.2.0 → 0.3.0

data/lib/rublox/models/presence.rb

@@ -1,98 +1,59 @@
 # frozen_string_literal: true
 
-require "time"
+require "rublox/derive/model"
+require "rublox/bases/base_user"
 
 module Rublox
-  # The state of the presence.
-  #
-  # Can be offline, online/on the website, playing a game, developing on studio.
-  module PresenceType
-    # The user is/was offline.
-    OFFLINE = :Offline
-    # The user is/was online (this also applies to the website).
-    ONLINE = :Online
-    # The user is/was playing a game.
-    GAME = :"In game"
-    # The user is/was developing on studio.
-    STUDIO = :"In Studio"
-
-    # @!visibility private
-    PRESENCE_MAP = [
-      OFFLINE,
-      ONLINE,
-      GAME,
-      STUDIO
-    ].freeze
-
-    # Convert the Roblox PresenceType enum response to rublox's PresenceType
-    # equivalent.
-    # @!visibility private
-    # @param enum [Integer]
-    # @return [Symbol]
-    def self.enum_to_presence_type(enum)
-      PRESENCE_MAP[enum]
-    end
-  end
-
-  # @note This class is handled internally by the public interface such as
-  #   {Client#user_presence_from_id}. You should not be creating it yourself.
-  # The {Presence} class corresponds to a response you can get via
-  # https://presence.roblox.com/v1/presence/users. You can use it to get information
-  # about the presence states of users.
-  class Presence
-    # @return [PresenceType] the current presence type
-    attr_reader :presence_type
-
-    # @return [PresenceType] the last presence type of the user
-    attr_reader :last_presence_type
-
-    # @note Unlike it sounds, this is not a numerical ID like of a user. It's a
-    # randomly generated string with hexadecimal numbers containing the server's
-    # job ID (which looks like "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX"), it can be
-    # also accessed in-game via the game.JobId property.
-    # @return [String, nil] the job ID of the game last played by the user.
-    attr_reader :game_job_id
-
-    # @return [Time] the date at which the user was last online
-    attr_reader :last_online_date
-
-    def initialize(data, client)
-      @presence_type = PresenceType.enum_to_presence_type(data["userPresenceType"])
-      @last_location = data["lastLocation"]
-      @place_id = data["placeId"]
-      @root_place_id = data["rootPlaceId"]
-      @game_job_id = data["gameId"]
-      @universe_id = data["universeId"]
-      @user_id = data["userId"]
-      @last_online_date = Time.iso8601(data["lastOnline"])
-
-      @client = client
-    end
-
-    # @todo add Place class
-    # @return [Place, nil] the place last visited by the user, can be nil if the
-    #   user has never played a game
-    def place
-      return unless @place_id
-    end
-
-    # @todo add Place class
-    # @return [Place, nil] the root of the place last visited by the user, can
-    #   be nil if the user has never played a game
-    def root_place
-      return unless @root_place_id
-    end
-
-    # @todo add Universe class
-    # @return [Universe, nil] the universe of the place last visited by the user,
-    #   can be nil if the user has never played a game
-    def universe
-      return unless @universe_id
-    end
-
-    # @return [FullUser] the user tied to the presence
-    def user
-      @client.user_from_id(@user_id)
-    end
-  end
+	module Models
+		module PresenceType
+			OFFLINE = :offline
+			ONLINE = :online
+			IN_GAME = :in_game
+			IN_STUDIO = :in_studio
+
+			PRESENCE_MAP = [
+				OFFLINE,
+				ONLINE,
+				IN_GAME,
+				IN_STUDIO
+			].freeze
+			private_constant :PRESENCE_MAP
+
+			# @!visibility private
+			def self.get(enum)
+				PRESENCE_MAP[enum]
+			end
+		end
+
+		class Presence
+			include Derive::Model
+
+			# @return [PresenceType]
+			attr_reader :user_presence_type
+			# @return [String]
+			attr_reader :last_location
+			# attr_reader :place_id
+			# attr_reader :root_place_id
+			# attr_reader :game_id
+			# attr_reader :universe_id
+			# @return [Bases::BaseUser]
+			attr_reader :user
+			# @return [Time]
+			attr_reader :last_online
+
+			# @!visibility private
+			def initialize(data)
+				@user_presence_type = PresenceType.get(data["userPresenceType"])
+				@last_location = data["lastLocation"]
+				# @place_id = data["placeId"]
+				# @root_place_id = data["rootPlaceId"]
+				# @game_id = data["gameId"]
+				# @universe_id = data["universeId"]
+				@user = Bases::BaseUser.new(data["userId"])
+				@last_online = Time.iso8601(data["lastOnline"])
+
+				@id = @user_id
+			end
+		end
+	end
 end

data/lib/rublox/models/skinny_user.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "rublox/derive/user"
+
+module Rublox
+	module Models
+		class SkinnyUser
+			include Derive::User
+
+			# @return [Integer]
+			attr_reader :id
+			# @return [String]
+			attr_reader :name
+			# @return [String]
+			attr_reader :display_name
+			# @return [Boolean]
+			attr_reader :has_verified_badge
+
+			# @!visibility private
+			def initialize(data)
+				@id = data["id"] || data["userId"]
+				@name = data["name"] || data["username"]
+				@display_name = data["displayName"]
+				@has_verified_badge = data["hasVerifiedBadge"]
+			end
+		end
+	end
+end

data/lib/rublox/util/api_helper.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "http"
+require "json"
+
+require "rublox/util/errors"
+
+module Rublox
+	module APIHelper
+		@client = HTTP::Client.new
+
+		# @!visibility private
+		def self.roblosecurity=(roblosecurity)
+			@client = @client.cookies(
+				{
+					".ROBLOSECURITY" => roblosecurity
+				}
+			)
+		end
+
+		def self.get(url, *args)
+			request(:get, url, *args)
+		end
+
+		def self.post(url, *args)
+			request(:post, url, *args)
+		end
+
+		def self.patch(url, *args)
+			request(:patch, url, *args)
+		end
+
+		def self.delete(url, *args)
+			request(:delete, url, *args)
+		end
+
+		def self.request(method, url, *args)
+			response = @client.request(method, url, *args)
+			case response.status
+			when 200
+				JSON.parse(response.body)
+			when 403
+				if JSON.parse(response.body).any? { |error| error.code.zero? }
+					@client = @client.headers(
+						{
+							"x-csrf-token" => response.headers
+						}
+					)
+				end
+			when 401
+				raise Errors::InvalidROBLOSECURITYError
+			else
+				raise Errors::UnhandledStatusCodeError.new(response, get_errors_from_response(response))
+			end
+		end
+
+		def self.get_errors_from_response(response)
+			body = JSON.parse(response.body)
+		rescue JSON::ParserError
+			"\ncould not parse errors, raw body:\n#{response.body}\n"
+		else
+			body["errors"].reduce("") do |error_message, error|
+				error_message + "\tCode: #{error['code']}\n\tMessage: #{error['message']}\n\n"
+			end
+		end
+
+		private_class_method :request, :get_errors_from_response
+	end
+end

data/lib/rublox/util/errors.rb

@@ -1,109 +1,44 @@
 # frozen_string_literal: true
 
 module Rublox
-  # This module contains errors that can be raised by rublox methods.
-  module Errors
-    # Exception raised when a user cannot be found.
-    class UserNotFoundError < StandardError
-      # @return [Integer, "(no ID information provided)"] the given user's ID
-      attr_reader :user_id
-
-      # @return [String, "(no username information provided)"] the given user's
-      #   username
-      attr_reader :user_username
-
-      # @param user_id [Integer]
-      # @param username [String, nil]
-      def initialize(
-        user_id = "(no ID information provided)",
-        username = "(no username information provided)"
-      )
-        @user_id = user_id
-        @user_username = username
-        super("The user of ID #{user_id} and username #{username} could not be found.")
-      end
-    end
-
-    # Exception raised when a group cannot be found.
-    class GroupNotFoundError < StandardError
-      # @return [Integer] the given group's ID
-      attr_reader :group_id
-
-      # @param group_id [Integer]
-      def initialize(group_id)
-        @group_id = group_id
-        super("The group of ID #{group_id} could not be found.")
-      end
-    end
-
-    # Exception raised when a user's presence cannot be found.
-    class PresenceNotFoundError < StandardError
-      # @return [Integer] the presence user's ID
-      attr_reader :user_id
-
-      def initialize(user_id)
-        @user_id = user_id
-        super("The presence of the user with ID #{user_id} could not be found.")
-      end
-    end
-
-    # Exception raised when a user is not part of a group.
-    class MemberNotFoundError < StandardError
-      # @return [Integer] the given user's ID
-      attr_reader :user_id
-
-      # @return [Integer] the given group's ID
-      attr_reader :group_id
-
-      # @param id [Integer]
-      # @param group_id [Integer]
-      def initialize(id, group_id)
-        @user_id = id
-        @group_id = group_id
-        super("The user of ID #{id} is not part of this group of ID #{group_id}")
-      end
-    end
-
-    # Exception raised when a role doesn't exist.
-    class RoleNotFoundError < StandardError
-      # @return [Integer] the given role's ID
-      attr_reader :role_id
-
-      # @return [Integer] the given group's ID
-      attr_reader :group_id
-
-      # @param role_id [Integer]
-      # @param group_id [Integer]
-      def initialize(role_id, group_id)
-        @role_id = role_id
-        @group_id = group_id
-        super("The role of ID #{role_id} does not exist in group of ID #{group_id}.")
-      end
-    end
-
-    # Exception raised when an unhandled status code is returned.
-    class UnhandledStatusCodeError < StandardError
-      # @return [HTTP::Response::Status] the unhandled status code
-      attr_reader :status_code
-
-      # @return [String] a string containing all the errors returned by the API
-      #   neatly formatted
-      attr_reader :errors
-
-      # @param status_code [Integer]
-      # @param errors [String, nil]
-      def initialize(status_code, errors = "")
-        super("Unhandled status code #{status_code}.\nRoblox errors:\n#{errors}")
-        @status_code = status_code
-        @errors = errors
-      end
-    end
-
-    # Exception raised when an invalid .ROBLOSECURITY cookie is used.
-    class InvalidROBLOSECURITYError < StandardError
-      def initialize
-        super("A valid .ROBLOSECURITY cookie needs to be passed to Rublox's constructor for this action.")
-      end
-    end
-  end
+	module Errors
+		# This error is raised when a user couldn't be found
+		class UserNotFoundError < StandardError
+		end
+
+		# This error is raised when a group couldn't be found
+		class GroupNotFoundError < StandardError
+		end
+
+		# This error is raised when one of the provided user IDs are invalid, or if a user ID is repeated
+		class PresenceRequestError < StandardError
+			# @!visibility private
+			def initialize
+				super("An invalid or repeated user ID was provided")
+			end
+		end
+
+		# This error is raised when an error returned by the Roblox API should be dealt by the user
+		class UnhandledStatusCodeError < StandardError
+			# @return [HTTP::Response] the response object
+			attr_reader :response
+			# @return [String] a formatted string of errors returned by the Roblox API
+			attr_reader :errors
+
+			# @!visibility private
+			def initialize(response, errors)
+				super("Unhandled status code #{response.status}.\nRoblox errors:\n#{errors}")
+				@response = response
+				@errors = errors
+			end
+		end
+
+		# This error is raised when a method that requires authenticated is called without a valid .ROBLOSECURITY cookie set
+		class InvalidROBLOSECURITYError < StandardError
+			# @!visibility private
+			def initialize
+				super("A valid .ROBLOSECURITY cookie needs to be passed to Rublox for this action.")
+			end
+		end
+	end
 end

data/lib/rublox.rb

@@ -1,136 +1,89 @@
 # frozen_string_literal: true
 
-require "http"
-
-require "rublox/version"
-require "rublox/util/http_client"
-require "rublox/util/cache"
+require "rublox/util/api_helper"
+require "rublox/util/errors"
 require "rublox/models/full_user"
-require "rublox/models/full_group"
+require "rublox/models/skinny_user"
 require "rublox/models/presence"
+require "rublox/bases/base_user"
+require "rublox/bases/base_group"
 
 # rublox is a Roblox web API wrapper written in Ruby. It aims to provide an
 # object oriented interface to get and modify data from Roblox's web API.
-#
-# Repository: https://github.com/roblox-api-wrappers/rublox
-#
 # Docs: https://rubydoc.info/gems/rublox
 module Rublox
-  # The {Client} object is the gateway to the API. Tt supplies methods that
-  # return classes modeled after the interactions you can do with the API.
-  #
-  # Initialize the client with a .ROBLOSECURITY cookie if you need functionality
-  # that requires it.
-  # @example
-  #   require "rublox"
-  #   # without a cookie
-  #   client = Rublox::Client.new
-  #   # with a cookie
-  #   client = Rublox::Client.new("_|WARNING:-DO-NOT-SHARE-THIS.--Sharing-this ...")
-  class Client
-    # @note The HTTP client should only be used when there are no methods
-    #   provided by the library to achieve what you want.
-    # @return [HTTPClient]
-    attr_reader :http_client
+	# Sets the .ROBLOSECURITY cookie to send authenticated requests
+	def self.roblosecurity=(roblosecurity)
+		APIHelper.roblosecurity = roblosecurity
+	end
+
+	# Returns the current authenticated user
+	def self.authenticated_user
+		Models::SkinnyUser.new(APIHelper.get("https://users.roblox.com/v1/users/authenticated"))
+	end
+
+	# Returns a BaseUser
+	def self.base_user(id)
+		Bases::BaseUser.new(id)
+	end
+
+	# Returns a user
+	def self.user_from_id(id)
+		Models::FullUser.new(APIHelper.get("https://users.roblox.com/v1/users/#{id}"))
+	rescue Errors::UnhandledStatusCodeError => e
+		raise Errors::UserNotFoundError, cause: nil if e.response.status == 404
 
-    # Initialize the client with a .ROBLOSECURITY cookie if you require functionality
-    # that needs it.
-    # @example
-    #   require "rublox"
-    #   # without a cookie
-    #   client = Rublox::Client.new
-    #   # with a cookie
-    #   client = Rublox::Client.new("_|WARNING:-DO-NOT-SHARE-THIS.--Sharing-this ...")
-    # @param roblosecurity [String, nil] a valid .ROBLOSECURITY cookie
-    def initialize(roblosecurity = "")
-      @http_client = HTTPClient.new(roblosecurity)
-    end
+		raise
+	end
 
-    # @example
-    #   client = Rublox::Client.new
-    #   user = client.user_from_id(1)
-    #   puts user.username # -> Roblox
-    # @param id [Integer] the user's ID
-    # @return [FullUser] a model of the user specified by the ID
-    def user_from_id(id)
-      user = Cache.get(Cache::USER, id)
-      return user if user
+	def self.users_from_ids(ids, exclude_banned_users: false)
+		APIHelper.post(
+			"https://users.roblox.com/v1/users",
+			json: {
+				userIds: ids,
+				excludeBannedUsers: exclude_banned_users
+			}
+		)["data"].map { |data| Models::SkinnyUser.new(data) }
+	end
 
-      data = @http_client.get(
-        URL.endpoint("users", "v1/users/#{id}")
-      )
-    rescue Errors::UnhandledStatusCodeError
-      raise Errors::UserNotFoundError, id
-    else
-      user = FullUser.new(
-        data,
-        self
-      )
-      Cache.set(Cache::USER, id, user)
+	def self.users_from_usernames(usernames, exclude_banned_users: false)
+		APIHelper.post(
+			"https://users.roblox.com/v1/usernames/users",
+			json: {
+				usernames: usernames,
+				excludeBannedUsers: exclude_banned_users
+			}
+		)["data"].map { |data| Models::SkinnyUser.new(data) }
+	end
 
-      user
-    end
+	def self.user_from_username(username, exclude_banned_users: false)
+		users_from_usernames([username], exclude_banned_users: exclude_banned_users)[0] or raise Errors::UserNotFoundError
+	end
 
-    # @note This method sends 2 requests, use {#user_from_id} if possible.
-    # @example
-    #   client = Rublox::Client.new
-    #   user = client.user_from_username("Roblox")
-    #   puts user.id # -> 1
-    # @param username [String] the user's username
-    # @return [FullUser] a model of the user specified by the ID
-    def user_from_username(username)
-      data = @http_client.post(
-        URL.endpoint("users", "/v1/usernames/users"),
-        json: {
-          usernames: [username],
-          excludeBannedUsers: false
-        }
-      )["data"]
-      raise Errors::UserNotFoundError.new(nil, username) if data.empty?
+	def self.base_group(id)
+		Bases::BaseGroup.new(id)
+	end
 
-      user_from_id(
-        data[0]["id"]
-      )
-    end
+	def self.group_from_id(id)
+		APIHelper.get("https://groups.roblox.com/v1/groups/#{id}")
+	rescue Errors::UnhandledStatusCodeError => e
+		raise Errors::GroupNotFoundError, cause: nil if e.response.status == 400
 
-    # @example
-    #   client = Rublox::Client.new
-    #   group = client.group_from_id(1)
-    #   puts group.name # -> RobloHunks
-    # @param id [Integer] the groups's ID
-    # @return [FullGroup] a model of the group specified by the ID
-    def group_from_id(id)
-      group = Cache.get(Cache::GROUP, id)
-      return group if group
+		raise
+	end
 
-      data = @http_client.get(
-        URL.endpoint("groups", "v1/groups/#{id}")
-      )
-    rescue Errors::UnhandledStatusCodeError
-      raise Errors::GroupNotFoundError, id
-    else
-      group = FullGroup.new(data, self)
-      Cache.set(Cache::GROUP, id, group)
+	def self.user_presences_from_ids(ids)
+		APIHelper.post(
+			"https://presence.roblox.com/v1/presence/users",
+			json: { userIds: ids }
+		)["userPresences"].map { |data| Models::Presence.new(data) }
+	rescue Errors::UnhandledStatusCodeError => e
+		raise Errors::PresenceRequestError, cause: nil if e.response.status == 400
 
-      group
-    end
+		raise
+	end
 
-    # @param id [Integer] the user's ID
-    # @return [Presence] a model of the presence specified by the user's ID
-    def user_presence_from_id(id)
-      data = http_client.post(
-        URL.endpoint("presence", "v1/presence/users"),
-        json: {
-          userIds: [id]
-        }
-      )
-    rescue Errors::UnhandledStatusCodeError
-      raise Errors::PresenceNotFoundError, id
-    else
-      Presence.new(
-        data["userPresences"][0],
-        self
-      )
-    end
-  end
+	def self.user_presence_from_id(id)
+		user_presences_from_ids([id])[0]
+	end
 end

data/rublox.gemspec

@@ -1,32 +1,30 @@
 # frozen_string_literal: true
 
-require_relative "lib/rublox/version"
-
 Gem::Specification.new do |spec|
-  spec.name = "rublox"
-  spec.version = Rublox::VERSION
-  spec.authors = %w[Zamdie Keef]
-  spec.email = "rorg.devv@gmail.com"
-  spec.summary = "A Roblox web API wrapper written in Ruby"
-  spec.description = "This gem allows easy interaction with the Roblox web API via class models."
-  spec.homepage = "https://github.com/roblox-api-wrappers/rublox"
-  spec.license = "MIT"
-  spec.required_ruby_version = ">= 3.0"
-  spec.files = Dir[
-    "LICENSE",
-    "CHANGELOG.MD",
-    "lib/**/*.rb",
-    "rublox.gemspec",
-    "Gemfile",
-    "Rakefile"
-  ]
-  spec.extra_rdoc_files = ["README.md"]
+	spec.name = "rublox"
+	spec.version = "0.3.0"
+	spec.authors = %w[zmλdie keef]
+	spec.email = "rorg.devv@gmail.com"
+	spec.summary = "A Roblox web API wrapper written in Ruby"
+	spec.description = "This gem allows easy interaction with the Roblox web API via modules and classes."
+	spec.homepage = "https://github.com/roblox-api-wrappers/rublox"
+	spec.metadata = {
+		"Documentation" => "https://rubydoc.info/gems/rublox",
+		"rubygems_mfa_required" => "true"
+	}
+	spec.license = "MIT"
+	spec.required_ruby_version = ">= 2.7.0"
+	spec.files = Dir[
+		"README.md",
+		"LICENSE",
+		"lib/**/*.rb",
+		"rublox.gemspec"
+	]
 
-  spec.add_dependency "http", "~> 5.0.2"
+	spec.add_dependency "http", "~> 5.1.1"
 
-  spec.add_development_dependency "dotenv", "~> 2.7"
-  spec.add_development_dependency "rake", "~> 13.0.6"
-  spec.add_development_dependency "rubocop", "~> 1.21.0"
-  spec.add_development_dependency "rubocop-performance", "~> 1.11.5"
-  spec.add_development_dependency "yard", "~> 0.9.26"
+	spec.add_development_dependency "rubocop", "~> 1.44.1"
+	spec.add_development_dependency "rubocop-performance", "~> 1.15.2"
+	spec.add_development_dependency "rubocop-rake", "~> 0.6.0"
+	spec.add_development_dependency "yard", "~> 0.9.28"
 end