indexmap 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c3d316abdab0a6a55f613b44a0481bdf98d7d041d3d5b60b8523524450494333
+  data.tar.gz: a18dd5ad2e6db70ecef78719d8bae1a6d249fd393fe7dc363a8862fedd2faede
+SHA512:
+  metadata.gz: 8dfd199b1b978991b703870f4eb08091b8ce4689156840b7f30a985f951d55d163dce89ba71d7d8d4645931b2cb6980a4134f9b593bd8bde3b97cf272fdfbe4c
+  data.tar.gz: 875b0e45a6d3ad629f03456f62b8311f6379f3d8cde8a308ec66e6bf5233cb122a34d39531d7a245b5b7e3a3e2bc051ee7fd16d5f2981fb5e5eb6b600ef01fa8

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.2.1] - 2026-04-21
+
+### <!-- 1 -->🐛 Bug Fixes
+- publish built gem in release workflow
+
+

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ethos Link
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,174 @@
+# Indexmap
+
+[![Gem Version](https://badge.fury.io/rb/indexmap.svg)](https://badge.fury.io/rb/indexmap)
+[![Ruby](https://github.com/ethos-link/indexmap/actions/workflows/ruby.yml/badge.svg)](https://github.com/ethos-link/indexmap/actions/workflows/ruby.yml)
+
+`indexmap` is a small Ruby gem for generating XML sitemap indexes and child sitemaps from explicit section definitions.
+
+It is designed for Rails apps that want:
+
+- deterministic sitemap output
+- plain Ruby configuration
+- first-party rake tasks instead of a large DSL
+- easy extraction of sitemap logic into app-owned manifests
+
+The default output mode is a sitemap index plus one or more child sitemap files. For simpler sites, `indexmap` also supports an explicit single-file mode that writes a single `urlset` directly to `sitemap.xml`.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "indexmap"
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it directly:
+
+```bash
+gem install indexmap
+```
+
+## Ruby usage
+
+```ruby
+require "indexmap"
+
+sections = [
+  Indexmap::Section.new(
+    filename: "sitemap-marketing.xml",
+    entries: [
+      Indexmap::Entry.new(loc: "https://example.com/"),
+      Indexmap::Entry.new(loc: "https://example.com/pricing", lastmod: Date.new(2026, 4, 21))
+    ]
+  )
+]
+
+Indexmap::Writer.new(
+  sections: sections,
+  public_path: Pathname("public"),
+  base_url: "https://example.com"
+).write
+```
+
+## Rails configuration
+
+In an initializer:
+
+```ruby
+Indexmap.configure do |config|
+  config.base_url = -> { "https://example.com" }
+  config.public_path = -> { Rails.public_path }
+  config.sections = -> do
+    [
+      Indexmap::Section.new(
+        filename: "sitemap-marketing.xml",
+        entries: [
+          Indexmap::Entry.new(loc: "https://example.com/")
+        ]
+      )
+    ]
+  end
+end
+```
+
+This enables:
+
+```bash
+bin/rails sitemap:create
+bin/rails sitemap:format
+```
+
+### Single-file mode
+
+For sites that only want one `public/sitemap.xml` file:
+
+```ruby
+Indexmap.configure do |config|
+  config.base_url = -> { "https://example.com" }
+  config.public_path = -> { Rails.public_path }
+  config.format = :single_file
+  config.entries = -> do
+    [
+      Indexmap::Entry.new(loc: "https://example.com/"),
+      Indexmap::Entry.new(loc: "https://example.com/about", lastmod: Date.new(2026, 4, 21))
+    ]
+  end
+end
+```
+
+In `:single_file` mode, `indexmap` writes a `urlset` directly to `sitemap.xml`. In the default `:index` mode, it writes a sitemap index plus child sitemap files from `sections`.
+
+## Development
+
+Run tests:
+
+```bash
+bundle exec rake test
+```
+
+Run lint:
+
+```bash
+bundle exec rake standard
+```
+
+Run the full default task:
+
+```bash
+bundle exec rake
+```
+
+Note: `Gemfile.lock` is intentionally not tracked for this gem, following normal Ruby library conventions.
+
+### Git hooks
+
+We use [lefthook](https://lefthook.dev/) with the Ruby [commitlint](https://github.com/arandilopez/commitlint) gem to enforce Conventional Commits on every commit. We also use [Standard Ruby](https://standardrb.com/) to keep code style consistent. CI validates commit messages, Standard Ruby, tests, and git-cliff changelog generation on pull requests and pushes to main/master.
+
+Run the hook installer once per clone:
+
+```bash
+bundle exec lefthook install
+```
+
+## Release
+
+Releases are tag-driven and published by GitHub Actions to RubyGems. Local release commands never publish directly.
+
+Install [git-cliff](https://git-cliff.org/) locally before preparing a release. The release task regenerates `CHANGELOG.md` from Conventional Commits.
+
+Before preparing a release, make sure you are on `main` or `master` with a clean worktree.
+
+Then run one of:
+
+```bash
+bundle exec rake 'release:prepare[patch]'
+bundle exec rake 'release:prepare[minor]'
+bundle exec rake 'release:prepare[major]'
+bundle exec rake 'release:prepare[0.1.0]'
+```
+
+The task will:
+
+1. Regenerate `CHANGELOG.md` with `git-cliff`.
+1. Update `lib/indexmap/version.rb`.
+1. Commit the release changes.
+1. Create and push the `vX.Y.Z` tag.
+
+The `Release` workflow then runs tests, publishes the gem to RubyGems, and creates the GitHub release from the changelog entry.
+
+## License
+
+MIT License, see [LICENSE.txt](LICENSE.txt)
+
+## About
+
+Made by the team at [Ethos Link](https://www.ethos-link.com) — practical software for growing businesses. We build tools for hospitality operators who need clear workflows, fast onboarding, and real human support.
+
+We also build [Reviato](https://www.reviato.com), “Capture. Interpret. Act.”.
+Turn guest feedback into clear next steps for your team. Collect private appraisals, spot patterns across reviews, and act before small issues turn into public ones.

data/lib/indexmap/configuration.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Indexmap
+  class Configuration
+    VALID_FORMATS = %i[index single_file].freeze
+
+    attr_writer :base_url, :entries, :format, :index_filename, :public_path, :sections
+
+    def initialize
+      @format = :index
+      @index_filename = "sitemap.xml"
+    end
+
+    def base_url
+      resolve(@base_url)
+    end
+
+    def entries
+      Array(resolve(@entries))
+    end
+
+    def format
+      value = resolve(@format)
+      value.nil? ? :index : value.to_sym
+    end
+
+    def index_filename
+      resolve(@index_filename)
+    end
+
+    def public_path
+      value = resolve(@public_path)
+      return Pathname("public") if value.nil?
+
+      Pathname(value)
+    end
+
+    def sections
+      Array(resolve(@sections))
+    end
+
+    def writer
+      raise ConfigurationError, "Indexmap base_url is not configured" if base_url.to_s.strip.empty?
+
+      unless VALID_FORMATS.include?(format)
+        raise ConfigurationError, "Indexmap format must be one of: #{VALID_FORMATS.join(", ")}"
+      end
+
+      if format == :single_file
+        raise ConfigurationError, "Indexmap entries are not configured" if entries.empty?
+      elsif sections.empty?
+        raise ConfigurationError, "Indexmap sections are not configured" if sections.empty?
+      end
+
+      Writer.new(
+        entries: entries,
+        format: format,
+        sections: sections,
+        public_path: public_path,
+        base_url: base_url,
+        index_filename: index_filename
+      )
+    end
+
+    private
+
+    def resolve(value)
+      value.respond_to?(:call) ? value.call : value
+    end
+  end
+end

data/lib/indexmap/entry.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Indexmap
+  Entry = Struct.new(:loc, :lastmod, keyword_init: true)
+end

data/lib/indexmap/railtie.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Indexmap
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load File.expand_path("../tasks/indexmap_tasks.rake", __dir__)
+    end
+  end
+end

data/lib/indexmap/section.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Indexmap
+  Section = Struct.new(:filename, :entries, keyword_init: true)
+end

data/lib/indexmap/task_runner.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module Indexmap
+  class TaskRunner
+    def initialize(configuration: Indexmap.configuration)
+      @configuration = configuration
+    end
+
+    def create
+      remove_existing_sitemap_files
+      configuration.writer.write
+    end
+
+    def format
+      sitemap_files.each do |file_path|
+        content = File.read(file_path)
+        document = Nokogiri::XML(
+          content,
+          nil,
+          nil,
+          Nokogiri::XML::ParseOptions::DEFAULT_XML | Nokogiri::XML::ParseOptions::NOBLANKS
+        )
+        save_options = Nokogiri::XML::Node::SaveOptions::FORMAT | Nokogiri::XML::Node::SaveOptions::AS_XML
+
+        File.write(file_path, document.to_xml(indent: 2, save_with: save_options))
+      end
+    end
+
+    private
+
+    attr_reader :configuration
+
+    def sitemap_files
+      Dir.glob(configuration.public_path.join("sitemap*.xml"))
+    end
+
+    def remove_existing_sitemap_files
+      Dir.glob(configuration.public_path.join("sitemap*.xml*")).each do |file_path|
+        File.delete(file_path)
+      end
+    end
+  end
+end

data/lib/indexmap/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Indexmap
+  VERSION = "0.2.1"
+end

data/lib/indexmap/writer.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Indexmap
+  class Writer
+    VALID_FORMATS = %i[index single_file].freeze
+
+    def initialize(public_path:, base_url:, sections: nil, entries: nil, index_filename: "sitemap.xml", format: :index)
+      @entries = normalize_entries(entries)
+      @format = normalize_format(format)
+      @sections = normalize_sections(sections)
+      @public_path = Pathname(public_path)
+      @base_url = base_url
+      @index_filename = index_filename
+    end
+
+    def write
+      FileUtils.mkdir_p(public_path)
+
+      return public_path.join(index_filename).write(urlset_xml(entries)) if single_file?
+
+      sections.each do |section|
+        public_path.join(section.filename).write(urlset_xml(section.entries))
+      end
+
+      public_path.join(index_filename).write(index_xml(sections))
+    end
+
+    private
+
+    attr_reader :base_url, :entries, :format, :index_filename, :public_path, :sections
+
+    def normalize_entries(raw_entries)
+      Array(raw_entries).map { |entry| normalize_entry(entry) }
+    end
+
+    def normalize_format(value)
+      normalized = value.nil? ? :index : value.to_sym
+      return normalized if VALID_FORMATS.include?(normalized)
+
+      raise ConfigurationError, "Indexmap format must be one of: #{VALID_FORMATS.join(", ")}"
+    end
+
+    def normalize_sections(raw_sections)
+      Array(raw_sections).map do |section|
+        next section if section.is_a?(Section)
+
+        Section.new(
+          filename: section.fetch(:filename),
+          entries: section.fetch(:entries)
+        )
+      end
+    end
+
+    def single_file?
+      format == :single_file
+    end
+
+    def urlset_xml(entries)
+      lines = [
+        %(<?xml version="1.0" encoding="UTF-8"?>),
+        %(<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">)
+      ]
+
+      entries.each do |entry|
+        sitemap_entry = normalize_entry(entry)
+        lines << "  <url>"
+        lines << "    <loc>#{escape(sitemap_entry.loc)}</loc>"
+        lines << "    <lastmod>#{format_lastmod(sitemap_entry.lastmod)}</lastmod>" if sitemap_entry.lastmod
+        lines << "  </url>"
+      end
+
+      lines << "</urlset>"
+      lines.join("\n") + "\n"
+    end
+
+    def index_xml(sitemap_sections)
+      lines = [
+        %(<?xml version="1.0" encoding="UTF-8"?>),
+        %(<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">)
+      ]
+
+      sitemap_sections.each do |section|
+        lines << "  <sitemap>"
+        lines << "    <loc>#{escape(index_loc(section.filename))}</loc>"
+        lines << "    <lastmod>#{format_lastmod(section_lastmod(section))}</lastmod>"
+        lines << "  </sitemap>"
+      end
+
+      lines << "</sitemapindex>"
+      lines.join("\n") + "\n"
+    end
+
+    def normalize_entry(entry)
+      return entry if entry.is_a?(Entry)
+
+      Entry.new(loc: entry.fetch(:loc), lastmod: entry[:lastmod])
+    end
+
+    def index_loc(filename)
+      File.join(base_url.sub(%r{/\z}, ""), filename)
+    end
+
+    def section_lastmod(section)
+      timestamps = Array(section.entries).map { |entry| comparable_lastmod(normalize_entry(entry).lastmod) }.compact
+      timestamps.max || Time.now.utc
+    end
+
+    def format_lastmod(value)
+      timestamp = parsed_lastmod(value)
+
+      escape(timestamp.iso8601)
+    end
+
+    def comparable_lastmod(value)
+      parsed = parsed_lastmod(value)
+      return parsed.to_time.utc if parsed.is_a?(Date)
+
+      parsed
+    end
+
+    def parsed_lastmod(value)
+      case value
+      when String
+        Time.parse(value)
+      when Date
+        value
+      when Time, DateTime
+        value
+      else
+        value.respond_to?(:to_time) ? value.to_time : value
+      end
+    end
+
+    def escape(value)
+      CGI.escapeHTML(value.to_s)
+    end
+  end
+end

data/lib/indexmap.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "cgi"
+require "date"
+require "fileutils"
+require "pathname"
+require "time"
+
+require_relative "indexmap/version"
+require_relative "indexmap/configuration"
+require_relative "indexmap/entry"
+require_relative "indexmap/section"
+require_relative "indexmap/task_runner"
+require_relative "indexmap/writer"
+
+module Indexmap
+  class Error < StandardError; end
+
+  class ConfigurationError < Error; end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def reset!
+      @configuration = Configuration.new
+    end
+  end
+end
+
+require_relative "indexmap/railtie" if defined?(Rails::Railtie)

data/lib/tasks/indexmap_tasks.rake

@@ -0,0 +1,13 @@
+namespace :sitemap do
+  desc "Create sitemap files"
+  task create: :environment do
+    runner = Indexmap::TaskRunner.new
+    runner.create
+    runner.format
+  end
+
+  desc "Format sitemap files for better readability"
+  task format: :environment do
+    Indexmap::TaskRunner.new.format
+  end
+end

data/test/indexmap/configuration_test.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class IndexmapConfigurationTest < Minitest::Test
+  def teardown
+    Indexmap.reset!
+  end
+
+  def test_writer_builds_from_configured_callables
+    Indexmap.configure do |config|
+      config.base_url = -> { "https://example.com" }
+      config.public_path = -> { Pathname("tmp/public") }
+      config.sections = -> do
+        [Indexmap::Section.new(filename: "sitemap-pages.xml", entries: [Indexmap::Entry.new(loc: "https://example.com/")])]
+      end
+    end
+
+    writer = Indexmap.configuration.writer
+
+    assert_equal Pathname("tmp/public"), writer.instance_variable_get(:@public_path)
+  end
+
+  def test_writer_builds_single_file_writer_from_configured_entries
+    Indexmap.configure do |config|
+      config.base_url = "https://example.com"
+      config.format = :single_file
+      config.entries = -> { [Indexmap::Entry.new(loc: "https://example.com/")] }
+    end
+
+    writer = Indexmap.configuration.writer
+
+    assert_equal :single_file, writer.instance_variable_get(:@format)
+    assert_equal [Indexmap::Entry.new(loc: "https://example.com/")], writer.instance_variable_get(:@entries)
+  end
+
+  def test_writer_raises_without_base_url
+    Indexmap.configure do |config|
+      config.sections = [Indexmap::Section.new(filename: "sitemap-pages.xml", entries: [])]
+    end
+
+    error = assert_raises(Indexmap::ConfigurationError) { Indexmap.configuration.writer }
+
+    assert_equal "Indexmap base_url is not configured", error.message
+  end
+
+  def test_writer_raises_without_entries_in_single_file_mode
+    Indexmap.configure do |config|
+      config.base_url = "https://example.com"
+      config.format = :single_file
+    end
+
+    error = assert_raises(Indexmap::ConfigurationError) { Indexmap.configuration.writer }
+
+    assert_equal "Indexmap entries are not configured", error.message
+  end
+
+  def test_writer_raises_for_invalid_format
+    Indexmap.configure do |config|
+      config.base_url = "https://example.com"
+      config.format = :unsupported
+      config.sections = [Indexmap::Section.new(filename: "sitemap-pages.xml", entries: [])]
+    end
+
+    error = assert_raises(Indexmap::ConfigurationError) { Indexmap.configuration.writer }
+
+    assert_equal "Indexmap format must be one of: index, single_file", error.message
+  end
+end

data/test/indexmap/writer_test.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class IndexmapWriterTest < Minitest::Test
+  def test_writes_sitemap_index_and_child_sitemap
+    Dir.mktmpdir do |directory|
+      sections = [
+        Indexmap::Section.new(
+          filename: "sitemap-pages.xml",
+          entries: [
+            Indexmap::Entry.new(loc: "https://example.com/", lastmod: Date.new(2026, 4, 21)),
+            Indexmap::Entry.new(loc: "https://example.com/pricing", lastmod: Time.utc(2026, 4, 22, 10, 30, 0))
+          ]
+        )
+      ]
+
+      Indexmap::Writer.new(
+        sections: sections,
+        public_path: directory,
+        base_url: "https://example.com"
+      ).write
+
+      index_xml = File.read(File.join(directory, "sitemap.xml"))
+      child_xml = File.read(File.join(directory, "sitemap-pages.xml"))
+
+      assert_includes index_xml, "<loc>https://example.com/sitemap-pages.xml</loc>"
+      assert_includes child_xml, "<loc>https://example.com/</loc>"
+      assert_includes child_xml, "<loc>https://example.com/pricing</loc>"
+      assert_includes child_xml, "<lastmod>2026-04-21</lastmod>"
+      assert_includes child_xml, "<lastmod>2026-04-22T10:30:00Z</lastmod>"
+    end
+  end
+
+  def test_accepts_hash_based_sections_and_entries
+    Dir.mktmpdir do |directory|
+      Indexmap::Writer.new(
+        sections: [
+          {
+            filename: "sitemap-pages.xml",
+            entries: [
+              {loc: "https://example.com/about", lastmod: "2026-04-20T09:15:00Z"}
+            ]
+          }
+        ],
+        public_path: directory,
+        base_url: "https://example.com"
+      ).write
+
+      child_xml = File.read(File.join(directory, "sitemap-pages.xml"))
+
+      assert_includes child_xml, "<loc>https://example.com/about</loc>"
+      assert_includes child_xml, "<lastmod>2026-04-20T09:15:00Z</lastmod>"
+    end
+  end
+
+  def test_writes_single_file_urlset
+    Dir.mktmpdir do |directory|
+      Indexmap::Writer.new(
+        format: :single_file,
+        entries: [
+          Indexmap::Entry.new(loc: "https://example.com/", lastmod: Date.new(2026, 4, 21)),
+          {loc: "https://example.com/about", lastmod: "2026-04-22T09:15:00Z"}
+        ],
+        public_path: directory,
+        base_url: "https://example.com"
+      ).write
+
+      sitemap_xml = File.read(File.join(directory, "sitemap.xml"))
+
+      assert_includes sitemap_xml, "<urlset"
+      assert_includes sitemap_xml, "<loc>https://example.com/</loc>"
+      assert_includes sitemap_xml, "<loc>https://example.com/about</loc>"
+      assert_includes sitemap_xml, "<lastmod>2026-04-21</lastmod>"
+      assert_includes sitemap_xml, "<lastmod>2026-04-22T09:15:00Z</lastmod>"
+      refute_includes sitemap_xml, "<sitemapindex"
+      refute File.exist?(File.join(directory, "sitemap-pages.xml"))
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+
+require "minitest/autorun"
+require "tmpdir"
+require "date"
+
+require "indexmap"

metadata

@@ -0,0 +1,150 @@
+--- !ruby/object:Gem::Specification
+name: indexmap
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+platform: ruby
+authors:
+- Paulo Fidalgo
+- Ethos Link
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: A small Ruby gem for generating sitemap indexes and child sitemaps from
+  explicit section definitions, with optional Rails rake task integration.
+email:
+- devel@ethos-link.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/indexmap.rb
+- lib/indexmap/configuration.rb
+- lib/indexmap/entry.rb
+- lib/indexmap/railtie.rb
+- lib/indexmap/section.rb
+- lib/indexmap/task_runner.rb
+- lib/indexmap/version.rb
+- lib/indexmap/writer.rb
+- lib/tasks/indexmap_tasks.rake
+- test/indexmap/configuration_test.rb
+- test/indexmap/writer_test.rb
+- test/test_helper.rb
+homepage: https://www.ethos-link.com/opensource/indexmap
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://www.ethos-link.com/opensource/indexmap
+  source_code_uri: https://github.com/ethos-link/indexmap
+  bug_tracker_uri: https://github.com/ethos-link/indexmap/issues
+  changelog_uri: https://github.com/ethos-link/indexmap/blob/main/CHANGELOG.md
+  documentation_uri: https://github.com/ethos-link/indexmap/blob/main/README.md
+  funding_uri: https://www.reviato.com/
+  github_repo: ssh://github.com/ethos-link/indexmap
+  allowed_push_host: https://rubygems.org
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: Generate sitemap indexes and child sitemaps with plain Ruby
+test_files: []