indexmap 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 38fa952c31358e79a900d348041a2475d5f597d19652837b50d27713f2004250
-  data.tar.gz: 6889768f6be1e01b6de1938687a757b050a52f7f9dbf2af58d1818cca2fdc977
+  metadata.gz: ef452a5928b87f84f65ecb9ba2afcab5340d9d09c5d8c8dfd8c4ffb3217a68fd
+  data.tar.gz: 03b11e1d9360bbd797d6b61886c99d1619247877dfd2c4676efeca9a1119764c
 SHA512:
-  metadata.gz: 612858ebdac07d01107af653411182685e161b1e501670e569d84265e1dbcd455dbb6a7e55615f802d112037875d9eb15d94c11747a2c15e6cbd1b9f63b804de
-  data.tar.gz: 512df6e55dbad711516e9558cda07b0b90b65f7f950441e36699fe696965296690c52a478247b707ff9e15801b49b73a5d3428cea92dd1e0b49e9861c14580d2
+  metadata.gz: a04a772029e2438636df90b65004a27c54e1cf3360205fd556feff615768fd527668fe2a3e3063f2831b9af9afb4edd983e48e73b922278c4c10a63d936b938e
+  data.tar.gz: 6ce68d9ee6343aaf7c4bbff6860a712d743899390b4a8a3a09c712694c95cff32cc0acd85f30a43e2ba37f0c8ff671d2af11028e63976649ae90e5100d5e0a1b

data/CHANGELOG.md

@@ -5,12 +5,14 @@ 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.5.0] - 2026-04-24
+## [0.6.0] - 2026-05-01
 
 
-### Fixed
+### Added
 
-- namespace rake tasks and harden sitemap validation (#8)
+- add the url count to google ping output (#9)
+
+- support named sitemap outputs (#10)
 
 
 

data/README.md

@@ -85,7 +85,10 @@ bin/rails indexmap:sitemap:format
 bin/rails indexmap:sitemap:validate
 ```
 
-`indexmap:sitemap:create` is the main task. It writes sitemap files, formats them, and validates the result.
+`indexmap:sitemap:create` is the main task. It writes sitemap files to a local
+temporary directory, formats them, validates the result, then replaces the final
+XML files. Existing sitemap files are left untouched if generation or validation
+fails.
 
 ### Default Index Mode
 
@@ -114,6 +117,85 @@ end
 
 In `:single_file` mode, `indexmap` writes a `urlset` directly to `sitemap.xml` and reads entries from `config.entries` instead of `config.sections`.
 
+### Named Outputs
+
+Most apps only need the default output. Use named outputs when one part of the
+sitemap must be generated separately, for example when static pages can be
+generated during deploy but database-heavy pages should refresh later. Named
+outputs still write normal sitemap XML files to a filesystem path; storage and
+serving are application concerns.
+
+```ruby
+Indexmap.configure do |config|
+  config.base_url = -> { "https://example.com" }
+  config.public_path = -> { Rails.root.join("storage/sitemaps") }
+  config.sections = -> { Sitemap.sections }
+
+  config.output :insights_data do |output|
+    output.format = :single_file
+    output.index_filename = "sitemap-insights-data.xml"
+    output.entries = -> { Sitemap.insights_data_entries }
+  end
+end
+```
+
+Generate the default output:
+
+```ruby
+Indexmap.create
+```
+
+Generate only the named output:
+
+```ruby
+Indexmap.create(:insights_data)
+```
+
+Named outputs inherit `base_url`, `public_path`, and `format` from the main
+configuration unless you override them.
+
+`Indexmap.create` uses the same safe local publish flow as the rake task:
+generate in a temporary directory, format, validate, and then replace the final
+XML file or files.
+
+### Deferred Dynamic Sections
+
+Use `after_create` when `indexmap:sitemap:create` should publish the default
+sitemap first, then schedule slower dynamic sections for the background. The
+callback runs only after the generated files have been formatted, validated, and
+replaced successfully.
+
+```ruby
+Indexmap.configure do |config|
+  config.base_url = -> { "https://example.com" }
+  config.public_path = -> { Rails.root.join("storage/sitemaps") }
+  config.sections = -> { Sitemap.sections }
+
+  config.output :insights_data do |output|
+    output.format = :single_file
+    output.index_filename = "sitemap-insights-data.xml"
+    output.entries = -> { Sitemap.insights_data_entries }
+  end
+
+  config.after_create do
+    Insights::SitemapRefreshJob.perform_later
+  end
+end
+```
+
+Then the job can stay small:
+
+```ruby
+class Insights::SitemapRefreshJob < ApplicationJob
+  def perform
+    Indexmap.create(:insights_data)
+  end
+end
+```
+
+This keeps deploys fast: the deploy only waits for `indexmap:sitemap:create`,
+while database-dependent output is refreshed by the job backend.
+
 ## Validation And Parsing
 
 `indexmap` also includes small utilities for working with generated sitemap files:

data/lib/indexmap/configuration.rb

@@ -9,6 +9,8 @@ module Indexmap
     def initialize
       @format = :index
       @index_filename = "sitemap.xml"
+      @after_create_callbacks = []
+      @outputs = {}
     end
 
     def base_url
@@ -47,27 +49,29 @@ module Indexmap
       Array(resolve(@sections))
     end
 
+    def output(name)
+      output = output_for(name)
+      yield(output) if block_given?
+      output
+    end
+
+    def output_for(name = :default)
+      normalized_name = name.to_sym
+      @outputs[normalized_name] ||= Output.new(configuration: self)
+    end
+
+    def after_create(&block)
+      raise ArgumentError, "after_create requires a block" unless block
+
+      @after_create_callbacks << block
+    end
+
+    def run_after_create_callbacks
+      @after_create_callbacks.each(&:call)
+    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
-      )
+      output_for(:default).writer
     end
 
     private

data/lib/indexmap/creator.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+require "tmpdir"
+
+module Indexmap
+  class Creator
+    ValidationConfiguration = Struct.new(:base_url, keyword_init: true)
+
+    def initialize(output:)
+      @output = output
+    end
+
+    def create
+      FileUtils.mkdir_p(output.public_path.dirname)
+
+      Dir.mktmpdir("indexmap", output.public_path.dirname) do |dir|
+        staging_path = Pathname(dir)
+        written_files = write_to(staging_path)
+        sitemap_files = sitemap_files_in(staging_path)
+
+        format(sitemap_files)
+        validate(staging_path.join(output.index_filename))
+
+        publish(sitemap_files)
+        written_files.map { |path| output.public_path.join(path.basename) }
+      end
+    end
+
+    private
+
+    attr_reader :output
+
+    def write_to(staging_path)
+      output.writer.tap do |writer|
+        writer.public_path = staging_path
+      end.write
+    end
+
+    def sitemap_files_in(path)
+      path.glob("sitemap*.xml").sort
+    end
+
+    def format(files)
+      files.each do |file_path|
+        document = Nokogiri::XML(
+          file_path.read,
+          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_path.write(document.to_xml(indent: 2, save_with: save_options))
+      end
+    end
+
+    def validate(index_path)
+      Validator.new(
+        configuration: ValidationConfiguration.new(base_url: output.base_url),
+        path: index_path
+      ).validate!
+    end
+
+    def publish(files)
+      FileUtils.mkdir_p(output.public_path)
+
+      files.map do |file_path|
+        final_path = output.public_path.join(file_path.basename)
+        File.rename(file_path, final_path)
+        final_path
+      end
+    end
+  end
+end

data/lib/indexmap/output.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Indexmap
+  class Output
+    VALID_FORMATS = %i[index single_file].freeze
+
+    attr_writer :base_url, :entries, :format, :index_filename, :public_path, :sections
+
+    def initialize(configuration:)
+      @configuration = configuration
+    end
+
+    def base_url
+      resolve(@base_url) || configuration.base_url
+    end
+
+    def entries
+      resolved_entries = resolve(@entries)
+
+      Array(resolved_entries.nil? ? configuration.entries : resolved_entries)
+    end
+
+    def format
+      value = resolve(@format) || configuration.format
+      value.nil? ? :index : value.to_sym
+    end
+
+    def index_filename
+      resolve(@index_filename) || configuration.index_filename
+    end
+
+    def public_path
+      value = resolve(@public_path) || configuration.public_path
+      Pathname(value)
+    end
+
+    def sections
+      resolved_sections = resolve(@sections)
+
+      Array(resolved_sections.nil? ? configuration.sections : resolved_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
+
+    attr_reader :configuration
+
+    def resolve(value)
+      value.respond_to?(:call) ? value.call : value
+    end
+  end
+end

data/lib/indexmap/parser.rb

@@ -2,7 +2,6 @@
 
 require "net/http"
 require "nokogiri"
-require "pathname"
 require "uri"
 
 module Indexmap

data/lib/indexmap/path.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "pathname"
 require "uri"
 
 module Indexmap

data/lib/indexmap/pinger/google.rb

@@ -20,10 +20,11 @@ module Indexmap
           return {status: :skipped, reason: :missing_credentials}
         end
 
-        results = sitemap_files.map { |sitemap_file| ping_sitemap(sitemap_file) }
+        files = sitemap_files
+        results = files.map { |sitemap_file| ping_sitemap(sitemap_file) }
         return {status: :skipped, reason: :no_sitemaps} if results.empty?
 
-        summarize_results(results)
+        summarize_results(results, url_count: sitemap_url_count(files))
       end
 
       private
@@ -90,16 +91,26 @@ module Indexmap
         )
       end
 
-      def summarize_results(results)
+      def sitemap_url_count(files)
+        files.each_with_object(Set.new) do |sitemap_file, urls|
+          Parser.new(path: sitemap_file).entries.each do |entry|
+            loc = entry.loc.to_s.strip
+            urls.add(loc) unless loc.empty?
+          end
+        end.count
+      end
+
+      def summarize_results(results, url_count:)
         submitted = results.select { |result| result[:status] == :submitted }
         failures = results.select { |result| result[:status] == :failed }
 
-        return {status: :submitted, sitemap_count: submitted.count, submitted: submitted} if failures.empty?
-        return {status: :failed, sitemap_count: 0, failures: failures} if submitted.empty?
+        return {status: :submitted, sitemap_count: submitted.count, url_count: url_count, submitted: submitted} if failures.empty?
+        return {status: :failed, sitemap_count: 0, url_count: 0, failures: failures} if submitted.empty?
 
         {
           status: :partial,
           sitemap_count: submitted.count,
+          url_count: url_count,
           submitted: submitted,
           failures: failures
         }

data/lib/indexmap/task_runner.rb

@@ -9,9 +9,11 @@ module Indexmap
     end
 
     def create
-      remove_existing_sitemap_files
-      configuration.writer.write
-      {files: sitemap_files, index_now_key_path: write_index_now_key}
+      written_files = Indexmap.create(configuration: configuration)
+      index_now_key_path = write_index_now_key
+      configuration.run_after_create_callbacks
+
+      {files: written_files.map(&:to_s), written_files: written_files, index_now_key_path: index_now_key_path}
     end
 
     def format
@@ -44,21 +46,19 @@ module Indexmap
     end
 
     def public_path
-      configuration.public_path
+      default_output.public_path
     end
 
     private
 
     attr_reader :configuration
 
-    def remove_existing_sitemap_files
-      Dir.glob(configuration.public_path.join("sitemap*.xml*")).each do |file_path|
-        File.delete(file_path)
-      end
+    def default_output
+      configuration.output_for(:default)
     end
 
     def sitemap_files
-      Dir.glob(configuration.public_path.join("sitemap*.xml")).sort
+      Dir.glob(public_path.join("sitemap*.xml")).sort
     end
   end
 end

data/lib/indexmap/version.rb

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

data/lib/indexmap/writer.rb

@@ -16,18 +16,20 @@ module Indexmap
     def write
       FileUtils.mkdir_p(public_path)
 
-      return public_path.join(index_filename).write(urlset_xml(entries)) if single_file?
+      return [write_file(index_filename, urlset_xml(entries))] if single_file?
 
-      sections.each do |section|
-        public_path.join(section.filename).write(urlset_xml(section.entries))
+      paths = sections.map do |section|
+        write_file(section.filename, urlset_xml(section.entries))
       end
 
-      public_path.join(index_filename).write(index_xml(sections))
+      paths + [write_file(index_filename, index_xml(sections))]
     end
 
+    attr_accessor :public_path
+
     private
 
-    attr_reader :base_url, :entries, :format, :index_filename, :public_path, :sections
+    attr_reader :base_url, :entries, :format, :index_filename, :sections
 
     def normalize_entries(raw_entries)
       Array(raw_entries).map { |entry| normalize_entry(entry) }
@@ -55,6 +57,12 @@ module Indexmap
       format == :single_file
     end
 
+    def write_file(filename, body)
+      path = public_path.join(filename)
+      path.write(body)
+      path
+    end
+
     def urlset_xml(entries)
       lines = [
         %(<?xml version="1.0" encoding="UTF-8"?>),

data/lib/indexmap.rb

@@ -3,14 +3,15 @@
 require "cgi"
 require "date"
 require "fileutils"
-require "pathname"
 require "time"
 
 require_relative "indexmap/version"
 require_relative "indexmap/google_configuration"
 require_relative "indexmap/index_now_configuration"
 require_relative "indexmap/configuration"
+require_relative "indexmap/creator"
 require_relative "indexmap/entry"
+require_relative "indexmap/output"
 require_relative "indexmap/path"
 require_relative "indexmap/parser"
 require_relative "indexmap/pinger/base"
@@ -39,6 +40,10 @@ module Indexmap
     def reset!
       @configuration = Configuration.new
     end
+
+    def create(output_name = :default, configuration: self.configuration)
+      Creator.new(output: configuration.output_for(output_name)).create
+    end
   end
 end
 

data/lib/tasks/indexmap_tasks.rake

@@ -4,10 +4,8 @@ namespace :indexmap do
     task create: :environment do
       runner = Indexmap::TaskRunner.new
       create_result = runner.create
-      runner.format
-      validated_files = runner.validate
 
-      puts "Created, formatted, and validated #{file_count(validated_files)} in #{public_directory(runner)}."
+      puts "Created, formatted, and validated #{file_count(create_result[:files])} in #{public_directory(runner)}."
       puts "IndexNow key file: #{create_result[:index_now_key_path]}" if create_result[:index_now_key_path]
     end
 
@@ -41,9 +39,9 @@ namespace :indexmap do
 
       case result[:status]
       when :submitted
-        puts "Submitted #{result[:sitemap_count]} sitemap #{(result[:sitemap_count] == 1) ? "file" : "files"} to Google Search Console."
+        puts "Submitted #{result[:sitemap_count]} sitemap #{(result[:sitemap_count] == 1) ? "file" : "files"} with #{result[:url_count]} URL#{"s" unless result[:url_count] == 1} to Google Search Console."
       when :partial
-        puts "Submitted #{result[:sitemap_count]} sitemap #{(result[:sitemap_count] == 1) ? "file" : "files"} to Google Search Console, with #{result[:failures].count} failure#{"s" unless result[:failures].count == 1}."
+        puts "Submitted #{result[:sitemap_count]} sitemap #{(result[:sitemap_count] == 1) ? "file" : "files"} with #{result[:url_count]} URL#{"s" unless result[:url_count] == 1} to Google Search Console, with #{result[:failures].count} failure#{"s" unless result[:failures].count == 1}."
         result[:failures].each { |failure| puts format_google_ping_failure(failure) }
       when :failed
         result[:failures].each { |failure| puts format_google_ping_failure(failure) }

data/test/indexmap/configuration_test.rb

@@ -91,4 +91,138 @@ class IndexmapConfigurationTest < Minitest::Test
     assert_equal "example-key", Indexmap.configuration.index_now.key
     assert_equal 250, Indexmap.configuration.index_now.max_urls_per_request
   end
+
+  def test_named_outputs_inherit_configuration_defaults
+    Dir.mktmpdir do |dir|
+      public_path = Pathname(dir)
+
+      Indexmap.configure do |config|
+        config.base_url = "https://example.com"
+        config.public_path = public_path
+        config.output :reports do |output|
+          output.sections = [
+            Indexmap::Section.new(
+              filename: "sitemap-reports.xml",
+              entries: [Indexmap::Entry.new(loc: "https://example.com/reports")]
+            )
+          ]
+        end
+      end
+
+      files = Indexmap.create(:reports)
+
+      assert_equal [
+        public_path.join("sitemap-reports.xml"),
+        public_path.join("sitemap.xml")
+      ], files
+      assert_includes public_path.join("sitemap.xml").read, "https://example.com/sitemap-reports.xml"
+    end
+  end
+
+  def test_create_writes_named_output_to_public_path
+    Dir.mktmpdir do |dir|
+      public_path = Pathname(dir)
+
+      Indexmap.configure do |config|
+        config.base_url = "https://example.com"
+        config.public_path = public_path
+        config.output :dynamic do |output|
+          output.sections = [
+            Indexmap::Section.new(
+              filename: "sitemap-dynamic.xml",
+              entries: [Indexmap::Entry.new(loc: "https://example.com/dynamic")]
+            )
+          ]
+        end
+      end
+
+      files = Indexmap.create(:dynamic)
+
+      assert_equal [
+        public_path.join("sitemap-dynamic.xml"),
+        public_path.join("sitemap.xml")
+      ], files
+      assert_includes public_path.join("sitemap-dynamic.xml").read, "https://example.com/dynamic"
+      assert_includes public_path.join("sitemap.xml").read, "https://example.com/sitemap-dynamic.xml"
+    end
+  end
+
+  def test_create_preserves_existing_files_when_validation_fails
+    Dir.mktmpdir do |dir|
+      public_path = Pathname(dir)
+      public_path.join("sitemap.xml").write("old index")
+      public_path.join("sitemap-pages.xml").write("old child")
+
+      Indexmap.configure do |config|
+        config.base_url = "https://example.com"
+        config.public_path = public_path
+        config.sections = [
+          Indexmap::Section.new(
+            filename: "sitemap-pages.xml",
+            entries: [Indexmap::Entry.new(loc: "https://example.com/about?utm_source=test")]
+          )
+        ]
+      end
+
+      error = assert_raises(Indexmap::ValidationError) { Indexmap.create }
+
+      assert_match "Parameterized sitemap URLs detected", error.message
+      assert_equal "old index", public_path.join("sitemap.xml").read
+      assert_equal "old child", public_path.join("sitemap-pages.xml").read
+    end
+  end
+
+  def test_create_writes_single_file_named_output_without_default_index
+    Dir.mktmpdir do |dir|
+      public_path = Pathname(dir)
+
+      Indexmap.configure do |config|
+        config.base_url = "https://example.com"
+        config.public_path = public_path
+        config.output :dynamic do |output|
+          output.format = :single_file
+          output.index_filename = "sitemap-dynamic.xml"
+          output.entries = [
+            Indexmap::Entry.new(loc: "https://example.com/dynamic")
+          ]
+        end
+      end
+
+      files = Indexmap.create(:dynamic)
+
+      assert_equal [public_path.join("sitemap-dynamic.xml")], files
+      refute public_path.join("sitemap.xml").exist?
+      assert_includes public_path.join("sitemap-dynamic.xml").read, "https://example.com/dynamic"
+    end
+  end
+
+  def test_create_preserves_existing_named_output_when_validation_fails
+    Dir.mktmpdir do |dir|
+      public_path = Pathname(dir)
+      public_path.join("sitemap-dynamic.xml").write("old dynamic")
+
+      Indexmap.configure do |config|
+        config.base_url = "https://example.com"
+        config.public_path = public_path
+        config.output :dynamic do |output|
+          output.format = :single_file
+          output.index_filename = "sitemap-dynamic.xml"
+          output.entries = [
+            Indexmap::Entry.new(loc: "https://example.com/dynamic?utm_source=test")
+          ]
+        end
+      end
+
+      error = assert_raises(Indexmap::ValidationError) { Indexmap.create(:dynamic) }
+
+      assert_match "Parameterized sitemap URLs detected", error.message
+      assert_equal "old dynamic", public_path.join("sitemap-dynamic.xml").read
+    end
+  end
+
+  def test_after_create_requires_a_block
+    error = assert_raises(ArgumentError) { Indexmap.configuration.after_create }
+
+    assert_equal "after_create requires a block", error.message
+  end
 end

data/test/indexmap/pinger/google_test.rb

@@ -8,10 +8,11 @@ class IndexmapPingerGoogleTest < Minitest::Test
 
   class FakeWebmastersService
     attr_accessor :authorization
-    attr_reader :submitted, :list_sites_calls
+    attr_reader :submitted, :submissions, :list_sites_calls
 
     def initialize(site_urls:)
       @site_urls = site_urls
+      @submissions = []
       @list_sites_calls = 0
     end
 
@@ -22,6 +23,7 @@ class IndexmapPingerGoogleTest < Minitest::Test
 
     def submit_sitemap(property, sitemap_url)
       @submitted = [property, sitemap_url]
+      @submissions << @submitted
     end
   end
 
@@ -53,10 +55,59 @@ class IndexmapPingerGoogleTest < Minitest::Test
       assert_equal ["sc-domain:example.com", "https://www.example.com/sitemap.xml"], service.submitted
       assert_equal :submitted, result[:status]
       assert_equal 1, result[:sitemap_count]
+      assert_equal 0, result[:url_count]
       assert_equal 1, service.list_sites_calls
     end
   end
 
+  def test_reports_unique_url_count_from_submitted_sitemaps
+    Dir.mktmpdir do |dir|
+      public_path = Pathname(dir)
+      public_path.join("sitemap.xml").write(<<~XML)
+        <?xml version="1.0" encoding="UTF-8"?>
+        <sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+          <sitemap><loc>https://www.example.com/sitemap-pages.xml</loc></sitemap>
+          <sitemap><loc>https://www.example.com/sitemap-posts.xml</loc></sitemap>
+        </sitemapindex>
+      XML
+      public_path.join("sitemap-pages.xml").write(<<~XML)
+        <?xml version="1.0" encoding="UTF-8"?>
+        <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+          <url><loc>https://www.example.com/</loc></url>
+          <url><loc>https://www.example.com/about</loc></url>
+        </urlset>
+      XML
+      public_path.join("sitemap-posts.xml").write(<<~XML)
+        <?xml version="1.0" encoding="UTF-8"?>
+        <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+          <url><loc>https://www.example.com/about</loc></url>
+          <url><loc>https://www.example.com/blog</loc></url>
+        </urlset>
+      XML
+
+      configuration = Indexmap::Configuration.new
+      configuration.base_url = "https://www.example.com"
+      configuration.public_path = public_path
+      configuration.google.credentials = "{\"type\":\"service_account\"}"
+
+      service = FakeWebmastersService.new(site_urls: ["sc-domain:example.com"])
+      result = Indexmap::Pinger::Google.new(
+        configuration: configuration,
+        service: service,
+        credentials_builder: ->(**) { :fake_authorizer }
+      ).ping
+
+      assert_equal :submitted, result[:status]
+      assert_equal 3, result[:sitemap_count]
+      assert_equal 3, result[:url_count]
+      assert_equal [
+        ["sc-domain:example.com", "https://www.example.com/sitemap-pages.xml"],
+        ["sc-domain:example.com", "https://www.example.com/sitemap-posts.xml"],
+        ["sc-domain:example.com", "https://www.example.com/sitemap.xml"]
+      ], service.submissions
+    end
+  end
+
   def test_skips_google_ping_when_credentials_are_missing
     Dir.mktmpdir do |dir|
       public_path = Pathname(dir)

data/test/indexmap/task_runner_test.rb

@@ -5,11 +5,12 @@ require "test_helper"
 class IndexmapTaskRunnerTest < Minitest::Test
   VALID_KEY = "1234567890abcdef1234567890abcdef"
 
-  def test_create_removes_existing_sitemap_files_writes_new_sitemap_and_key_file
+  def test_create_writes_new_sitemap_and_key_file_without_deleting_unrelated_files
     Dir.mktmpdir do |dir|
       public_path = Pathname(dir)
       public_path.join("sitemap.xml").write("old")
       public_path.join("sitemap-pages.xml.gz").write("old")
+      public_path.join("sitemap-extra.xml").write("existing")
 
       configuration = Indexmap::Configuration.new
       configuration.base_url = "https://example.com"
@@ -24,14 +25,40 @@ class IndexmapTaskRunnerTest < Minitest::Test
 
       result = Indexmap::TaskRunner.new(configuration: configuration).create
 
-      assert_equal false, public_path.join("sitemap-pages.xml.gz").exist?
+      assert public_path.join("sitemap-pages.xml.gz").exist?
+      assert_equal "existing", public_path.join("sitemap-extra.xml").read
       assert_includes public_path.join("sitemap.xml").read, "<sitemapindex"
       assert_equal VALID_KEY, public_path.join("#{VALID_KEY}.txt").read
       assert_equal [public_path.join("sitemap-pages.xml").to_s, public_path.join("sitemap.xml").to_s], result[:files]
+      assert_equal [public_path.join("sitemap-pages.xml"), public_path.join("sitemap.xml")], result[:written_files]
       assert_equal public_path.join("#{VALID_KEY}.txt"), result[:index_now_key_path]
     end
   end
 
+  def test_create_runs_after_create_callbacks_after_validation
+    Dir.mktmpdir do |dir|
+      calls = []
+      public_path = Pathname(dir)
+      configuration = Indexmap::Configuration.new
+      configuration.base_url = "https://example.com"
+      configuration.public_path = public_path
+      configuration.sections = [
+        Indexmap::Section.new(
+          filename: "sitemap-pages.xml",
+          entries: [Indexmap::Entry.new(loc: "https://example.com/about")]
+        )
+      ]
+      configuration.after_create do
+        calls << :called
+        calls << public_path.join("sitemap.xml").read.include?("<sitemapindex")
+      end
+
+      Indexmap::TaskRunner.new(configuration: configuration).create
+
+      assert_equal [:called, true], calls
+    end
+  end
+
   def test_write_index_now_key_returns_nil_when_key_is_not_configured
     Dir.mktmpdir do |dir|
       configuration = Indexmap::Configuration.new

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: indexmap
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Paulo Fidalgo
@@ -177,9 +177,11 @@ files:
 - README.md
 - lib/indexmap.rb
 - lib/indexmap/configuration.rb
+- lib/indexmap/creator.rb
 - lib/indexmap/entry.rb
 - lib/indexmap/google_configuration.rb
 - lib/indexmap/index_now_configuration.rb
+- lib/indexmap/output.rb
 - lib/indexmap/parser.rb
 - lib/indexmap/path.rb
 - lib/indexmap/pinger/base.rb