jekyll-kroki 0.5.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 39c2c3f9463c5788864d00c4ed80e9aa826a1aa1d1380dbff2be92407958f0e5
-  data.tar.gz: 38340a5a1deaa705a0b7cde596e5eb007da3d84526b2641e9cad6e9f38e86809
+  metadata.gz: 7b092bf9850f67c8e4bd7bd0d454aeeaa274b372f5ae8976f6fb05cab3f8372a
+  data.tar.gz: 1c8b189b173440b3694156281c41915c204d55b0d35d46bc866a51b0287ea73e
 SHA512:
-  metadata.gz: dbedea8bbf380c047c91cee38bc7fade0c9a6a0e3aa8735b7a18e3361219cb796fb3b89b17583db402f0b03bf083f13892d53a7677cc904d12f6be6990bfee98
-  data.tar.gz: 6c3cf11ca513c6b16331547bcd69003b77dd62c3a09b46c52e440684a5001f8c47318962037faa3a0bce5cf1e99c2dfe4a2f5f4e00f4bc0eb893ef0fb174efa6
+  metadata.gz: bc181d7f3288979cb09d8aeae9f915de5099ecbe2b0d6b3c56f941935e3d7ea264051b7fa1c0c850f476930613bb45a2723f623f3b97867b65283e752466f16a
+  data.tar.gz: 9e46a87b36b24fc80e2a9349044b87c9c0251f59a8b1060ac498b00bf7a012dbf70415be23752988684ba234de27865526db15ea7552a764d6b4953e5fd7f975

data/.devcontainer/devcontainer.json

@@ -1,6 +1,6 @@
 {
 	"name": "Ruby",
-	"image": "mcr.microsoft.com/devcontainers/ruby:3.4-bullseye",
+	"image": "mcr.microsoft.com/devcontainers/ruby:4.0-bookworm",
 	"customizations": {
 		"vscode": {
 			"extensions": [

data/.rubocop.yml

@@ -5,7 +5,7 @@ plugins:
 
 AllCops:
   NewCops: enable
-  TargetRubyVersion: 2.7
+  TargetRubyVersion: 3.0
 
 Gemspec/DevelopmentDependencies:
   EnforcedStyle: gemspec

data/.vscode/settings.json

@@ -3,5 +3,9 @@
     "editor.rulers": [
         120
     ],
-    "rubyLsp.formatter": "rubocop"
+    "rubyLsp.formatter": "rubocop",
+    "cSpell.language": "en-GB",
+    "cSpell.words": [
+        "Kroki"
+    ]
 }

data/README.md

@@ -2,9 +2,11 @@
 [![Gem Version](https://badge.fury.io/rb/jekyll-kroki.svg)](https://badge.fury.io/rb/jekyll-kroki)
 
 # jekyll-kroki
+
 A [Jekyll](https://jekyllrb.com/) plugin to convert diagram descriptions into images using [Kroki](https://kroki.io/).
 
 ## Installation
+
 Add the `jekyll-kroki` Gem to the `:jekyll_plugins` group of your site's Gemfile:
 
 ```ruby
@@ -14,6 +16,7 @@ end
 ```
 
 ## Usage
+
 Kroki supports over 25 popular diagram scripting languages, including Blockdiag, D2, GraphViz, Mermaid, and PlantUML. The [examples](https://kroki.io/examples.html) page and complete list of [supported diagram languages](https://kroki.io/#support) provide a taste of what's possible.
 
 In Markdown, simply write your diagram descriptions inside a fenced code block with the language specified:
@@ -28,27 +31,32 @@ Kroki --> Jekyll: Rendered diagram in SVG format
 ```
 ````
 
-When Jekyll builds your site, the `jekyll-kroki` plugin will encode the diagrams, send them to the Kroki server for rendering, then replace the diagram descriptions in the generated HTML with the rendered images in SVG format:
+When Jekyll builds your site, the `jekyll-kroki` plugin encodes the diagram descriptions, renders them as SVG images using the Kroki server, then embeds them in the generated HTML:
 
 ![sample-diagram](https://github.com/felixvanoost/jekyll-kroki/assets/10233016/244d2ec4-b09b-4a5f-8164-3851574c3dd2)
 
-The site remains fully static as the images are directly embedded in the HTML files served by Jekyll. Jekyll only depends on the Kroki server - which can also be run locally - during the build stage, and all of the client-side processing that is normally used to render diagrams into images is eliminated.
+Since the images are rendered and embedded at build-time, the Jekyll site remains completely static and doesn't depend on access to the Kroki server later on. This also eliminates all of the client-side processing that is typically used to render diagrams into images.
 
 ### Advantages
 
 #### Consistent syntax
+
 Instead of using Liquid tags, `jekyll-kroki` leverages the same Markdown fenced code block syntax used by both [GitLab](https://docs.gitlab.com/ee/user/markdown.html#diagrams-and-flowcharts) and [GitHub](https://docs.github.com/en/get-started/writing-on-github/working-with-advanced-formatting/creating-diagrams) to display diagrams. Besides being more consistent, this means that diagram descriptions in Markdown files can be displayed consistently as images across the GitLab/GitHub UI and on GitLab/GitHub Pages sites generated using Jekyll. GitLab currently supports Mermaid and PlantUML, while GitHub only supports Mermaid.
 
 #### Seamless GitLab integration
-Self-managed GitLab instances can additionally enable the [Kroki integration](https://docs.gitlab.com/ee/administration/integration/kroki.html), which adds support for all the same diagram scripting languages used by `jekyll-kroki`. Furthermore, by pointing both GitLab and `jekyll-kroki` to the same Kroki instance, you can guarantee that diagrams are generated using identical versions of the diagram libraries.
+
+Self-managed or dedicated GitLab instances can additionally enable the [Kroki integration](https://docs.gitlab.com/ee/administration/integration/kroki.html), which adds support for all the diagram scripting languages used by `jekyll-kroki`. Furthermore, by pointing both GitLab and `jekyll-kroki` to the same Kroki instance, you can guarantee that diagrams are generated using identical versions of the diagram libraries.
 
 #### Speed
-The server-side nature of Kroki means that you don't have to deal with installing or updating any diagram library dependencies on your machine. Jekyll sites that are generated in CI/CD pipelines will thus build faster.
+
+The server-side nature of Kroki means that you don't have to deal with installing or updating any diagram library dependencies on your machine. Jekyll sites that are generated in CI/CD pipelines can bypass these setup steps and will thus build faster. `jekyll-kroki` is built with performance in mind to minimise the build time of even the largest sites with thousands of diagrams.
 
 #### Flexibility
-Kroki is available either as a free service or self-hosted using Docker. Organisations that frequently build large Jekyll sites with many diagrams or want maximum control over their data have the option of running their own Kroki instance to provide consistency and use compute resources efficiently.
+
+Kroki is available either as a free service or self-hosted using Docker. Organisations that frequently build large Jekyll sites with many diagrams or want maximum control over their data can choose to operate their own Kroki instance to ensure consistency and use compute resources efficiently. For individuals, you can also opt to run Kroki locally.
 
 ### Configuration
+
 You can specify the following parameters in the Jekyll `_config.yml` file:
 
 | Parameter | Default value | Description |
@@ -69,7 +77,8 @@ kroki:
 ```
 
 ### Security
-Embedding diagrams as SVGs directly within HTML files can be dangerous. You should only use a Kroki instance that you trust (or run your own!). For additional security, you can configure a [Content Security Policy (CSP)](https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP) using custom Webrick headers in the Jekyll `_config.yml` file:
+
+Embedding untrusted SVGs directly in HTML files can introduce security risks. Use a Kroki instance that you trust, or consider hosting your own local/private instance. For added security, you can configure a [Content Security Policy (CSP)](https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP) by adding custom Webrick headers in your Jekyll `_config.yml` file:
 
 ```yaml
 webrick:
@@ -78,4 +87,5 @@ webrick:
 ```
 
 ## Contributing
+
 Bug reports and pull requests are welcome! For major changes, please open an issue first to discuss what you would like to change.

data/lib/jekyll/kroki/config.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Jekyll
+  class Kroki
+    # Reads, validates, and exposes the jekyll-kroki configuration from the Jekyll site config.
+    class Config
+      DEFAULT_KROKI_URL = "https://kroki.io"
+      DEFAULT_HTTP_RETRIES = 3
+      DEFAULT_HTTP_TIMEOUT = 15
+      DEFAULT_MAX_CONCURRENT_DOCS = 8
+
+      attr_reader :kroki_url, :http_retries, :http_timeout, :max_concurrent_docs
+
+      # @param [Hash] The Jekyll site configuration.
+      # @raise [TypeError] If any parameter has an incorrect type.
+      # @raise [ArgumentError] If any parameter is out of the valid range.
+      def initialize(site_config)
+        kroki_config = site_config.fetch("kroki", {})
+
+        @kroki_url = parse_url(kroki_config)
+        @http_retries = parse_integer(kroki_config, "http_retries", DEFAULT_HTTP_RETRIES, min: 0)
+        @http_timeout = parse_integer(kroki_config, "http_timeout", DEFAULT_HTTP_TIMEOUT, min: 0)
+        @max_concurrent_docs = parse_integer(kroki_config, "max_concurrent_docs", DEFAULT_MAX_CONCURRENT_DOCS, min: 1)
+
+        freeze
+      end
+
+      private
+
+      def parse_url(kroki_config)
+        param_name = "url"
+        raw = kroki_config.fetch(param_name, DEFAULT_KROKI_URL)
+        uri = URI.parse(raw)
+        raise TypeError, "'#{param_name}' is not a valid HTTP URL" unless uri.is_a?(URI::HTTP)
+
+        uri
+      end
+
+      def parse_integer(kroki_config, param_name, default, min:)
+        value = kroki_config.fetch(param_name, default)
+        raise TypeError, "'#{param_name}' must be an integer" unless value.is_a?(Integer)
+        raise ArgumentError, "'#{param_name}' must be >= #{min}" if value < min
+
+        value
+      end
+    end
+  end
+end

data/lib/jekyll/kroki/version.rb

@@ -2,6 +2,6 @@
 
 module Jekyll
   class Kroki
-    VERSION = "0.5.0"
+    VERSION = "1.0.0"
   end
 end

data/lib/jekyll/kroki.rb

@@ -1,10 +1,13 @@
 # frozen_string_literal: true
 
+require_relative "kroki/config"
 require_relative "kroki/version"
 
 require "async"
 require "async/semaphore"
 require "base64"
+require "concurrent-ruby"
+require "digest"
 require "faraday"
 require "faraday/retry"
 require "httpx/adapters/faraday"
@@ -15,130 +18,117 @@ require "zlib"
 module Jekyll
   # Converts diagram descriptions into images using Kroki.
   class Kroki
-    DEFAULT_KROKI_URL = "https://kroki.io"
-    DEFAULT_HTTP_RETRIES = 3
-    DEFAULT_HTTP_TIMEOUT = 15
-    DEFAULT_MAX_CONCURRENT_DOCS = 8
+    SUPPORTED_LANGUAGES = %w[actdiag blockdiag bpmn bytefield c4plantuml d2 dbml diagramsnet ditaa erd excalidraw
+                             graphviz mermaid nomnoml nwdiag packetdiag pikchr plantuml rackdiag seqdiag structurizr
+                             svgbob symbolator tikz umlet vega vegalite wavedrom wireviz].freeze
     EXPECTED_HTML_TAGS = %w[code div].freeze
+    DIAGRAM_SELECTOR = SUPPORTED_LANGUAGES.flat_map do |language|
+      EXPECTED_HTML_TAGS.map { |tag| "#{tag}[class~='language-#{language}']" }
+    end.join(", ").freeze
+
     HTTP_RETRY_INTERVAL_BACKOFF_FACTOR = 2
     HTTP_RETRY_INTERVAL_RANDOMNESS = 0.5
     HTTP_RETRY_INTERVAL = 0.1
-    SUPPORTED_LANGUAGES = %w[actdiag blockdiag bpmn bytefield c4plantuml d2 dbml diagramsnet ditaa erd excalidraw
-                             graphviz mermaid nomnoml nwdiag packetdiag pikchr plantuml rackdiag seqdiag structurizr
-                             svgbob symbolator tikz umlet vega vegalite wavedrom wireviz].freeze
+
+    @diagram_cache = Concurrent::Map.new
 
     class << self
       # Renders and embeds all diagram descriptions in the given Jekyll site using Kroki.
       #
       # @param [Jekyll::Site] The Jekyll site to embed diagrams in.
       def embed_site(site)
-        kroki_url = get_kroki_url(site.config)
-        http_retries = get_http_retries(site.config)
-        http_timeout = get_http_timeout(site.config)
-        connection = setup_connection(kroki_url, http_retries, http_timeout)
-
-        max_concurrent_docs = get_max_concurrent_docs(site.config)
-        rendered_diag = embed_docs_in_site(site, connection, max_concurrent_docs)
-        unless rendered_diag.zero?
-          puts "[jekyll-kroki] Rendered #{rendered_diag} diagrams using Kroki instance at '#{kroki_url}'"
-        end
-      rescue StandardError => e
-        exit(e)
+        config = Config.new(site.config)
+        connection = setup_connection(config.kroki_url, config.http_retries, config.http_timeout)
+
+        rendered_diag = embed_docs_in_site(site, connection, config.max_concurrent_docs)
+        return unless rendered_diag.positive?
+
+        Jekyll.logger.info(
+          "[jekyll-kroki] Rendered #{rendered_diag} diagrams using Kroki instance at '#{config.kroki_url}'"
+        )
       end
 
       # Renders the diagram descriptions in all Jekyll pages and documents in the given Jekyll site. Pages / documents
-      # are rendered concurrently up to the limit defined by DEFAULT_MAX_CONCURRENT_DOCS.
+      # are rendered concurrently up to the limit defined by max_concurrent_docs.
       #
       # @param [Jekyll::Site] The Jekyll site to embed diagrams in.
       # @param [Faraday::Connection] The Faraday connection to use.
       # @param [Integer] The maximum number of documents to render concurrently.
       # @return [Integer] The number of successfully rendered diagrams.
       def embed_docs_in_site(site, connection, max_concurrent_docs)
-        rendered_diag = 0
         semaphore = Async::Semaphore.new(max_concurrent_docs)
 
-        Async do |task|
-          tasks = (site.pages + site.documents).filter_map do |doc|
+        Async do
+          (site.pages + site.documents).filter_map do |doc|
             next unless embeddable?(doc)
 
-            async_embed_single_doc(task, semaphore, connection, doc)
-          end
-
-          rendered_diag = tasks.sum(&:wait)
-        end
-
-        rendered_diag
-      end
-
-      # Renders the supported diagram descriptions in a single document asynchronously, respecting the concurrency limit
-      # imposed by the provided semaphore.
-      #
-      # @param [Async::Task] The parent async task to spawn a child task from.
-      # @param [Async::Semaphore] A semaphore to limit concurrency.
-      # @param [Faraday::Connection] The Faraday connection to use.
-      # @param [Jekyll::Page, Jekyll::Document] The document to process.
-      # @return [Integer] The number of successfully rendered diagrams.
-      def async_embed_single_doc(task, semaphore, connection, doc)
-        task.async do
-          semaphore.async { embed_single_doc(connection, doc) }.wait
-        rescue StandardError => e
-          warn "[jekyll-kroki] Error rendering diagram: #{e.message}".red
-          0
-        end
+            semaphore.async do
+              embed_single_doc(connection, doc)
+            rescue StandardError => e
+              Jekyll.logger.error "[jekyll-kroki] Failed to render diagram in '#{doc.relative_path}': #{e.message}"
+              0
+            end
+          end.sum(&:wait)
+        end.wait
       end
 
-      # Renders the supported diagram descriptions in a single document and embeds them as inline SVGs in the HTML
-      # source.
+      # Renders the supported diagram descriptions in a single document sequentially and embeds them as inline SVGs in
+      # the HTML source. Returns without modifying the document if no supported diagram descriptions are found.
       #
       # @param [Faraday::Connection] The Faraday connection to use.
       # @param [Jekyll::Page, Jekyll::Document] The document to process.
       # @return [Integer] The number of successfully rendered diagrams.
       def embed_single_doc(connection, doc)
-        # Parse the HTML document.
         parsed_doc = Nokogiri::HTML(doc.output)
+        nodes = parsed_doc.css(DIAGRAM_SELECTOR)
+        return 0 if nodes.empty?
 
-        rendered_diag = 0
-        SUPPORTED_LANGUAGES.each do |language|
-          EXPECTED_HTML_TAGS.each do |tag|
-            parsed_doc.css("#{tag}[class~='language-#{language}']").each do |diagram_desc|
-              # Replace the diagram description with the SVG representation rendered by Kroki.
-              diagram_desc.replace(render_diagram(connection, diagram_desc, language))
-              rendered_diag += 1
-            end
-          end
+        nodes.each do |node|
+          # Extract the diagram language from the class list.
+          language = node["class"].split.grep(/\Alanguage-/).first.delete_prefix("language-")
+          node.replace(render_diagram(connection, node.text, language))
         end
 
         # Convert the document back to HTML.
         doc.output = parsed_doc.to_html
-        rendered_diag
+        nodes.size
       end
 
-      # Renders a single diagram description using Kroki.
+      # Renders a single diagram description using Kroki. The rendered diagram is cached to avoid redundant HTTP
+      # requests across documents, using the diagram language and the SHA1 of the diagram description as the key.
       #
       # @param [Faraday::Connection] The Faraday connection to use.
       # @param [String] The diagram description.
       # @param [String] The language of the diagram description.
       # @return [String] The rendered diagram in SVG format.
-      def render_diagram(connection, diagram_desc, language)
-        begin
-          response = connection.get("#{language}/svg/#{encode_diagram(diagram_desc.text)}")
-        rescue Faraday::Error => e
-          raise e.message
+      def render_diagram(connection, diagram_text, language)
+        cache_key = "#{language}:#{Digest::SHA1.hexdigest(diagram_text)}"
+        @diagram_cache.compute_if_absent(cache_key) do
+          response = connection.get("#{language}/svg/#{encode_diagram(diagram_text)}")
+          validate_content_type(response)
+          sanitise_diagram(response.body)
+        rescue Faraday::BadRequestError => e
+          kroki_message = e.response_body.to_s.strip
+          raise e, (kroki_message.empty? ? e.message : kroki_message)
         end
+      end
+
+      # Validates that the Kroki response has the expected SVG content type.
+      #
+      # @param [Faraday::Response] The response to validate.
+      def validate_content_type(response)
         expected_content_type = "image/svg+xml"
         returned_content_type = response.headers[:content_type]
-        if returned_content_type != expected_content_type
-          raise "Kroki returned an incorrect content type: " \
-                "expected '#{expected_content_type}', received '#{returned_content_type}'"
+        return if returned_content_type == expected_content_type
 
-        end
-        sanitise_diagram(response.body)
+        raise "[jekyll-kroki] Kroki returned an incorrect content type: " \
+              "expected '#{expected_content_type}', received '#{returned_content_type}'"
       end
 
       # Sanitises a rendered diagram. Only <script> elements are removed, which is the most minimal / naive
       # implementation possible.
       #
-      # @param [String] The diagram to santise in SVG format.
+      # @param [String] The diagram to sanitise in SVG format.
       # @return [String] The sanitised diagram.
       def sanitise_diagram(diagram_svg)
         parsed_svg = Nokogiri::XML(diagram_svg)
@@ -149,10 +139,10 @@ module Jekyll
       # Encodes the diagram into Kroki format using deflate + base64.
       # See https://docs.kroki.io/kroki/setup/encode-diagram/.
       #
-      # @param [String, #read] The diagram description to encode.
+      # @param [String] The diagram description to encode.
       # @return [String] The encoded diagram.
       def encode_diagram(diagram_desc)
-        Base64.urlsafe_encode64(Zlib.deflate(diagram_desc))
+        Base64.urlsafe_encode64(Zlib.deflate(diagram_desc, Zlib::BEST_COMPRESSION))
       end
 
       # Sets up a new Faraday connection.
@@ -175,69 +165,20 @@ module Jekyll
         end
       end
 
-      # Gets the URL of the Kroki instance to use for rendering diagrams.
-      #
-      # @param The Jekyll site configuration.
-      # @return [URI::HTTP] The URL of the Kroki instance.
-      def get_kroki_url(config)
-        url = config.fetch("kroki", {}).fetch("url", DEFAULT_KROKI_URL)
-        raise TypeError, "'url' is not a valid HTTP URL" unless URI.parse(url).is_a?(URI::HTTP)
-
-        URI(url)
-      end
-
-      # Gets the number of HTTP retries.
-      #
-      # @param The Jekyll site configuration.
-      # @return [Integer] The number of HTTP retries.
-      def get_http_retries(config)
-        config.fetch("kroki", {}).fetch("http_retries", DEFAULT_HTTP_RETRIES)
-      end
-
-      # Gets the HTTP timeout value.
-      #
-      # @param The Jekyll site configuration.
-      # @return [Integer] The HTTP timeout value in seconds.
-      def get_http_timeout(config)
-        config.fetch("kroki", {}).fetch("http_timeout", DEFAULT_HTTP_TIMEOUT)
-      end
-
-      # Gets the maximum number of documents to render concurrently.
-      #
-      # @param The Jekyll site configuration.
-      # @return [Integer] The maximum number of documents to render concurrently.
-      def get_max_concurrent_docs(config)
-        config.fetch("kroki", {}).fetch("max_concurrent_docs", DEFAULT_MAX_CONCURRENT_DOCS)
-      end
-
       # Determines whether a document may contain embeddable diagram descriptions; it is in HTML format and is either
       # a Jekyll::Page or writeable Jekyll::Document.
       #
-      # @param [Jekyll::Page or Jekyll::Document] The document to check for embeddability.
+      # @param [Jekyll::Page or Jekyll::Document] The document to check for embeddable diagrams.
       def embeddable?(doc)
         doc.output_ext == ".html" && (doc.is_a?(Jekyll::Page) || doc.write?)
       end
-
-      # Exits the Jekyll process without returning a stack trace. This method does not return because the process is
-      # abruptly terminated.
-      #
-      # @param [StandardError] The error to display in the termination message.
-      # @param [int] The caller index to display in the termination message. The default index is 1, which means the
-      #              calling method. To specify the calling method's caller, pass in 2.
-      #
-      # Source: https://www.mslinn.com/ruby/2200-crash-exit.html
-      def exit(error, caller_index = 1)
-        raise error
-      rescue StandardError => e
-        file, line_number, caller = e.backtrace[caller_index].split(":")
-        caller = caller.tr("", "'")
-        warn %([jekyll-kroki] "#{error.message}" #{caller} on line #{line_number} of #{file}).red
-        exec "exit 1"
-      end
     end
   end
 end
 
 Jekyll::Hooks.register :site, :post_render do |site|
   Jekyll::Kroki.embed_site(site)
+rescue StandardError => e
+  Jekyll.logger.error "[jekyll-kroki] #{e.class}: #{e.message}"
+  raise
 end

metadata

@@ -1,11 +1,11 @@
 --- !ruby/object:Gem::Specification
 name: jekyll-kroki
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Felix van Oost
-bindir: exe
+bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
@@ -23,6 +23,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.25'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement
@@ -190,14 +204,13 @@ files:
 - LICENSE
 - README.md
 - Rakefile
-- jekyll-kroki.gemspec
 - lib/jekyll/kroki.rb
+- lib/jekyll/kroki/config.rb
 - lib/jekyll/kroki/version.rb
 homepage: https://github.com/felixvanoost/jekyll-kroki
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/felixvanoost/jekyll-kroki
   source_code_uri: https://github.com/felixvanoost/jekyll-kroki
   rubygems_mfa_required: 'true'
 rdoc_options: []
@@ -207,14 +220,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.0
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 4.0.10
 specification_version: 4
 summary: A Jekyll plugin to convert diagram descriptions into images using Kroki
 test_files: []

data/jekyll-kroki.gemspec

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "lib/jekyll/kroki/version"
-
-Gem::Specification.new do |spec|
-  spec.name = "jekyll-kroki"
-  spec.version = Jekyll::Kroki::VERSION
-  spec.authors = ["Felix van Oost"]
-
-  spec.summary = "A Jekyll plugin to convert diagram descriptions into images using Kroki"
-  spec.description = "A Jekyll plugin to convert diagram descriptions written in over 25 popular diagram scripting
-                      languages into images using Kroki"
-  spec.homepage = "https://github.com/felixvanoost/jekyll-kroki"
-  spec.license = "MIT"
-  spec.required_ruby_version = ">= 2.7.0"
-
-  spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = spec.homepage
-  spec.metadata["rubygems_mfa_required"] = "true"
-
-  # Load the files that are versioned in Git into the RubyGem.
-  spec.files = Dir.chdir(__dir__) do
-    `git ls-files -z`.split("\x0").reject do |f|
-      (File.expand_path(f) == __FILE__) ||
-        f.start_with?(*%w[bin/ test/ spec/ features/ .git appveyor Gemfile])
-    end
-  end
-  spec.bindir = "exe"
-  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-
-  spec.add_dependency "async", ["~> 2.25"]
-  spec.add_dependency "faraday", ["~> 2.7"]
-  spec.add_dependency "faraday-retry", ["~> 2.2"]
-  spec.add_dependency "httpx", ["~> 1.1"]
-  spec.add_dependency "jekyll", ["~> 4"]
-  spec.add_dependency "nokogiri", ["~> 1.15"]
-
-  spec.add_development_dependency "minitest", ["~> 5.0"]
-  spec.add_development_dependency "rake", ["~> 13.0"]
-  spec.add_development_dependency "rubocop", ["~> 1.21"]
-  spec.add_development_dependency "rubocop-minitest", ["~> 0.38"]
-  spec.add_development_dependency "rubocop-performance", ["~> 1.25"]
-  spec.add_development_dependency "rubocop-rake", ["~> 0.7"]
-end