mangadex 5.3.0

data/lib/mangadex/report_reason.rb

@@ -0,0 +1,39 @@
+# typed: true
+module Mangadex
+  class ReportReason < MangadexObject
+    has_attributes \
+      :reason,
+      :details_required,
+      :category,
+      :version
+
+    class << self
+      def list(category)
+        args = Mangadex::Internal::Definition.validate({category: category}, {
+          category: { accepts: %w(manga chapter scanlation_group user), required: true },
+        })
+
+        Mangadex::Internal::Request.get(
+          '/report/reasons/%{category}' % args,
+        )
+      end
+
+      def create(**args)
+        Mangadex::Internal::Request.post(
+          '/report',
+          payload: Mangadex::Internal::Definition.validate(args, {
+            category: { accepts: %w(manga chapter scanlation_group user), required: true },
+            reason: { accepts: String, required: true },
+            object_id: { accepts: String, required: true },
+            details: { accepts: String },
+          }),
+        )
+      end
+    end
+
+    def self.attributes_to_inspect
+      self.attributes
+    end
+  end
+end
+

data/lib/mangadex/scanlation_group.rb

@@ -0,0 +1,97 @@
+# typed: false
+module Mangadex
+  class ScanlationGroup < MangadexObject
+    has_attributes \
+      :name,
+      :website,
+      :irc_channel,
+      :irc_server,
+      :discord,
+      :contact_email,
+      :description,
+      :locked,
+      :official,
+      :verified,
+      :version,
+      :created_at,
+      :updated_at
+
+    class << self
+      def list(**args)
+        Mangadex::Internal::Request.get(
+          '/group',
+          Mangadex::Internal::Definition.validate(args, {
+            limit: { accepts: Integer },
+            offset: { accepts: Integer },
+            ids: { accepts: [String] },
+            name: { accepts: String },
+            includes: { accepts: [String] },
+          }),
+        )
+      end
+
+      def create(**args)
+        Mangadex::Internal::Request.post(
+          '/group',
+          payload: Mangadex::Internal::Definition.validate(args, {
+            name: { accepts: String, required: true },
+            website: { accepts: String },
+            irc_server: { accepts: String },
+            irc_channel: { accepts: String },
+            discord: { accepts: String },
+            contact_email: { accepts: String },
+            description: { accepts: String },
+          }),
+        )
+      end
+
+      def view(id)
+        Mangadex::Internal::Request.get(
+          '/group/%{id}' % {id: id},
+          Mangadex::Internal::Definition.validate(args, {
+            includes: { accepts: [String] },
+          }),
+        )
+      end
+
+      def update(id, **args)
+        Mangadex::Internal::Request.put(
+          '/group/%{id}' % {id: id},
+          payload: Mangadex::Internal::Definition.validate(args, {
+            name: { accepts: String },
+            website: { accepts: String },
+            irc_server: { accepts: String },
+            irc_channel: { accepts: String },
+            discord: { accepts: String },
+            contact_email: { accepts: String },
+            description: { accepts: String },
+            locked: { accepts: [true, false] },
+            version: { accepts: Integer, required: true },
+          }),
+        )
+      end
+
+      def delete(id)
+        Mangadex::Internal::Request.delete(
+          '/group/%{id}' % {id: id},
+        )
+      end
+
+      def follow(id)
+        Mangadex::Internal::Request.post(
+          '/group/%{id}/follow' % {id: id},
+        )
+      end
+
+      def unfollow(id)
+        Mangadex::Internal::Request.delete(
+          '/group/%{id}/follow' % {id: id},
+        )
+      end
+    end
+
+    def self.inspect_attributes
+      self.attributes - [:version, :created_at, :updated_at]
+    end
+  end
+end

data/lib/mangadex/sorbet.rb

@@ -0,0 +1,42 @@
+# typed: false
+
+# These are custom alias Sorbet types
+
+module T
+  module Api
+    Text = T.type_alias { T.any(String, Symbol) }
+
+    Arguments = T.type_alias do
+      T.any(
+        Text,
+        T::Array[Text],
+        Integer,
+        T::Hash[Text, Text],
+      )
+    end
+    MangaResponse = T.type_alias do
+      T.any(
+        Mangadex::Api::Response[Mangadex::Manga],
+        Mangadex::Api::Response[T::Array[Mangadex::Manga]]
+      )
+    end
+    ChapterResponse = T.type_alias do
+      T.any(
+        Mangadex::Api::Response[Mangadex::Chapter],
+        Mangadex::Api::Response[T::Array[Mangadex::Chapter]]
+      )
+    end
+    GenericResponse = T.type_alias do
+      T.any(
+        ::Hash,
+        Mangadex::Api::Response,
+      )
+    end
+    ContentRating = T.type_alias do
+      T.any(
+        String,
+        ::Mangadex::ContentRating,
+      )
+    end
+  end
+end

data/lib/mangadex/tag.rb

@@ -0,0 +1,10 @@
+# typed: true
+module Mangadex
+  class Tag < MangadexObject
+    has_attributes :name, :description, :group, :version
+
+    def self.attributes_to_inspect
+      %i(name)
+    end
+  end
+end

data/lib/mangadex/types.rb

@@ -0,0 +1,24 @@
+# typed: strict
+# Utilitary classes
+require_relative "sorbet"
+require_relative "content_rating"
+require_relative "mangadex_object"
+
+# Authorization
+require_relative "auth"
+
+# Mangadex objects
+require_relative "author"
+require_relative "artist"
+require_relative "chapter"
+require_relative "cover_art"
+require_relative "custom_list"
+require_relative "manga"
+require_relative "upload"
+require_relative "user"
+require_relative "tag"
+require_relative "scanlation_group"
+require_relative "report_reason"
+
+# Relationship
+require_relative "relationship"

data/lib/mangadex/upload.rb

@@ -0,0 +1,78 @@
+# typed: false
+module Mangadex
+  class Upload < MangadexObject
+    has_attributes \
+      :is_committed,
+      :is_processed,
+      :is_deleted,
+      :version,
+      :created_at,
+      :updated_at
+
+    class << self
+      def current
+        Mangadex::Internal::Request.get(
+          '/upload',
+        )
+      end
+
+      def start(**args)
+        Mangadex::Internal::Request.post(
+          '/upload/begin',
+          payload: Mangadex::Internal::Definition.validate(args, {
+            groups: { accepts: [String], required: true },
+            manga: { accepts: String, required: true },
+          }),
+        )
+      end
+      alias_method :begin, :start
+
+      def upload_images(upload_session_id)
+        Mangadex::Internal::Request.post(
+          '/upload/%{upload_session_id}' % {upload_session_id: upload_session_id},
+          payload: Mangadex::Internal::Definition.validate(args, {
+            file: { accepts: String },
+          }),
+        )
+      end
+
+      def abandon(upload_session_id)
+        Mangadex::Internal::Request.delete(
+          '/upload/%{upload_session_id}' % {upload_session_id: upload_session_id},
+        )
+      end
+      alias_method :stop, :abandon
+
+      def commit(upload_session_id, **args)
+        Mangadex::Internal::Request.post(
+          '/upload/%{upload_session_id}/commit' % {upload_session_id: upload_session_id},
+          payload: Mangadex::Internal::Definition.validate(args, {
+            chapter_draft: { accepts: Hash }, # todo enforce chapter_draft content?
+            page_order: { accepts: [String] },
+          }),
+        )
+      end
+
+      def delete_uploaded_image(upload_session_id, upload_session_file_id)
+        Mangadex::Internal::Request.delete(
+          '/upload/%{upload_session_id}/%{upload_session_file_id}' % {
+            upload_session_id: upload_session_id,
+            upload_session_file_id: upload_session_file_id,
+          },
+        )
+      end
+
+      def delete_uploaded_images(upload_session_id, upload_session_file_ids)
+        Mangadex::Internal::Request.delete(
+          '/upload/%{upload_session_id}' % {upload_session_id: upload_session_id},
+          payload: Array(upload_session_file_id),
+        )
+      end
+    end
+
+    def self.inspect_attributes
+      [:is_committed, :is_processed, :is_deleted]
+    end
+  end
+end
+

data/lib/mangadex/user.rb

@@ -0,0 +1,103 @@
+# typed: false
+module Mangadex
+  class User < MangadexObject
+    has_attributes \
+      :username,
+      :roles,
+      :version
+
+    sig { params(args: T::Api::Arguments).returns(Mangadex::Api::Response[Mangadex::Chapter]) }
+    def self.feed(**args)
+      Mangadex::Internal::Request.get(
+        '/user/follows/manga/feed',
+        Mangadex::Internal::Definition.chapter_list(args),
+        auth: true,
+      )
+    end
+
+    sig { params(args: T::Api::Arguments).returns(Mangadex::Api::Response[Mangadex::ScanlationGroup]) }
+    def self.followed_groups(**args)
+      Mangadex::Internal::Request.get(
+        '/user/follows/group',
+        Mangadex::Internal::Definition.validate(args, {
+          limit: { accepts: Integer },
+          offset: { accepts: Integer },
+          includes: { accepts: Array },
+        }),
+        auth: true,
+      )
+    end
+
+    sig { params(id: String).returns(T::Boolean) }
+    def self.follows_group(id)
+      data = Mangadex::Internal::Request.get(
+        '/user/follows/group/%{id}' % {id: id},
+        raw: true,
+        auth: true,
+      )
+      JSON.parse(data)['result'] == 'ok'
+    rescue JSON::ParserError => error
+      warn(error)
+      false
+    end
+
+    sig { params(args: T::Api::Arguments).returns(Mangadex::Api::Response[Mangadex::User]) }
+    def self.followed_users(**args)
+      Mangadex::Internal::Request.get(
+        '/user/follows/user',
+        Mangadex::Internal::Definition.validate(args, {
+          limit: { accepts: Integer },
+          offset: { accepts: Integer },
+        }),
+        auth: true,
+      )
+    end
+
+    sig { params(id: String).returns(T::Boolean) }
+    def self.follows_user(id)
+      return if Mangadex::Api::Context.user.nil?
+
+      data = Mangadex::Internal::Request.get(
+        '/user/follows/user/%{id}' % {id: id},
+        raw: true,
+        auth: true,
+      )
+      JSON.parse(data)['result'] == 'ok'
+    rescue JSON::ParserError => error
+      warn(error)
+      false
+    end
+
+    sig { params(args: T::Api::Arguments).returns(Mangadex::Api::Response[Mangadex::Manga]) }
+    def self.followed_manga(**args)
+      Mangadex::Internal::Request.get(
+        '/user/follows/manga',
+        Mangadex::Internal::Definition.validate(args, {
+          limit: { accepts: Integer },
+          offset: { accepts: Integer },
+          includes: { accepts: Array },
+        }),
+        auth: true,
+      )
+    end
+
+    sig { params(id: String).returns(T::Boolean) }
+    def self.follows_manga(id)
+      return if Mangadex::Api::Context.user.nil?
+
+      data = Mangadex::Internal::Request.get(
+        '/user/follows/manga/%{id}' % {id: id},
+        raw: true,
+        auth: true,
+      )
+      JSON.parse(data)['result'] == 'ok'
+    rescue JSON::ParserError => error
+      warn(error)
+      false
+    end
+
+    def self.attributes_to_inspect
+      [:username, :roles]
+    end
+  end
+end

data/lib/mangadex/version.rb

@@ -0,0 +1,4 @@
+# typed: strict
+module Mangadex
+  VERSION = "5.3.0"
+end

data/lib/mangadex.rb

@@ -0,0 +1,35 @@
+# typed: strict
+require 'sorbet-runtime'
+
+require 'active_support'
+require_relative 'extensions'
+
+# The insides of the gem
+require "mangadex/version"
+require "mangadex/internal"
+
+# Types that represent all of the resources (ie: objects)
+require "mangadex/types"
+
+# API, to interact with Mangadex
+require "mangadex/api"
+
+# Namespace for classes and modules for this gem.
+# @since 5.3.0
+
+module Mangadex
+  # Standard error class for this gem.
+  # 
+  # @author thedrummeraki
+  # @since 0.6.0
+  class Error < StandardError
+    extend T::Sig
+  end
+
+  class UserNotLoggedIn < Error
+    sig { returns(String) }
+    def message
+      "You are not logged in. Use [Mangadex::Auth.login] to log in."
+    end
+  end
+end

data/mangadex.gemspec

@@ -0,0 +1,35 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "mangadex/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "mangadex"
+  spec.version       = Mangadex::VERSION
+  spec.authors       = ["Akinyele Cafe-Febrissy"]
+  spec.email         = ["me@akinyele.ca"]
+
+  spec.summary       = "Your next favourite Ruby gem for interacting with Mangadex.org"
+  spec.homepage      = "https://github.com/thedrummeraki/mangadex"
+  spec.license       = "MIT"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "psych", "~> 4.0.1"
+  spec.add_dependency "rest-client", "~> 2.1"
+  spec.add_dependency "activesupport", "~> 6.1"
+  spec.add_dependency "sorbet-runtime"
+
+  spec.add_development_dependency "bundler", "~> 2.2.19"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "sorbet"
+end

data/sorbet/config

@@ -0,0 +1,3 @@
+--dir
+.
+--ignore=/vendor/bundle