mangadex 5.3.0

data/lib/mangadex/auth.rb

@@ -0,0 +1,56 @@
+# typed: false
+module Mangadex
+  class Auth
+    class << self
+      def login(username, password)
+        response = Mangadex::Internal::Request.post(
+          '/auth/login',
+          payload: {
+            username: username,
+            password: password,
+          },
+        )
+        return response if response.is_a?(Mangadex::Api::Response) && response.errored?
+
+        session = response.dig('token', 'session')
+        refresh = response.dig('token', 'refresh')
+
+        mangadex_user = Mangadex::Internal::Request.get('/user/me', headers: { Authorization: session })
+
+        user = Mangadex::Api::User.new(
+          mangadex_user.data.id,
+          session: session,
+          refresh: refresh,
+          data: mangadex_user.data,
+        )
+        Mangadex::Api::Context.user = user
+        !user.session_expired?
+      end
+
+      def check_token
+        JSON.parse(
+          Mangadex::Internal::Request.get(
+            '/auth/check',
+            raw: true,
+          )
+        )
+      end
+
+      def logout
+        return true if Mangadex::Api::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
+        true
+      end
+
+      def refresh_token
+        !(Mangadex::Api::Context.user&.refresh!).nil?
+      end
+    end
+  end
+end

data/lib/mangadex/author.rb

@@ -0,0 +1,101 @@
+# typed: true
+
+require_relative 'mangadex_object'
+
+module Mangadex
+  class Author < MangadexObject
+    has_attributes :name, :image_url, :biography, :version, :created_at, :updated_at
+
+    # List all authors.
+    # Path: +GET /author+
+    # Reference: https://api.mangadex.org/docs.html#operation/get-author
+    #
+    # @return [Mangadex::Api::Response] with a collection of authors
+    sig { params(args: T::Api::Arguments).returns(Mangadex::Api::Response[Author]) }
+    def self.list(**args)
+      Mangadex::Internal::Request.get(
+        '/author',
+        Mangadex::Internal::Definition.validate(args, {
+          limit: { accepts: Integer },
+          offset: { accepts: Integer },
+          ids: { accepts: [String] },
+          name: { accepts: String },
+          order: { accepts: Hash },
+          includes: { accepts: [String] },
+        })
+      )
+    end
+
+    # Create an author.
+    # Path: +POST /author+
+    # Reference: https://api.mangadex.org/docs.html#operation/post-author
+    #
+    # @return [Mangadex::Api::Response] with newly created author
+    sig { params(args: T::Api::Arguments).returns(Mangadex::Api::Response[Author]) }
+    def self.create(**args)
+      Mangadex::Internal::Request.post(
+        '/author',
+        payload: Mangadex::Internal::Definition.validate(args, {
+          name: { accepts: String, required: true },
+          version: { accepts: Integer },
+        })
+      )
+    end
+
+    # Get an author by ID.
+    # Path: +GET /author/:id+
+    # Reference: https://api.mangadex.org/docs.html#operation/get-author-id
+    #
+    # @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::Request.get(
+        format('/author/%{id}', id: id),
+        Mangadex::Internal::Definition.validate(args, {
+          includes: { accepts: [String] },
+        })
+      )
+    end
+
+    # Update an author.
+    # Path: +POST /author/:id+
+    # Reference: https://api.mangadex.org/docs.html#operation/put-author-id
+    #
+    # @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::Request.put(
+        format('/author/%{id}', id: id),
+        payload: Mangadex::Internal::Definition.validate(args, {
+          name: { accepts: String },
+          version: { accepts: Integer, required: true },
+        })
+      )
+    end
+
+    # Delete an author.
+    # Path: +DELETE /author/:id+
+    # Reference: https://api.mangadex.org/docs.html#operation/delete-author-id
+    #
+    # @param id Author's ID
+    # @return [Hash]
+    sig { params(id: String).returns(Hash) }
+    def self.delete(id)
+      Mangadex::Internal::Request.delete(
+        format('/author/%{id}', id: id)
+      )
+    end
+
+    def self.inspect_attributes
+      [:name]
+    end
+
+    # Indicates if this is an artist
+    #
+    # @return [Boolean] whether this is an artist or not.
+    sig { returns(T::Boolean) }
+    def artist?
+      false
+    end
+  end
+end

data/lib/mangadex/chapter.rb

@@ -0,0 +1,105 @@
+# typed: false
+require_relative "mangadex_object"
+
+module Mangadex
+  class Chapter < MangadexObject
+    include Internal::WithAttributes
+
+    has_attributes \
+      :title,
+      :volume,
+      :chapter,
+      :translated_language,
+      :hash,
+      :data,
+      :data_saver,
+      :last_chapter,
+      :uploader,
+      :external_url,
+      :version,
+      :created_at,
+      :updated_at,
+      :publish_at
+
+    sig { params(args: T::Api::Arguments).returns(Mangadex::Api::Response[Chapter]) }
+    def self.list(**args)
+      Mangadex::Internal::Request.get(
+        '/chapter',
+        Mangadex::Internal::Definition.chapter_list(args),
+      )
+    end
+
+    sig { params(id: String, args: T::Api::Arguments).returns(Mangadex::Api::Response[Chapter]) }
+    def self.get(id, **args)
+      Mangadex::Internal::Request.get(
+        '/chapter/%{id}' % {id: id},
+        Mangadex::Internal::Definition.validate(args, {
+          includes: { accepts: [String] },
+        }),
+      )
+    end
+
+    sig { params(id: String, args: T::Api::Arguments).returns(Mangadex::Api::Response[Chapter]) }
+    def self.update(id, **args)
+      Mangadex::Internal::Request.put(
+        '/chapter/%{id}' % {id: id},
+        payload: Mangadex::Internal::Definition.validate(args, {
+          title: { accepts: String },
+          volume: { accepts: String },
+          chapter: { accepts: String },
+          translated_language: { accepts: %r{^[a-zA-Z\-]{2,5}$} },
+          groups: { accepts: [String] },
+          version: { accepts: Integer, required: true },
+        }),
+      )
+    end
+
+    sig { params(id: String).returns(Hash) }
+    def self.delete(id)
+      Mangadex::Internal::Request.delete(
+        '/chapter/%{id}' % {id: id},
+      )
+    end
+
+    sig { returns(String) }
+    def title
+      attributes&.title.presence || chapter.presence && "Chapter #{chapter}" || "N/A"
+    end
+
+    sig { returns(T.nilable(String)) }
+    def locale
+      found_locale = translated_language.split('-').first
+      return if found_locale.nil?
+
+      ISO_639.find(found_locale)
+    end
+
+    sig { returns(T.nilable(String)) }
+    def locale_name
+      locale&.english_name
+    end
+
+    sig { returns(Integer) }
+    def page_count
+      Array(data).count
+    end
+
+    sig { returns(T.nilable(String)) }
+    def preview_image_url
+      return if data_saver.empty?
+
+      "https://uploads.mangadex.org/data-saver/#{attributes.hash}/#{data_saver.first}"
+    end
+
+    def as_json(*)
+      super.merge({
+        locale_name: locale_name,
+        preview_image_url: preview_image_url,
+      })
+    end
+
+    def self.attributes_to_inspect
+      [:id, :type, :title, :volume, :chapter, :page_count, :publish_at]
+    end
+  end
+end

data/lib/mangadex/content_rating.rb

@@ -0,0 +1,75 @@
+# typed: false
+require "active_support/string_inquirer"
+require "active_support/core_ext/module/delegation"
+
+module Mangadex
+  class ContentRating
+    extend T::Sig
+    include Comparable
+
+    VALUES = [
+      SAFE = 'safe',
+      SUGGESTIVE = 'suggestive',
+      EROTICA = 'erotica',
+      PORNOGRAPHIC = 'pornographic',
+    ].freeze
+
+    SCORES = {
+      SAFE => 0,
+      SUGGESTIVE => 1,
+      EROTICA => 2,
+      PORNOGRAPHIC => 3,
+    }.freeze
+
+    delegate_missing_to :value
+
+    sig { params(content_rating: T::Api::ContentRating).returns(T::Array[ContentRating]) }
+    def self.anything_below(content_rating)
+      SCORES.keys.map { |key| ContentRating.new(key) }.select { |record| record <= content_rating }.sort
+    end
+
+    sig { params(value: T.any(T::Api::Text, T::Api::ContentRating)).void }
+    def initialize(value)
+      @value = ensure_value!(value.to_s)
+    end
+
+    sig { returns(ActiveSupport::StringInquirer) }
+    def value
+      ActiveSupport::StringInquirer.new(@value)
+    end
+
+    sig { params(other: T.any(ContentRating, String, Symbol)).returns(Integer) }
+    def <=>(other)
+      other_score = if other.is_a?(ContentRating)
+        other.score
+      else
+        ContentRating.new(other).score
+      end
+
+      score <=> other_score
+    end
+
+    alias_method :safer_than?, :<
+    alias_method :spicier_than?, :>
+
+    sig { returns(Integer) }
+    def score
+      SCORES[value]
+    end
+
+    sig { returns(String) }
+    def to_s
+      value.to_s
+    end
+
+    private
+
+    sig { params(value: T.any(T::Api::Text, T::Api::ContentRating)).void }
+    def ensure_value!(value)
+      return value if value.is_a?(ContentRating)
+      return value if VALUES.include?(value)
+
+      raise ArgumentError, "Invalid content rating: '#{value}'. Must be one of #{VALUES}"
+    end
+  end
+end

data/lib/mangadex/cover_art.rb

@@ -0,0 +1,93 @@
+# typed: false
+require_relative "mangadex_object"
+
+module Mangadex
+  class CoverArt < MangadexObject
+    has_attributes \
+      :description,
+      :volume,
+      :file_name,
+      :created_at,
+      :updated_at,
+      :version
+
+    sig { params(args: T::Api::Arguments).returns(Mangadex::Api::Response[CoverArt]) }
+    def self.list(**args)
+      Mangadex::Internal::Request.get(
+        '/cover',
+        Mangadex::Internal::Definition.validate(args, {
+          limit: { accepts: Integer },
+          offset: { accepts: Integer },
+          manga: { accepts: [String] },
+          ids: { accepts: [String] },
+          uploaders: { accepts: [String] },
+          order: { accepts: Hash },
+          includes: { accepts: [String] },
+        })
+      )
+    end
+
+    sig do
+      params(
+        file: String,
+        volume: T.nilable(T.any(String, Integer)),
+        manga_id: String,
+      ).returns(Mangadex::Api::Response[CoverArt])
+    end
+    def self.upload(file, volume=nil, manga_id:)
+      args = { file: file, volume: volume }
+      Mangadex::Internal::Request.post(
+        '/cover/%{manga_id}' % {manga_id: manga_id},
+        payload: Mangadex::Internal::Definition.validate(args, {
+          file: { accepts: String, required: true },
+          volume: { accepts: %r{^(0|[1-9]\\d*)((\\.\\d+){1,2})?[a-z]?$} } # todo: double check regexp here
+        })
+      )
+    end
+
+    sig { params(id: String, args: T::Api::Arguments).returns(Mangadex::Api::Response[CoverArt]) }
+    def self.get(id, **args)
+      Mangadex::Internal::Request.get(
+        '/cover/%{id}' % {id: id},
+        Mangadex::Internal::Definition.validate(args, {
+          includes: { accepts: [String] },
+        })
+      )
+    end
+
+    sig { params(id: String, args: T::Api::Arguments).returns(Mangadex::Api::Response[CoverArt]) }
+    def self.edit(id, **args)
+      Mangadex::Internal::Request.put(
+        '/cover/%{id}' % {id: id},
+        Mangadex::Internal::Definition.validate(args, {
+          volume: { accepts: String },
+          description: { accepts: String },
+          version: { accepts: Integer, required: true }
+        })
+      )
+    end
+
+    sig { params(id: String).returns(Hash) }
+    def self.delete(id)
+      Mangadex::Internal::Request.delete(
+        '/cover/%{id}' % {id: id},
+      )
+    end
+
+    sig { params(size: T::Api::Text).returns(T.nilable(String)) }
+    def image_url(size: :small)
+      return unless manga.present?
+
+      extension = case size.to_sym
+      when :original
+        ''
+      when :medium
+        '.512.jpg'
+      else # :small by default
+        '.256.jpg'
+      end
+
+      "https://uploads.mangadex.org/covers/#{manga.id}/#{file_name}#{extension}"
+    end
+  end
+end

data/lib/mangadex/custom_list.rb

@@ -0,0 +1,127 @@
+# typed: false
+require_relative "mangadex_object"
+
+module Mangadex
+  class CustomList < MangadexObject
+    has_attributes \
+      :name,
+      :visibility,
+      :version
+
+    sig { params(args: T::Api::Arguments).returns(Mangadex::Api::Response[CustomList]) }
+    def self.create(**args)
+      Mangadex::Internal::Request.post(
+        '/list',
+        payload: Mangadex::Internal::Definition.validate(args, {
+          name: { accepts: String, required: true },
+          visibility: { accepts: %w(public private), converts: :to_s },
+          manga: { accepts: String },
+          version: { accepts: Integer },
+        }),
+        auth: true,
+      )
+    end
+
+    sig { params(id: String).returns(Mangadex::Api::Response[CustomList]) }
+    def self.get(id)
+      Mangadex::Internal::Request.get(
+        '/list/%{id}' % {id: id},
+      )
+    end
+
+    sig { params(id: String, args: T::Api::Arguments).returns(Mangadex::Api::Response[CustomList]) }
+    def self.update(id, **args)
+      Mangadex::Internal::Request.put(
+        '/list/%{id}' % {id: id},
+        payload: Mangadex::Internal::Definition.validate(args, {
+          name: { accepts: String },
+          visibility: { accepts: %w(private public) },
+          manga: { accepts: String },
+          version: { accepts: Integer, required: true },
+        })
+      )
+    end
+
+    sig { params(id: String).returns(T::Boolean) }
+    def self.delete(id)
+      Mangadex::Internal::Request.delete(
+        '/list/%{id}' % {id: id},
+      )
+    end
+
+    sig { params(id: String, args: T::Api::Arguments).returns(Mangadex::Api::Response[Chapter]) }
+    def self.feed(id, **args)
+      Mangadex::Internal::Request.get(
+        '/list/%{id}/feed' % {id: id},
+        Mangadex::Internal::Definition.chapter_list(args),
+      )
+    end
+
+    sig { params(id: String, list_id: String).returns(T::Boolean) }
+    def self.add_manga(id, list_id:)
+      response = Mangadex::Internal::Request.post(
+        '/manga/%{id}/list/%{list_id}' % {id: id, list_id: list_id},
+      )
+      if response.is_a?(Hash)
+        response['result'] == 'ok'
+      else
+        !response.errored?
+      end
+    end
+
+    sig { params(id: String, list_id: String).returns(T::Boolean) }
+    def self.remove_manga(id, list_id:)
+      response = Mangadex::Internal::Request.delete(
+        '/manga/%{id}/list/%{list_id}' % {id: id, list_id: list_id},
+      )
+      if response.is_a?(Hash)
+        response['result'] == 'ok'
+      else
+        !response.errored?
+      end
+    end
+
+    sig { params(args: T::Api::Arguments).returns(Mangadex::Api::Response[CustomList]) }
+    def self.list(**args)
+      Mangadex::Internal::Request.get(
+        '/user/list',
+        Mangadex::Internal::Definition.validate(args, {
+          limit: { accepts: Integer },
+          offset: { accepts: Integer },
+        }),
+      )
+    end
+
+    sig { params(user_id: String, args: T::Api::Arguments).returns(Mangadex::Api::Response[CustomList]) }
+    def self.user_list(user_id, **args)
+      Mangadex::Internal::Request.get(
+        '/user/%{id}/list' % {id: user_id},
+        Mangadex::Internal::Definition.validate(args, {
+          limit: { accepts: Integer },
+          offset: { accepts: Integer },
+        }),
+      )
+    end
+
+    sig { params(id: String).returns(T::Boolean) }
+    def add_manga(id)
+      Mangadex::CustomList.add_manga(id, list_id: self.id)
+    end
+
+    sig { params(id: String).returns(T::Boolean) }
+    def remove_manga(id)
+      Mangadex::CustomList.remove_manga(id, list_id: self.id)
+    end
+
+    sig { params(args: T::Api::Arguments).returns(T.nilable(Mangadex::Api::Response[Manga])) }
+    def manga_details(**args)
+      ids = mangas.map(&:id)
+      ids.any? ? Mangadex::Manga.list(**args.merge(ids: ids)) : nil
+    end
+
+    def self.inspect_attributes
+      [:name, :visibility]
+    end
+  end
+end
+