mangadex 5.3.0

data/lib/mangadex/internal/definition.rb

@@ -0,0 +1,162 @@
+# typed: true
+module Mangadex
+  module Internal
+    class Definition
+      attr_reader :key, :value, :converts, :accepts, :required
+      attr_reader :errors
+
+      def initialize(key, value, converts: nil, accepts: nil, required: false)
+        @converts = converts
+        @key = key
+        @value = convert_value(value)
+        @raw_value = value
+        @accepts = accepts
+        @required = required ? true : false
+        @errors = Array.new
+      end
+
+      def empty?
+        value.respond_to?(:empty?) ? value.empty? : value.to_s.strip.empty?
+      end
+
+      def validate!
+        validate_required!
+        validate_accepts!
+
+        true
+      end
+
+      def valid?
+        validate!
+      rescue ArgumentError
+        false
+      end
+
+      def error
+        validate! && nil
+      rescue ArgumentError => error
+        error.message
+      end
+
+      def convert_value(value)
+        if converts.is_a?(Proc)
+          converts.call(value)
+        elsif converts.is_a?(String) || converts.is_a?(Symbol)
+          value.send(converts)
+        else
+          value
+        end
+      end
+
+      def validate_required!
+        return unless required
+
+        if empty?
+          raise ArgumentError, "Missing :#{key}"
+        end
+      end
+
+      def validate_accepts!
+        return if value.nil? && !required
+        return unless accepts
+
+        if accepts.is_a?(Class) && !value.is_a?(accepts)
+          raise ArgumentError, "Expected :#{key} to be a #{accepts}, but got a #{value.class}"
+        end
+        if accepts.is_a?(Regexp) && !(accepts === value)
+          raise ArgumentError, "Expected :#{key} to match /#{accepts}/"
+        end
+        if accepts.is_a?(Array)
+          if accepts.count == 1 && accepts[0].is_a?(Class)
+            expected_class = accepts[0]
+            if !value.is_a?(Array)
+              raise ArgumentError, "Expected :#{key} to be an Array of #{expected_class}, but got #{value}"
+            end
+
+            invalid_elements = []
+            value.each do |x|
+              invalid_elements << x unless x.is_a?(expected_class)
+            end
+            return if invalid_elements.empty?
+            bad = invalid_elements.map { |x| "<#{x}:#{x.class}>" }
+            raise ArgumentError, "Expected elements in :#{key} to be an Array of #{expected_class}, but found #{bad}"
+          else
+            if value.is_a?(Array)
+              extra_elements = value - accepts
+              return if extra_elements.empty?
+              raise ArgumentError, "Expected elements in :#{key} to be one of #{accepts}, but found #{extra_elements}"
+            elsif !(value.nil? || (value.respond_to?(:empty?) && value.empty?)) && !accepts.include?(value)
+              raise ArgumentError, "Expected :#{key} to be one of #{accepts}, but got #{@raw_value}:#{@raw_value.class}"
+            end
+          end
+        end
+      end
+
+      class << self
+        def converts(key=nil)
+          procs = { to_a: -> ( x ) { Array(x) } }
+          return procs if key.nil?
+
+          procs[key]
+        end
+
+        def chapter_list(args)
+          validate(
+            args,
+            {
+              limit: { accepts: Integer },
+              offset: { accepts: Integer },
+              translated_language: { accepts: String },
+              original_language: { accepts: [String] },
+              excluded_original_language: { accepts: [String] },
+              content_rating: { accepts: %w(safe suggestive erotica pornographic), converts: converts(:to_a) },
+              include_future_updates: { accepts: %w(0 1) },
+              created_at_since: { accepts: %r{^\d{4}-[0-1]\d-([0-2]\d|3[0-1])T([0-1]\d|2[0-3]):[0-5]\d:[0-5]\d$} },
+              updated_at_since: { accepts: %r{^\d{4}-[0-1]\d-([0-2]\d|3[0-1])T([0-1]\d|2[0-3]):[0-5]\d:[0-5]\d$} },
+              publish_at_since: { accepts: %r{^\d{4}-[0-1]\d-([0-2]\d|3[0-1])T([0-1]\d|2[0-3]):[0-5]\d:[0-5]\d$} },
+              order: { accepts: Hash },
+              includes: { accepts: [String], converts: converts(:to_a) },
+            },
+          )
+        end
+
+        def validate(args, definition)
+          args = Hash(args).with_indifferent_access
+          definition = Hash(definition).with_indifferent_access
+          return args if definition.empty?
+
+          errors = []
+          extra_keys = args.keys - definition.keys
+          extra_keys.each do |extra_key|
+            errors << { extra: extra_key }
+          end
+
+          definition.each do |key, definition|
+            validator = Definition.new(key, args[key], **definition.symbolize_keys)
+            validation_error = validator.error
+            if validation_error
+              errors << { message: validation_error }
+            elsif !validator.empty?
+              args[key] = validator.value
+            end
+          end
+
+          if errors.any?
+            error_message = errors.map do |error|
+              if error[:extra]
+                "params[:#{error[:extra]}] does not exist and cannot be passed to this request"
+              elsif error[:message]
+                error[:message]
+              else
+                error.to_s
+              end
+            end.join(', ')
+            raise ArgumentError, "Validation error: #{error_message}"
+          end
+
+          args.symbolize_keys
+        end
+      end
+    end
+  end
+end

data/lib/mangadex/internal/request.rb

@@ -0,0 +1,121 @@
+# typed: false
+require 'rest-client'
+require 'json'
+require 'active_support/core_ext/object/to_query'
+require 'active_support/core_ext/hash/keys'
+
+module Mangadex
+  module Internal
+    class Request
+      BASE_URI = 'https://api.mangadex.org'
+      ALLOWED_METHODS = %i(get post put delete).freeze
+
+      attr_accessor :path, :headers, :payload, :method, :raw
+      attr_reader :response
+
+      def self.get(path, params={}, auth: false, headers: nil, raw: false)
+        new(
+          path_with_params(path, params),
+          method: :get,
+          headers: headers,
+          payload: nil,
+        ).run!(raw: raw, auth: auth)
+      end
+
+      def self.post(path, headers: nil, auth: false, payload: nil, raw: false)
+        new(path, method: :post, headers: headers, payload: payload).run!(raw: raw, auth: auth)
+      end
+
+      def self.put(path, headers: nil, auth: false, payload: nil, raw: false)
+        new(path, method: :put, headers: headers, payload: payload).run!(raw: raw, auth: auth)
+      end
+
+      def self.delete(path, headers: nil, auth: false, payload: nil, raw: false)
+        new(path, method: :delete, headers: headers, payload: payload).run!(raw: raw, auth: auth)
+      end
+
+      def initialize(path, method:, headers: nil, payload: nil)
+        @path = path
+        @headers = Hash(headers)
+        @payload = payload
+        @method = ensure_method!(method)
+      end
+
+      def request
+        RestClient::Request.new(
+          method: method,
+          url: request_url,
+          headers: request_headers,
+          payload: request_payload,
+        )
+      end
+
+      def run!(raw: false, auth: false)
+        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?
+
+        start_time = Time.now
+
+        @response = request.execute
+        end_time = Time.now
+        elapsed_time = ((end_time - start_time) * 1000).to_i
+        puts("[#{self.class.name}] took #{elapsed_time} ms")
+
+        if @response.body
+          raw ? @response.body : Mangadex::Api::Response.coerce(JSON.parse(@response.body))
+        end
+      rescue RestClient::Exception => error
+        if error.response.body
+          raw ? error.response.body : Mangadex::Api::Response.coerce(JSON.parse(error.response.body))
+        else
+          raise error
+        end
+      end
+
+      private
+
+      def self.path_with_params(path, params)
+        return path if params.blank?
+
+        params = params.deep_transform_keys do |key|
+          key.to_s.camelize(:lower)
+        end
+        "#{path}?#{params.to_query}"
+      end
+
+      def request_url
+        request_path = path.start_with?('/') ? path : "/#{path}"
+        "#{BASE_URI}#{request_path}"
+      end
+
+      def request_payload
+        return if payload.nil? || payload.empty?
+
+        JSON.generate(payload)
+      end
+
+      def request_headers
+        return headers if Mangadex::Api::Context.user.nil?
+
+        headers.merge({
+          Authorization: Mangadex::Api::Context.user.with_valid_session.session,
+        })
+      end
+
+      def missing_method?(method)
+        method.nil? || method.to_s.strip.empty?
+      end
+
+      def ensure_method!(method)
+        raise 'Method must be present' if missing_method?(method)
+
+        clean_method = method.to_s.downcase.to_sym
+        return clean_method if ALLOWED_METHODS.include?(clean_method)
+
+        raise "Invalid method: #{method}. Must be one of: #{ALLOWED_METHODS}"
+      end
+    end
+  end
+end

data/lib/mangadex/internal/with_attributes.rb

@@ -0,0 +1,120 @@
+# typed: false
+
+require "active_support/hash_with_indifferent_access"
+
+module Mangadex
+  module Internal
+    module WithAttributes
+      extend ActiveSupport::Concern
+
+      attr_accessor \
+          :id,
+          :type,
+          :attributes,
+          :relationships
+      
+      class_methods do
+        USING_ATTRIBUTES = {}
+
+        def has_attributes(*attributes)
+          USING_ATTRIBUTES[self.name] = Array(USING_ATTRIBUTES[self.name]).concat(
+            attributes.map(&:to_sym)
+          )
+        end
+
+        def attributes
+          USING_ATTRIBUTES[self.name] || []
+        end
+
+        def type
+          self.name.split('::').last.underscore
+        end
+
+        def from_data(data)
+          base_class_name = self.name.gsub('::', '_')
+          klass_name = self.name
+          target_attributes_class_name = "#{base_class_name}_Attributes"
+          
+          klass = if const_defined?(target_attributes_class_name)
+            target_attributes_class_name.constantize
+          else
+            class_contents = <<-END
+              # typed: true
+              class ::#{target_attributes_class_name} < MangadexObject
+                #{USING_ATTRIBUTES[klass_name].map {|attribute| "sig { returns(T.untyped) }; attr_accessor(:#{attribute})"}.join(';')}
+
+                def self.attributes_to_inspect
+                  #{USING_ATTRIBUTES[klass_name]}
+                end
+              end
+            END
+
+            eval class_contents
+            Object.const_get(target_attributes_class_name)
+          end
+
+          data = data.with_indifferent_access
+
+          relationships = data['relationships']&.map do |relationship_data|
+            Relationship.from_data(relationship_data)
+          end
+
+          attributes = klass.new(**Hash(data['attributes']))
+
+          initialize_hash = {
+            id: data['id'],
+            type: data['type'] || self.type,
+            attributes: attributes,
+          }
+
+          initialize_hash.merge!({relationships: relationships}) if relationships.present?
+
+          new(**initialize_hash)
+        end
+      end
+
+      included do
+        def ==(other)
+          if other.is_a?(String)
+            id == other
+          elsif other.respond_to?(:id)
+            id == other.id
+          else
+            false
+          end
+        end
+
+        def any_relationships?
+          Array(relationships).any?
+        end
+
+        def method_missing(method_name, *args, **kwargs)
+          if self.class.attributes.include?(method_name.to_sym)
+            return if attributes.nil?
+            return unless attributes.respond_to?(method_name)
+
+            attributes.send(method_name)
+          elsif any_relationships?
+            existing_relationships = relationships.map(&:type)
+            original_relationship = method_name.to_s
+            looking_for_relationship = original_relationship.singularize
+            is_looking_for_many = original_relationship != looking_for_relationship
+
+            if existing_relationships.include?(looking_for_relationship)
+              search_method = is_looking_for_many ? :select : :find
+              relationships.send(search_method) do |relationship|
+                relationship.type == looking_for_relationship
+              end
+            elsif is_looking_for_many
+              []
+            else
+              super
+            end
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mangadex/internal.rb

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

data/lib/mangadex/manga.rb

@@ -0,0 +1,188 @@
+# typed: true
+require_relative "mangadex_object"
+
+module Mangadex
+  class Manga < MangadexObject
+    has_attributes \
+      :title,
+      :alt_titles,
+      :description,
+      :is_locked,
+      :links,
+      :original_language,
+      :last_volume,
+      :last_chapter,
+      :publication_demographic,
+      :status,
+      :year,
+      :content_rating,
+      :tags,
+      :version,
+      :created_at,
+      :updated_at
+
+    sig { params(args: T::Api::Arguments).returns(T::Api::MangaResponse) }
+    def self.list(**args)
+      to_a = Mangadex::Internal::Definition.converts(:to_a)
+
+      Mangadex::Internal::Request.get(
+        '/manga',
+        Mangadex::Internal::Definition.validate(args, {
+          limit: { accepts: Integer },
+          offset: { accepts: Integer },
+          title: { accepts: String },
+          authors: { accepts: [String] },
+          artists: { accepts: [String] },
+          year: { accepts: Integer },
+          included_tags: { accepts: [String] },
+          included_tags_mode: { accepts: %w(OR AND), converts: to_a },
+          excluded_tags: { accepts: [String] },
+          excluded_tags_mode: { accepts: %w(OR AND), converts: to_a },
+          status: { accepts: %w(ongoing completed hiatus cancelled), converts: to_a },
+          original_language: { accepts: [String] },
+          excluded_original_language: { accepts: [String] },
+          available_translated_language: { accepts: [String] },
+          publication_demographic: { accepts: %w(shounen shoujo josei seinen none), converts: to_a },
+          ids: { accepts: Array },
+          content_rating: { accepts: %w(safe suggestive erotica pornographic), converts: to_a },
+          created_at_since: { accepts: %r{^\d{4}-[0-1]\d-([0-2]\d|3[0-1])T([0-1]\d|2[0-3]):[0-5]\d:[0-5]\d$} },
+          updated_at_since: { accepts: %r{^\d{4}-[0-1]\d-([0-2]\d|3[0-1])T([0-1]\d|2[0-3]):[0-5]\d:[0-5]\d$} },
+          order: { accepts: Hash },
+          includes: { accepts: Array, converts: to_a },
+        }),
+      )
+    end
+
+    sig { params(id: String, args: T::Api::Arguments).returns(Hash) }
+    def self.volumes_and_chapters(id, **args)
+      Mangadex::Internal::Request.get(
+        '/manga/%{id}/aggregate' % {id: id},
+        Mangadex::Internal::Definition.validate(args, {
+          translated_language: { accepts: Array },
+          groups: { accepts: Array },
+        }),
+      )
+    end
+
+    sig { params(id: String, args: T::Api::Arguments).returns(T::Api::MangaResponse) }
+    def self.view(id, **args)
+      Mangadex::Internal::Request.get(
+        '/manga/%{id}' % {id: id},
+        Mangadex::Internal::Definition.validate(args, {
+          includes: { accepts: Array },
+        })
+      )
+    end
+
+    sig { params(id: String).returns(T.any(Hash, Mangadex::Api::Response)) }
+    def self.unfollow(id)
+      Mangadex::Internal::Request.delete(
+        '/manga/%{id}/follow' % {id: id},
+      )
+    end
+
+    sig { params(id: String).returns(T.any(Hash, Mangadex::Api::Response)) }
+    def self.follow(id)
+      Mangadex::Internal::Request.post(
+        '/manga/%{id}/follow' % {id: id},
+      )
+    end
+
+    sig { params(id: String, args: T::Api::Arguments).returns(T::Api::ChapterResponse) }
+    def self.feed(id, **args)
+      Mangadex::Internal::Request.get(
+        '/manga/%{id}/feed' % {id: id},
+        Mangadex::Internal::Definition.chapter_list(args),
+      )
+    end
+
+    sig { params(args: T::Api::Arguments).returns(T::Api::MangaResponse) }
+    def self.random(**args)
+      Mangadex::Internal::Request.get(
+        '/manga/random',
+        Mangadex::Internal::Definition.validate(args, {
+          includes: { accepts: Array },
+        })
+      )
+    end
+
+    sig { returns(Mangadex::Api::Response[Mangadex::Tag]) }
+    def self.tag_list
+      Mangadex::Internal::Request.get(
+        '/manga/tag'
+      )
+    end
+
+    sig { params(args: T::Api::Arguments).returns(T::Api::GenericResponse) }
+    def self.reading_status(**args)
+      Mangadex::Internal::Request.get(
+        '/manga/status',
+        Mangadex::Internal::Definition.validate(args, {
+          status: {
+            accepts: %w(reading on_hold dropped plan_to_read re_reading completed),
+            converts: Mangadex::Internal::Definition.converts(:to_a),
+          },
+        })
+      )
+    end
+
+    sig { params(id: String).returns(T::Api::GenericResponse) }
+    def self.reading_status(id)
+      Mangadex::Internal::Request.get(
+        '/manga/%{id}/status' % {id: id},
+      )
+    end
+
+    sig { returns(T::Api::GenericResponse) }
+    def self.all_reading_status
+      Mangadex::Internal::Request.get(
+        '/manga/status',
+      )
+    end
+
+    sig { params(id: String, status: String).returns(T::Api::GenericResponse) }
+    def self.update_reading_status(id, status)
+      Mangadex::Internal::Request.post(
+        '/manga/%{id}/status' % {id: id},
+        payload: Mangadex::Internal::Definition.validate({status: status}, {
+          status: {
+            accepts: %w(reading on_hold dropped plan_to_read re_reading completed),
+            required: true,
+          },
+        })
+      )
+    end
+
+    # Untested API endpoints
+    sig { params(id: String, args: T::Api::Arguments).returns(T::Api::MangaResponse) }
+    def self.update(id, **args)
+      Mangadex::Internal::Request.put('/manga/%{id}' % {id: id}, payload: args)
+    end
+
+    sig { params(id: String).returns(Hash) }
+    def self.delete(id)
+      Mangadex::Internal::Request.delete(
+        '/manga/%{id}' % {id: id},
+      )
+    end
+
+    def self.create(**args)
+      Mangadex::Internal::Request.post('/manga', payload: args)
+    end
+
+    def self.attributes_to_inspect
+      [:id, :type, :title, :content_rating, :original_language, :year]
+    end
+
+    class << self
+      alias_method :aggregate, :volumes_and_chapters
+    end
+
+    sig { returns(T.nilable(ContentRating)) }
+    def content_rating
+      return unless attributes&.content_rating.present?
+
+      ContentRating.new(attributes.content_rating)
+    end
+  end
+end

data/lib/mangadex/mangadex_object.rb

@@ -0,0 +1,62 @@
+# typed: false
+require "active_support/inflector"
+require_relative "internal/with_attributes"
+
+module Mangadex
+  class MangadexObject
+    extend T::Sig
+    include Internal::WithAttributes
+
+    def self.attributes_to_inspect
+      to_inspect = [:id, :type]
+      if self.respond_to?(:inspect_attributes)
+        to_inspect.concat(Array(self.inspect_attributes))
+      end
+
+      to_inspect
+    end
+
+    def initialize(**args)
+      args.keys.each do |attribute|
+        original_attribute = attribute
+        attribute = attribute.to_s.underscore
+        attribute_to_set = "#{attribute}="
+
+        if respond_to?(attribute_to_set)
+          if %w(created_at updated_at publish_at).include?(attribute)
+            args[original_attribute] = DateTime.parse(args[original_attribute])
+          end
+
+          send(attribute_to_set, args[original_attribute])
+        else
+          warn("Ignoring setter `#{attribute_to_set}` on #{self.class.name}...")
+        end
+      end
+
+      self.type = self.class.type if self.type.blank?
+    end
+
+    def eq?(other)
+      return id == other.id if respond_to?(:id) && other.respond_to?(:id)
+
+      super
+    end
+
+    def hash
+      id.hash
+    end
+
+    def inspect
+      string = "#<#{self.class.name}:#{self.object_id} "
+      fields = self.class.attributes_to_inspect.map do |field|
+        value = self.send(field)
+        if !value.nil?
+          "@#{field}=\"#{value}\""
+        end
+      rescue => error
+        "@#{field}[!]={#{error.class.name}: #{error.message}}"
+      end.compact
+      string << fields.join(" ") << ">"
+    end
+  end
+end

data/lib/mangadex/relationship.rb

@@ -0,0 +1,46 @@
+# typed: false
+module Mangadex
+  class Relationship < MangadexObject
+    attr_accessor :id, :type, :attributes
+
+    class << self
+      def from_data(data)
+        data = data.with_indifferent_access
+        klass = class_for_relationship_type(data['type'])
+
+        return klass.from_data(data) if klass && data['attributes']&.any?
+
+        new(
+          id: data['id'],
+          type: data['type'],
+          attributes: OpenStruct.new(data['attributes']),
+        )
+      end
+
+      private
+
+      def build_attributes(data)
+        klass = class_for_relationship_type(data['type'])
+        if klass.present?
+          klass.from_data(data)
+        else
+          OpenStruct.new(data['attributes'])
+        end
+      end
+
+      def class_for_relationship_type(type)
+        module_parts = self.name.split('::')
+        module_name = module_parts.take(module_parts.size - 1).join('::')
+        klass_name = "#{module_name}::#{type.split('_').collect(&:capitalize).join}"
+
+        return unless Object.const_defined?(klass_name)
+
+        Object.const_get(klass_name)
+      end
+    end
+
+    def inspect
+      "#<#{self.class} id=#{id.inspect} type=#{type.inspect}>"
+    end
+  end
+end