shikimori-api 1.0.0 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 47e86dd12c49f262d518820a7c3572c8de8a73a2d7047891819a2c6be46daf83
-  data.tar.gz: 1b2872e10096765da94493d387061870757a041405fbd54a4baf76e5da19c04b
+  metadata.gz: 012cbdff8dba5946e47672d2d8646bf7cfc93df8dfabb0e3e2eec95d28e49c3a
+  data.tar.gz: '0596c4b458a7d474727f6b006e97f1ece1875c2cf5a57a69f1c72c600079c5db'
 SHA512:
-  metadata.gz: acfec6a1d8fdf30813debd7fe2dbf423f4c531a48e2c57c8ee43b7b243e69824de8c7a30aa40e1ec64bb48d94497725077ac84811a27f3f1d6f28cad4b589cc3
-  data.tar.gz: d253b3dc0191aec63c8aaca69ea258c9f63cdaf5d2cc31f140d628acfbec18abf1bf65dcfb5bccccd2025373fe8f867a8723b05ee4399d0a02353fd1611b34a6
+  metadata.gz: 3ce0a04dfab2c91dee236bb9a2580b33293ea87f6f619ab5c1000e46709d8f8d36948b4f584af708c0573b08acf077da5b1510a2ebdc84a02210700d084cf112
+  data.tar.gz: 2796b2ad37e1066c50974882765a657c1c1d46e7bb0d0965fb64c100a0f0efefa769387055e1e2872671226edcd386892ca8c4efcb25fe61948b5ee69b2123ba

data/README.md

@@ -1,20 +1,293 @@
-[![CI](https://github.com/iwdt/shikikit/actions/workflows/main.yml/badge.svg)](https://github.com/iwdt/shikikit/actions/workflows/main.yml) [![codecov](https://codecov.io/gh/iwdt/shikikit/graph/badge.svg)](https://codecov.io/gh/iwdt/shikikit)
-
 # Shikikit
-Ruby toolkit for the [Shikimori API](https://shikimori.one)
-
-## TODO:
-- logger
-- #as_app
-- proxy config
-- oauth methods on API
-- optional auto refresh token
-- more information at errors
-- more tests
-- entities for responses
-- contracts for requests (client-side validations)
-- better documentation
-- mutator
-- CI/CD
-- auto version increment on main branch pushing
-- deploy to rubygems
+Ruby toolkit for the [Shikimori](https://shikimori.one)
+
+[![Shikimori Profile](https://img.shields.io/badge/shikimori_profile-gray?logo=shikimori)](https://shikimori.one/io.human) [![Codecov](https://img.shields.io/codecov/c/gh/iwdt/shikikit?logo=codecov)](https://codecov.io/gh/iwdt/shikikit) [![CI](https://img.shields.io/github/actions/workflow/status/iwdt/shikikit/main.yml?label=CI&logo=github)](https://github.com/iwdt/shikikit/actions/workflows/main.yml) [![GitHub Discussions](https://img.shields.io/github/discussions/iwdt/shikikit?logo=github)](https://github.com/iwdt/shikikit/discussions)
+
+
+## Table of Contents
+1. [API Documentation](#api-documentation)
+2. [Omniauth Strategy](#omniauth-shikimori-strategy)
+   1. [Installation](#installation)
+   2. [Configuration](#configuration)
+   3. [Usage](#usage-examples)
+3. [OAuth2](#shikimori-oauth-2)
+   1. [Installation](#installation-1)
+   2. [Configuration](#configuration-1)
+   3. [Usage](#usage)
+4. [API Client](#shikimori-api)
+   1. [Installation](#installation-2)
+   3. [Usage](#usage-1)
+5. [Supported Ruby Versions](#supported-ruby-versions)
+6. [Versioning](#versioning)
+7. [Contributing](/CONTRIBUTING.md)
+8. [Code of conduct](/CODE_OF_CONDUCT.md)
+9. [License](/LICENSE.txt)
+
+## API Documentation
+
+* [Shikimori API](https://www.rubydoc.info/gems/shikimori-api)
+* [Shikimori OAuth2](https://www.rubydoc.info/gems/shikimori-oauth2)
+* [Omniauth Shikimori Strategy](https://www.rubydoc.info/gems/omniauth-shikimori-oauth2)
+
+## Omniauth Shikimori Strategy
+
+Strategy to authenticate with Shikimori via OAuth2 in OmniAuth. To use it, you'll need to sign up for an OAuth2 Application ID and Secret on the [Shikimori OAuth Apps Page](https://shikimori.one/oauth/applications).
+
+Shikimori's official guide to using OAuth2: https://shikimori.one/oauth
+
+[![Gem Version](https://img.shields.io/gem/v/omniauth-shikimori-oauth2?logo=rubygems&label=RubyGems)](https://rubygems.org/gems/omniauth-shikimori-oauth2)
+
+### Installation
+
+Add to your `Gemfile`:
+
+```ruby
+gem 'omniauth-shikimori-oauth2', '~> 1.0'
+```
+
+Then `bundle install`
+
+### Configuration
+
+You can configure several options, which you pass in to the `provider` method via a `Hash`:
+
+* `app_name`: the name of the registered OAuth application at https://shikimori.one/oauth/applications
+   > **⚠ WARNING!**
+   > This is an important option that must be specified, as otherwise your IP may be banned for further requests to Shikimori.
+
+* `scope`: required list of access permissions you want to request from the user. Available values:
+   - `user_rates` - modify your list of anime and manga.
+   - `messages` - read your personal messages, send personal messages on your behalf.
+   - `comments` - comment on behalf of you.
+   - `topics` - create topics and reviews on your behalf.
+   - `content` - modify the website's database.
+   - `clubs` - join and leave clubs.
+   - `friends` - add and remove people as friends.
+   - `ignores` - add and remove people to ignore.
+
+* `client_options`: optional `Hash` of client options. Available options:
+   - `site` - the OAuth2 provider site host. Default: `https://shikimori.one`
+   - `redirect_uri` - the absolute URI to the Redirection Endpoint for use in authorization grants and token exchange.
+   - `authorize_url` - absolute or relative URL path to the Authorization endpoint. Default: `/oauth/authorize`
+   - `token_url` - absolute or relative URL path to the Token endpoint. Default: `/oauth/token`
+   - `token_method` - HTTP method to use to request token (`:get`, `:post`, `:post_with_query_string`). Default: `:post`
+   - `auth_scheme` - HTTP method to use to authorize request (`:basic_auth` or `:request_body`). Default: `:basic_auth`
+   - `connection_opts` - `Hash` of connection options to pass to initialize `Faraday` with. Default: `{}`
+   - `max_redirects` - maximum number of redirects to follow. Default: `5`
+   - `raise_errors` - whether or not to raise an `OAuth2::Error` on responses with 400+ status codes. Default: `true`
+   - `logger` - which logger to use when `OAUTH_DEBUG` is enabled. Default: `::Logger.new($stdout)`
+
+Here's an example of a possible configuration:
+
+```ruby
+provider :shikimori, ENV['SHIKIMORI_KEY'], ENV['SHIKIMORI_KEY'],
+         scope: %w[user_rates messages comments topics content clubs friends ignores],
+         app_name: 'My awesome site',
+         client_options: {
+            site: 'https://shikimori.org',
+            redirect_url: 'https://my-awesome-site.example/auth/shikimori/callback',
+            logger: Rails.logger
+         }
+```
+
+### Usage examples
+#### Rails usage
+In `config/initializers/omniauth.rb`
+
+```ruby
+Rails.application.config.middleware.use OmniAuth::Builder do
+   provider :shikimori, ENV['SHIKIMORI_KEY'], ENV['SHIKIMORI_KEY'],
+            scope: %w[user_rates comments topics],
+            app_name: ENV['SHIKIMORI_APP_NAME'],
+            client_options: {
+               redirect_url: 'https://my-awesome-site.example/auth/shikimori/callback',
+               logger: Rails.logger
+            }
+end
+```
+
+#### Non-rails usage
+Add middleware to your rack-based application:
+
+```ruby
+use OmniAuth::Builder do
+   provider :shikimori, ENV['SHIKIMORI_KEY'], ENV['SHIKIMORI_SECRET'],
+            scope: %w[user_rates comments topics],
+            app_name: ENV['SHIKIMORI_APP_NAME'],
+            client_options: {
+               redirect_url: 'https://my-awesome-site.example/auth/shikimori/callback'
+            }
+end
+```
+
+## Shikimori OAuth 2
+
+A Ruby wrapper for the [Shikimori's OAuth 2](https://shikimori.one/oauth)
+
+[![Gem Version](https://img.shields.io/gem/v/shikimori-oauth2?logo=rubygems&label=RubyGems)](https://rubygems.org/gems/shikimori-oauth2)
+
+
+### Installation
+
+Install via Rubygems
+
+```bash
+gem install shikimori-oauth2
+```
+
+... or add to your Gemfile
+
+```ruby
+gem 'shikimori-oauth2', '~> 1.0'
+```
+
+Access the library in Ruby:
+
+```ruby
+require 'shikimori-oauth2'
+```
+
+### Configuration
+
+While `Shikimori::OAuth2::Client` accepts a range of options when creating a new client instance, Shikimori's configuration API allows you to set your configuration options at the module level. This is particularly handy if you're creating a number of client instances based on some shared defaults. Changing options affects new instances only and will not modify existing `Shikimori::OAuth2::Client` instances created with previous options.
+
+Configuring module defaults
+
+Every writable attribute in `Shikimori::OAuth2::Config` can be set in batch:
+
+```ruby
+Shikimori::Oauth2.configure do |c|
+  c.site = 'https://shikimori.one/'
+  c.app_name = 'My awesome site'
+  c.options = {
+   redirect_uri: 'https://my-awesome-site.example/auth/shikimori/callback',
+   authorize_url: '/oauth/authorize',
+   token_url: '/oauth/token',
+   token_method: :post,
+   auth_scheme: :basic_auth,
+   connection_opts: {},
+   max_redirects: 5,
+   raise_errors: true,
+   logger: ::Logger.new($stdout),
+  }
+end
+```
+
+Also available global options from [OAuth2 gem](https://gitlab.com/oauth-xx/oauth2#global-configuration).
+
+### Usage
+
+To get access and refresh tokens, follow this example:
+
+```ruby
+require 'shikimori-oauth2'
+
+client = Shikimori::OAuth2::Client.new('client_id', 'client_secret', app_name: 'Api test')
+client.auth_code.authorize_url(scope: 'user_rates+comments+topics', redirect_uri: 'urn:ietf:wg:oauth:2.0:oob')
+#=> https://shikimori.one/oauth/authorize?client_id=client_id&redirect_uri=urn%3Aietf%3Awg%3Aoauth%3A2.0%3Aoob&response_type=code&scope=user_rates+comments+topics
+#=> Open this link at browser and copy code
+
+access = client.auth_code.get_token('authorization_code_value', redirect_uri: 'urn:ietf:wg:oauth:2.0:oob')
+
+access.token #=> Access token
+access.refresh_token #=> Refresh token
+access.expires_in #=> 86400
+access.expires_at #=> 1708887613
+```
+
+## Shikimori API
+
+Simple wrapper for the Shikimori API
+
+[![Gem Version](https://img.shields.io/gem/v/shikimori-api?logo=rubygems&label=RubyGems)](https://rubygems.org/gems/shikimori-api)
+
+### Installation
+
+Install via Rubygems
+
+```bash
+gem install shikimori-api
+```
+
+... or add to your Gemfile
+
+```ruby
+gem 'shikimori-api', '~> 1.0'
+```
+
+Access the library in Ruby:
+
+```ruby
+require 'shikimori-api'
+```
+
+### Usage
+
+API methods are accessible as instance methods of the `Shikimori::API::Client`. Documentation is available at RubyDoc.info:
+* [V1 methods](https://www.rubydoc.info/gems/shikimori-api/Shikimori/API/V1)
+* [V2 methods](https://www.rubydoc.info/gems/shikimori-api/Shikimori/API/V2)
+
+### Examples
+
+Basic example to get 10 random anime titles released in the 90s
+
+```ruby
+client = Shikimori::API::Client.new
+client.v1.animes(limit: 10, order: 'random', season: '199x') # call /api/animes
+```
+
+To provide authentication credentials, you can pass them as arguments during client initialization:
+
+```ruby
+access_token = 'access_token' #=> User's access token
+refresh_token = 'refresh_token' #=> User's refresh token
+oauth_app_name = 'Api Test' #=> OAuth2 application name
+
+client = Shikimori::API::Client.new(app_name: oauth_app_name, access_token: access_token, refresh_token: refresh_token)
+client.v1.whoami
+```
+
+For passing additional query parameters to request use the following syntax:
+
+```ruby
+client.v1.animes(limit: 10, page: 2, another_param: 'Param')
+client.v1.anime_videos(anime_id, first_param: 1, second_param: 2)
+```
+
+... and for request headers use the following syntax:
+
+```ruby
+client.v1.animes(headers: { 'X-Header-Name' => 'My header value' })
+```
+
+For configuring a connection through proxy, you can pass `proxy_host`, `proxy_port`, `proxy_user` and `proxy_password` as arguments during client initialization:
+
+```ruby
+client = Shikimori::API::Client.new(proxy_host: 'http://my-proxy', proxy_port: 8080, proxy_user: 'my_proxy_user', proxy_password: 'my_proxy_password')
+```
+
+You can also using client as application:
+
+```ruby
+Shikimori::API::Client.as_app(access_token: 'access-token') do |client|
+   animes = client.animes
+   mangas = client.mangas
+   # some logic ...
+end
+```
+
+## Supported Ruby Versions
+This library aims to support and is tested against the following Ruby implementations:
+* Ruby 3.0
+* Ruby 3.1
+* Ruby 3.2
+* Ruby 3.3
+
+If something doesn't work on one of these Ruby versions, it's a bug.
+
+This library may inadvertently work (or seem to work) on other Ruby implementations, but support will only be provided for the versions listed above.
+
+If you would like this library to support another Ruby version, you may volunteer to be a maintainer. Being a maintainer entails making sure all tests run and pass on that implementation. When something breaks on your implementation, you will be responsible for providing patches in a timely fashion. If critical issues for a particular implementation exist at the time of a major release, support for that Ruby version may be dropped.
+
+## Versioning
+This library aims to adhere to [Semantic Versioning 2.0.0](http://semver.org/). Violations of this scheme should be reported as bugs. Specifically, if a minor or patch version is released that breaks backward compatibility, that version should be immediately yanked and/or a new version should be immediately released that restores compatibility. Breaking changes to the public API will only be introduced with new major versions. As a result of this policy, you can (and should) specify a dependency on this gem using the Pessimistic Version Constraint with two digits of precision.

data/lib/shikimori/api/client.rb

@@ -14,20 +14,42 @@ module Shikimori
 
       attr_reader :v1, :v2
 
-      def initialize(site = DEFAULT_SITE_URL, app_name:, access_token:, refresh_token:)
-        rest = REST.new(
-          access_token: access_token,
-          refresh_token: refresh_token,
-          app_name: app_name
-        )
-        @v1 = V1.new(
-          base_url: URI.new(site).join('api/'),
-          rest: rest
-        )
-        @v2 = V2.new(
-          base_url: URI.new(site).join('api/v2/'),
-          rest: rest
-        )
+      # Initialize a Shikimori's API Client
+      #
+      # @param site [String] Shikimori's base url
+      # @param options [Hash] Additional options to making requests to shikimori
+      # @option options [String] :app_name OAuth2 application name
+      # @option options [String] :access_token User's access token from OAuth2
+      # @option options [String] :refresh_token User's refresh token from OAuth2
+      # @option options [String] :proxy_host Proxy hostname
+      # @option options [Integer] :proxy_port Proxy port
+      # @option options [String] :proxy_user Proxy username
+      # @option options [String] :proxy_password Proxy password
+      def initialize(site = DEFAULT_SITE_URL, **options)
+        rest = REST.new(**options)
+        base_uri = URI.new(site)
+
+        @v1 = V1.new(base_url: base_uri.join('api/'), rest: rest)
+        @v2 = V2.new(base_url: base_uri.join('api/v2/'), rest: rest)
+      end
+
+      # Using shikimori client as application
+      #
+      # @yield [Client] client instance
+      # @example Usage example
+      #   Shikimori::API::Client.as_app(access_token: 'my-access-token') do |client|
+      #     animes = client.v1.animes
+      #     mangas = client.v1.mangas
+      #     # some logic ...
+      #   end
+      #
+      # @see #initialize
+      def self.as_app(site = DEFAULT_SITE_URL, **options)
+        client = new(site, **options)
+
+        yield client
+
+        client
       end
     end
   end

data/lib/shikimori/api/errors.rb

@@ -3,19 +3,8 @@
 module Shikimori
   module API
     class RequestError < StandardError; end
-
     class NotFoundError < RequestError; end
     class ForbiddenError < RequestError; end
-
-    # Error, when request is bad
-    class BadRequestError < RequestError
-      attr_reader :errors
-
-      def initialize(errors)
-        @errors = errors.is_a?(Hash) ? errors['errors'] : errors
-
-        super("Bad request. Errors:\n\t#{@errors.join("\n\t")}")
-      end
-    end
+    class BadRequestError < RequestError; end
   end
 end

data/lib/shikimori/api/rest.rb

@@ -4,10 +4,14 @@ module Shikimori
   module API
     # Helpers to make requests
     class REST
-      def initialize(app_name:, access_token:, refresh_token:)
+      def initialize(app_name: nil, access_token: nil, refresh_token: nil, **options)
         @app_name = app_name
         @access_token = access_token
         @refresh_token = refresh_token
+        @proxy_host = options.fetch(:proxy_host, nil)
+        @proxy_port = options.fetch(:proxy_port, nil)
+        @proxy_user = options.fetch(:proxy_user, nil)
+        @proxy_password = options.fetch(:proxy_password, nil)
       end
 
       def get(uri, **options)
@@ -67,7 +71,7 @@ module Shikimori
 
         Net::HTTP.start(
           uri.hostname.to_s, uri.port,
-          :ENV, nil, nil, nil,
+          @proxy_host, @proxy_port, @proxy_user, @proxy_password,
           use_ssl: uri.scheme == 'https'
         ) do |http|
           http.request(request)
@@ -76,8 +80,6 @@ module Shikimori
 
       def parse_response(response)
         case response
-        when Net::HTTPNoContent
-          {}
         when Net::HTTPSuccess, Net::HTTPCreated
           json_parse_response_body(response.body)
         when Net::HTTPForbidden
@@ -85,12 +87,22 @@ module Shikimori
         when Net::HTTPNotFound
           raise NotFoundError
         when Net::HTTPUnprocessableEntity, Net::HTTPBadRequest
-          raise BadRequestError, json_parse_response_body(response.body)
+          raise BadRequestError, json_parse_response_errors(response.body)
+        end
+      end
+
+      def json_parse_response_errors(body)
+        error = json_parse_response_body(body)
+
+        if error.is_a?(Array)
+          error.join(', ')
+        elsif error.is_a?(Hash) && error.key?('errors')
+          error['errors']
         end
       end
 
       def json_parse_response_body(body)
-        JSON.parse(body&.empty? ? '{}' : body)
+        JSON.parse(body.nil? || body.empty? ? '{}' : body)
       rescue JSON::ParserError
         {}
       end
@@ -100,7 +112,7 @@ module Shikimori
           'Content-Type' => 'application/json',
           'Authorization' => "Bearer #{@access_token}",
           'User-Agent' => @app_name
-        )
+        ).compact
       end
 
       def query_params_from(uri, options)

data/lib/shikimori/api/v1/people.rb

@@ -16,7 +16,7 @@ module Shikimori
         #
         # @return [Array<Hash>] Array of hashes representing people
         #
-        # @see https://shikimori.one/api/doc/1.0/people/index Shikimori's API documentation
+        # @see https://shikimori.one/api/doc/1.0/people/search Shikimori's API documentation
         # @example Search a Hayao Miyazaki at mangakas list
         #   client = Shikimori::API::Client.new(
         #     app_name: 'Api Test',

data/lib/shikimori/api/version.rb

@@ -3,6 +3,6 @@
 module Shikimori
   module API
     # @return [String] Semantic version of library
-    VERSION = '1.0.0'
+    VERSION = '1.0.2'
   end
 end

data/shikimori-api.gemspec

@@ -14,11 +14,9 @@ Gem::Specification.new do |spec|
   spec.license = 'MIT'
   spec.required_ruby_version = '>= 3.0'
 
-  spec.metadata['homepage_uri'] = spec.homepage
   spec.metadata['allowed_push_host'] = 'https://rubygems.org'
   spec.metadata['source_code_uri'] = 'https://github.com/iwdt/shikikit'
   spec.metadata['bug_tracker_uri'] = 'https://github.com/iwdt/shikikit/issues'
-  spec.metadata['changelog_uri'] = 'https://github.com/iwdt/shikikit/blob/main/CHANGELOG.md'
   spec.metadata['rubygems_mfa_required'] = 'true'
 
   spec.files = Dir[

data/sig/shikimori/api/client.rbs

@@ -6,7 +6,9 @@ module Shikimori
       attr_reader v1: V1
       attr_reader v2: V2
 
-      def initialize: (?String site, app_name: String, access_token: String, refresh_token: String) -> void
+      def initialize: (?String site, **untyped) -> void
+
+      def self.as_app: (?String site, **untyped) { (Shikimori::API::Client) -> void } -> Shikimori::API::Client
     end
   end
 end

data/sig/shikimori/api/rest.rbs

@@ -5,24 +5,29 @@ module Shikimori
       type request = Net::HTTP::Delete | Net::HTTP::Get | Net::HTTP::Post | Net::HTTP::Put
       type body = Hash[_ToS, Object] | nil
 
-      @app_name: String
-      @access_token: String
-      @refresh_token: String
+      @app_name: String | nil
+      @access_token: String | nil
+      @refresh_token: String | nil
+      @proxy_host: String | :ENV | nil
+      @proxy_port: Integer | nil
+      @proxy_user: String | nil
+      @proxy_password: String | nil
 
-      def initialize: (app_name: String, access_token: String, refresh_token: String) -> void
+      def initialize: (?app_name: String | nil, ?access_token: String | nil, ?refresh_token: String | nil, **untyped) -> void
 
       def get: (::URI::Generic, **untyped) -> untyped
       def post: (::URI::Generic, Hash[_ToS, untyped] data, **untyped) -> untyped
-      def put: (::URI::Generic, Hash[_ToS, Object] data, **untyped) -> untyped
+      def put: (::URI::Generic, Hash[_ToS, untyped] data, **untyped) -> untyped
       def delete: (::URI::Generic, **untyped) -> bool
 
       private
 
-      def request: (request_method, ::URI::Generic, ?body, **untyped) -> [Net::HTTPResponse, (::Hash[_ToS, Object] | nil)]
+      def request: (request_method, ::URI::Generic, ?body, **untyped) -> [Net::HTTPResponse, (::Hash[_ToS, Object] | nil | Array[untyped])]
       def build_request: (request_method, ::URI::Generic, **untyped) -> request
       def start_request: (::URI::Generic, request, ?body, **untyped) -> Net::HTTPResponse
-      def parse_response: (Net::HTTPResponse response) -> (::Hash[_ToS, untyped] | nil)
-      def json_parse_response_body: (String) -> (::Hash[_ToS, untyped] | nil)
+      def parse_response: (Net::HTTPResponse response) -> (::Hash[_ToS, untyped] | Array[untyped] | nil)
+      def json_parse_response_errors: (String) -> (String | nil)
+      def json_parse_response_body: (String) -> (::Hash[_ToS, untyped] | Array[untyped] | nil)
       def headers_from: (Hash[untyped, untyped]) -> Hash[String, String]
       def query_params_from: (::URI::Generic, Hash[untyped, untyped]) -> untyped
     end

data/sig/shikimori/api.rbs

@@ -10,9 +10,6 @@ module Shikimori
     end
 
     class BadRequestError < RequestError
-      attr_reader errors: Array[String]
-
-      def initialize: (Array[String] | { "errors" => Array[String] }) -> void
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shikimori-api
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.2
 platform: ruby
 authors:
 - Ivan Naumov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-02-22 00:00:00.000000000 Z
+date: 2025-08-21 00:00:00.000000000 Z
 dependencies: []
 description: Ruby toolkit for working with the Shikimori API
 email:
@@ -109,11 +109,9 @@ homepage: https://github.com/iwdt/shikikit
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/iwdt/shikikit
   allowed_push_host: https://rubygems.org
   source_code_uri: https://github.com/iwdt/shikikit
   bug_tracker_uri: https://github.com/iwdt/shikikit/issues
-  changelog_uri: https://github.com/iwdt/shikikit/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
 post_install_message: 
 rdoc_options: []
@@ -130,7 +128,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3.1
+rubygems_version: 3.2.33
 signing_key: 
 specification_version: 4
 summary: Simple wrapper for the Shikimori API