mangadex 5.3.1.3 → 5.3.3.2

data/lib/mangadex/auth.rb

@@ -3,16 +3,20 @@ module Mangadex
   class Auth
     extend T::Sig
 
-    sig { params(username: String, password: String).returns(T.any(T::Boolean, Mangadex::Api::Response)) }
-    def self.login(username, password)
+    sig { params(username: T.nilable(String), email: T.nilable(String), password: String).returns(T.nilable(Mangadex::Api::User)) }
+    def self.login(username: nil, email: nil, password: nil)
+      args = { password: password }
+      args.merge!(email: email) if email
+      args.merge!(username: username) if username
+
       response = Mangadex::Internal::Request.post(
         '/auth/login',
-        payload: {
-          username: username,
-          password: password,
-        },
+        payload: Mangadex::Internal::Definition.validate(args, {
+          username: { accepts: String },
+          email: { accepts: String },
+          password: { accepts: String, required: true },
+        }),
       )
-      return response if response.is_a?(Mangadex::Api::Response) && response.errored?
 
       session = response.dig('token', 'session')
       refresh = response.dig('token', 'refresh')
@@ -20,13 +24,19 @@ module Mangadex
       mangadex_user = Mangadex::Internal::Request.get('/user/me', headers: { Authorization: session })
 
       user = Mangadex::Api::User.new(
-        mangadex_user.data.id,
+        mangadex_user_id: mangadex_user.data.id,
         session: session,
         refresh: refresh,
         data: mangadex_user.data,
       )
-      Mangadex::Api::Context.user = user
-      !user.session_expired?
+      return if user.session_expired?
+
+      Mangadex.context.user = user
+
+      user.persist
+      user
+    rescue Errors::UnauthorizedError => error
+      raise Errors::AuthenticationError.new(error.response)
     end
 
     sig { returns(Hash) }
@@ -41,20 +51,39 @@ module Mangadex
 
     sig { returns(T.any(T::Boolean, Mangadex::Api::Response)) }
     def self.logout
-      return true if Mangadex::Api::Context.user.nil?
+      return true if Mangadex.context.user.nil?
 
       response = Mangadex::Internal::Request.post(
         '/auth/logout',
       )
       return reponse if response.is_a?(Mangadex::Api::Response) && response.errored?
 
-      Mangadex::Api::Context.user = nil
+      clear_user
+      true
+    rescue Mangadex::Errors::UnauthorizedError
+      clear_user
       true
     end
 
     sig { returns(T::Boolean) }
     def self.refresh_token
-      !(Mangadex::Api::Context.user&.refresh!).nil?
+      !(Mangadex.context.user&.refresh!).nil?
+    end
+
+    private
+
+    sig { void }
+    def self.clear_user
+      return if Mangadex.context.user.nil?
+
+      if Mangadex.context.user.respond_to?(:session=)
+        Mangadex.context.user.session = nil
+      end
+      if Mangadex.context.user.respond_to?(:refresh=)
+        Mangadex.context.user.refresh = nil
+      end
+      Mangadex.storage.clear(Mangadex.context.user.mangadex_user_id)
+      Mangadex.context.user = nil
     end
   end
 end

data/lib/mangadex/author.rb

@@ -4,7 +4,24 @@ require_relative 'mangadex_object'
 
 module Mangadex
   class Author < MangadexObject
-    has_attributes :name, :image_url, :biography, :version, :created_at, :updated_at
+    has_attributes \
+      :name,
+      :image_url,
+      :biography,
+      :twitter,
+      :pixiv,
+      :melon_book,
+      :fan_box,
+      :booth,
+      :nico_video,
+      :skeb,
+      :fantia,
+      :tumblr,
+      :youtube,
+      :website,
+      :version,
+      :created_at,
+      :updated_at
 
     # List all authors.
     # Path: +GET /author+
@@ -49,6 +66,8 @@ module Mangadex
     # @return [Mangadex::Api::Response] with a entity of author
     sig { params(id: String, args: T::Api::Arguments).returns(Mangadex::Api::Response[Author]) }
     def self.get(id, **args)
+      Mangadex::Internal::Definition.must(id)
+
       Mangadex::Internal::Request.get(
         format('/author/%{id}', id: id),
         Mangadex::Internal::Definition.validate(args, {
@@ -64,6 +83,8 @@ module Mangadex
     # @return [Mangadex::Api::Response] with a entity of author
     sig { params(id: String, args: T::Api::Arguments).returns(Mangadex::Api::Response[Author]) }
     def self.update(id, **args)
+      Mangadex::Internal::Definition.must(id)
+
       Mangadex::Internal::Request.put(
         format('/author/%{id}', id: id),
         payload: Mangadex::Internal::Definition.validate(args, {
@@ -81,6 +102,8 @@ module Mangadex
     # @return [Hash]
     sig { params(id: String).returns(Hash) }
     def self.delete(id)
+      Mangadex::Internal::Definition.must(id)
+
       Mangadex::Internal::Request.delete(
         format('/author/%{id}', id: id)
       )
@@ -90,6 +113,10 @@ module Mangadex
       [:name]
     end
 
+    class << self
+      alias_method :view, :get
+    end
+
     # Indicates if this is an artist
     #
     # @return [Boolean] whether this is an artist or not.

data/lib/mangadex/chapter.rb

@@ -26,11 +26,14 @@ module Mangadex
       Mangadex::Internal::Request.get(
         '/chapter',
         Mangadex::Internal::Definition.chapter_list(args),
+        content_rating: true,
       )
     end
 
     sig { params(id: String, args: T::Api::Arguments).returns(Mangadex::Api::Response[Chapter]) }
     def self.get(id, **args)
+      Mangadex::Internal::Definition.must(id)
+
       Mangadex::Internal::Request.get(
         '/chapter/%{id}' % {id: id},
         Mangadex::Internal::Definition.validate(args, {
@@ -41,6 +44,8 @@ module Mangadex
 
     sig { params(id: String, args: T::Api::Arguments).returns(Mangadex::Api::Response[Chapter]) }
     def self.update(id, **args)
+      Mangadex::Internal::Definition.must(id)
+
       Mangadex::Internal::Request.put(
         '/chapter/%{id}' % {id: id},
         payload: Mangadex::Internal::Definition.validate(args, {
@@ -56,11 +61,17 @@ module Mangadex
 
     sig { params(id: String).returns(Hash) }
     def self.delete(id)
+      Mangadex::Internal::Definition.must(id)
+
       Mangadex::Internal::Request.delete(
         '/chapter/%{id}' % {id: id},
       )
     end
 
+    class << self
+      alias_method :view, :get
+    end
+
     sig { returns(String) }
     def title
       attributes&.title.presence || chapter.presence && "Chapter #{chapter}" || "N/A"

data/lib/mangadex/content_rating.rb

@@ -28,6 +28,11 @@ module Mangadex
       SCORES.keys.map { |key| ContentRating.new(key) }.select { |record| record <= content_rating }.sort
     end
 
+    sig { params(content_ratings: T::Array[T.any(T::Api::Text, T::Api::ContentRating)]).returns(T::Array[ContentRating]) }
+    def self.parse(content_ratings)
+      content_ratings.map { |content_rating| ContentRating.new(content_rating) }.uniq
+    end
+
     sig { params(value: T.any(T::Api::Text, T::Api::ContentRating)).void }
     def initialize(value)
       @value = ensure_value!(value.to_s)
@@ -64,7 +69,7 @@ module Mangadex
 
     private
 
-    sig { params(value: T.any(T::Api::Text, T::Api::ContentRating)).void }
+    sig { params(value: T.any(T::Api::Text, T::Api::ContentRating)).returns(T.any(T::Api::Text, T::Api::ContentRating)) }
     def ensure_value!(value)
       return value if value.is_a?(ContentRating)
       return value if VALUES.include?(value)

data/lib/mangadex/cover_art.rb

@@ -47,6 +47,8 @@ module Mangadex
 
     sig { params(id: String, args: T::Api::Arguments).returns(Mangadex::Api::Response[CoverArt]) }
     def self.get(id, **args)
+      Mangadex::Internal::Definition.must(id)
+
       Mangadex::Internal::Request.get(
         '/cover/%{id}' % {id: id},
         Mangadex::Internal::Definition.validate(args, {
@@ -57,6 +59,8 @@ module Mangadex
 
     sig { params(id: String, args: T::Api::Arguments).returns(Mangadex::Api::Response[CoverArt]) }
     def self.edit(id, **args)
+      Mangadex::Internal::Definition.must(id)
+
       Mangadex::Internal::Request.put(
         '/cover/%{id}' % {id: id},
         Mangadex::Internal::Definition.validate(args, {
@@ -69,11 +73,18 @@ module Mangadex
 
     sig { params(id: String).returns(Hash) }
     def self.delete(id)
+      Mangadex::Internal::Definition.must(id)
+
       Mangadex::Internal::Request.delete(
         '/cover/%{id}' % {id: id},
       )
     end
 
+    class << self
+      alias_method :view, :get
+      alias_method :update, :edit
+    end
+
     sig { params(size: T::Api::Text).returns(T.nilable(String)) }
     def image_url(size: :small)
       return unless manga.present?

data/lib/mangadex/custom_list.rb

@@ -24,6 +24,8 @@ module Mangadex
 
     sig { params(id: String).returns(Mangadex::Api::Response[CustomList]) }
     def self.get(id)
+      Mangadex::Internal::Definition.must(id)
+
       Mangadex::Internal::Request.get(
         '/list/%{id}' % {id: id},
       )
@@ -31,6 +33,8 @@ module Mangadex
 
     sig { params(id: String, args: T::Api::Arguments).returns(Mangadex::Api::Response[CustomList]) }
     def self.update(id, **args)
+      Mangadex::Internal::Definition.must(id)
+
       Mangadex::Internal::Request.put(
         '/list/%{id}' % {id: id},
         payload: Mangadex::Internal::Definition.validate(args, {
@@ -44,6 +48,8 @@ module Mangadex
 
     sig { params(id: String).returns(T::Boolean) }
     def self.delete(id)
+      Mangadex::Internal::Definition.must(id)
+
       Mangadex::Internal::Request.delete(
         '/list/%{id}' % {id: id},
       )
@@ -51,14 +57,19 @@ module Mangadex
 
     sig { params(id: String, args: T::Api::Arguments).returns(Mangadex::Api::Response[Chapter]) }
     def self.feed(id, **args)
+      Mangadex::Internal::Definition.must(id)
+
       Mangadex::Internal::Request.get(
         '/list/%{id}/feed' % {id: id},
         Mangadex::Internal::Definition.chapter_list(args),
+        content_rating: true,
       )
     end
 
     sig { params(id: String, list_id: String).returns(T::Boolean) }
     def self.add_manga(id, list_id:)
+      Mangadex::Internal::Definition.must(id)
+
       response = Mangadex::Internal::Request.post(
         '/manga/%{id}/list/%{list_id}' % {id: id, list_id: list_id},
       )
@@ -71,6 +82,8 @@ module Mangadex
 
     sig { params(id: String, list_id: String).returns(T::Boolean) }
     def self.remove_manga(id, list_id:)
+      Mangadex::Internal::Definition.must(id)
+
       response = Mangadex::Internal::Request.delete(
         '/manga/%{id}/list/%{list_id}' % {id: id, list_id: list_id},
       )
@@ -94,6 +107,8 @@ module Mangadex
 
     sig { params(user_id: String, args: T::Api::Arguments).returns(Mangadex::Api::Response[CustomList]) }
     def self.user_list(user_id, **args)
+      Mangadex::Internal::Definition.must(user_id)
+
       Mangadex::Internal::Request.get(
         '/user/%{id}/list' % {id: user_id},
         Mangadex::Internal::Definition.validate(args, {
@@ -103,6 +118,11 @@ module Mangadex
       )
     end
 
+    class << self
+      alias_method :view, :get
+      alias_method :edit, :update
+    end
+
     sig { params(id: String).returns(T::Boolean) }
     def add_manga(id)
       Mangadex::CustomList.add_manga(id, list_id: self.id)

data/lib/mangadex/internal/context.rb

@@ -0,0 +1,141 @@
+# typed: true
+module Mangadex
+  module Internal
+    class Context
+      extend T::Sig
+
+      sig { returns(T::Array[Mangadex::ContentRating]) }
+      attr_accessor :allowed_content_ratings, :ignore_user
+
+      def initialize
+        @allowed_content_ratings = Mangadex.configuration.default_content_ratings
+      end
+
+      sig { returns(T.nilable(String)) }
+      def version
+        @version ||= Mangadex::Api::VersionChecker.check_mangadex_version
+      end
+
+      sig { returns(T.nilable(Mangadex::Api::User)) }
+      def user
+        @ignore_user ? nil : @user&.with_valid_session
+      rescue Mangadex::Errors::UnauthorizedError
+        warn("A user is present but not authenticated!")
+        nil
+      end
+
+      sig { returns(T::Array[Mangadex::Tag]) }
+      def tags
+        @tags ||= Mangadex::Tag.list.data
+      end
+
+      sig { params(user: T.nilable(T.any(Hash, Mangadex::Api::User, Mangadex::User)), block: T.proc.returns(T.untyped)).returns(T.untyped) }
+      def with_user(user, &block)
+        temp_set_value("user", user) do
+          yield
+        end
+      end
+
+      sig { params(block: T.proc.returns(T.untyped)).returns(T.untyped) }
+      def without_user(&block)
+        temp_set_value("ignore_user", true) do
+          yield
+        end
+      end
+
+      sig { params(user: T.nilable(T.untyped)).void }
+      def user=(user)
+        if user.is_a?(Mangadex::Api::User)
+          @user = user
+        elsif user.is_a?(Mangadex::User)
+          @user = Mangadex::Api::User.new(
+            mangadex_user_id: user.id,
+            data: user,
+          )
+        elsif user.is_a?(Hash)
+          user = Mangadex::Internal::Definition.validate(user, {
+            mangadex_user_id: { accepts: String, required: true },
+            session: { accepts: String },
+            refresh: { accepts: String },
+          })
+
+          @user = Mangadex::Api::User.new(
+            mangadex_user_id: user[:mangadex_user_id],
+            session: user[:session],
+            refresh: user[:refresh],
+          )
+        elsif user_object?(user)
+          @user = Mangadex::Api::User.new(
+            mangadex_user_id: user.mangadex_user_id.to_s,
+            session: user.session,
+            refresh: user.refresh,
+            data: user,
+          )
+        elsif user.nil?
+          @user = nil
+        else
+          raise TypeError, "Invalid user type."
+        end
+      end
+
+      def allow_content_ratings(*content_ratings, &block)
+        content_ratings = Mangadex::ContentRating.parse(Array(content_ratings))
+        if block_given?
+          content_ratings = Mangadex.context.allowed_content_ratings if content_ratings.empty?
+
+          # set temporarily
+          temp_set_value("allowed_content_ratings", content_ratings) do
+            yield
+          end
+        elsif content_ratings.any?
+          # set "permanently"
+          @allowed_content_ratings = content_ratings
+        else
+          # This is to throw an exception prompting to pass a block if there no params.
+          yield
+        end
+      end
+
+      def with_allowed_content_ratings(*other_content_ratings, &block)
+        T.unsafe(self).allow_content_ratings(*(allowed_content_ratings + other_content_ratings)) do
+          yield
+        end
+      end
+
+      # Only recommended for development and debugging only
+      def force_raw_requests(&block)
+        if block_given?
+          temp_set_value("force_raw_requests", true) do
+            yield
+          end
+        else
+          !!@force_raw_requests
+        end
+      end
+
+      private
+
+      def user_object?(user)
+        return false if user.nil?
+
+        missing_methods = [:session, :refresh, :mangadex_user_id] - user.methods
+        return true if missing_methods.empty?
+
+        warn("Potential user object #{user} is missing #{missing_methods}")
+        false
+      end
+
+      def temp_set_value(name, value, &block)
+        setter_method_name = "#{name}="
+
+        current_value = send(name)
+        send(setter_method_name, value)
+        response = yield
+        send(setter_method_name, current_value)
+        response
+      ensure
+        send(setter_method_name, current_value) if current_value
+      end
+    end
+  end
+end

data/lib/mangadex/internal/definition.rb

@@ -120,6 +120,19 @@ module Mangadex
           )
         end
 
+        def must(*args)
+          args = args.each_with_index.map do |arg, index|
+            ["arg_at_position_#{index}".to_sym, arg]
+          end.to_h
+
+          definition = args.keys.map do |key|
+            [key, { required: true }]
+          end.to_h
+
+          validate(args, definition)
+          args.values
+        end
+
         def validate(args, definition)
           args = Hash(args).with_indifferent_access
           definition = Hash(definition).with_indifferent_access

data/lib/mangadex/internal/request.rb

@@ -13,9 +13,9 @@ module Mangadex
       attr_accessor :path, :headers, :payload, :method, :raw
       attr_reader :response
 
-      def self.get(path, params={}, auth: false, headers: nil, raw: false)
+      def self.get(path, params={}, auth: false, headers: nil, raw: false, content_rating: false)
         new(
-          path_with_params(path, params),
+          path_with_params(path, params, content_rating),
           method: :get,
           headers: headers,
           payload: nil,
@@ -54,7 +54,7 @@ module Mangadex
         payload_details = request_payload ? "Payload: #{request_payload}" : "{no-payload}"
         puts("[#{self.class.name}] #{method.to_s.upcase} #{request_url} #{payload_details}")
 
-        raise Mangadex::UserNotLoggedIn.new if auth && Mangadex::Api::Context.user.nil?
+        raise Mangadex::Errors::UserNotLoggedIn.new if auth && Mangadex.context.user.nil?
 
         start_time = Time.now
 
@@ -62,13 +62,17 @@ module Mangadex
         end_time = Time.now
         elapsed_time = ((end_time - start_time) * 1000).to_i
         puts("[#{self.class.name}] took #{elapsed_time} ms")
+        
+        raw_request = raw || Mangadex.context.force_raw_requests
 
-        if @response.body
-          raw ? @response.body : Mangadex::Api::Response.coerce(JSON.parse(@response.body))
+        if (body = @response.body)
+          raw_request ? try_json(body) : Mangadex::Api::Response.coerce(try_json(body))
         end
+      rescue RestClient::Unauthorized => error
+        raise Errors::UnauthorizedError.new(Mangadex::Api::Response.coerce(try_json(error.response.body)))
       rescue RestClient::Exception => error
-        if error.response.body
-          raw ? error.response.body : Mangadex::Api::Response.coerce(JSON.parse(error.response.body)) rescue raise error
+        if (body = error.response.body)
+          raw_request ? try_json(body) : Mangadex::Api::Response.coerce(JSON.parse(body)) rescue raise error
         else
           raise error
         end
@@ -76,7 +80,8 @@ module Mangadex
 
       private
 
-      def self.path_with_params(path, params)
+      def self.path_with_params(path, params, content_rating)
+        params = content_rating ? self.with_content_rating(params) : params
         return path if params.blank?
 
         params = params.deep_transform_keys do |key|
@@ -85,6 +90,14 @@ module Mangadex
         "#{path}?#{params.to_query}"
       end
 
+      def self.with_content_rating(data)
+        content_rating = data.has_key?(:content_rating) ? data[:content_rating] : []
+        Mangadex.context.allow_content_ratings(*content_rating) do
+          data[:content_rating] = Mangadex.context.allowed_content_ratings
+        end
+        data
+      end
+
       def request_url
         request_path = path.start_with?('/') ? path : "/#{path}"
         "#{BASE_URI}#{request_path}"
@@ -97,10 +110,10 @@ module Mangadex
       end
 
       def request_headers
-        return headers if Mangadex::Api::Context.user.nil?
+        return headers if Mangadex.context.user.nil?
 
         headers.merge({
-          Authorization: Mangadex::Api::Context.user.with_valid_session.session,
+          Authorization: Mangadex.context.user.with_valid_session.session,
         })
       end
 
@@ -116,6 +129,12 @@ module Mangadex
 
         raise "Invalid method: #{method}. Must be one of: #{ALLOWED_METHODS}"
       end
+
+      def try_json(body)
+        JSON.parse(body)
+      rescue JSON::ParserError
+        body
+      end
     end
   end
 end

data/lib/mangadex/internal/with_attributes.rb

@@ -11,7 +11,8 @@ module Mangadex
           :id,
           :type,
           :attributes,
-          :relationships
+          :relationships,
+          :related_type
       
       class_methods do
         USING_ATTRIBUTES = {}
@@ -30,7 +31,7 @@ module Mangadex
           self.name.split('::').last.underscore
         end
 
-        def from_data(data)
+        def from_data(data, related_type: nil)
           base_class_name = self.name.gsub('::', '_')
           klass_name = self.name
           target_attributes_class_name = "#{base_class_name}_Attributes"
@@ -65,6 +66,7 @@ module Mangadex
             id: data['id'],
             type: data['type'] || self.type,
             attributes: attributes,
+            related_type: related_type,
           }
 
           initialize_hash.merge!({relationships: relationships}) if relationships.present?
@@ -110,6 +112,13 @@ module Mangadex
             else
               super
             end
+          elsif !related_type.nil?
+            return super unless method_name.end_with?("?")
+
+            looking_for_related = method_name.to_s.split("?").first
+            return super unless Mangadex::Relationship::RELATED_VALUES.include?(looking_for_related)
+
+            related_type == looking_for_related
           else
             super
           end

data/lib/mangadex/internal.rb

@@ -1,3 +1,4 @@
 # typed: strict
+require_relative "internal/context"
 require_relative "internal/request"
 require_relative "internal/definition"