indexmap 0.4.2 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9b0f3c8b9175d0c18c39e52b61b3934129dfa8b8b637d06ad3d0d9adc30eb995
-  data.tar.gz: 3baf06c566ce17d63e189aabfdd7f3e7b4047d5908fc6a58f3e017da5ecef1de
+  metadata.gz: ef452a5928b87f84f65ecb9ba2afcab5340d9d09c5d8c8dfd8c4ffb3217a68fd
+  data.tar.gz: 03b11e1d9360bbd797d6b61886c99d1619247877dfd2c4676efeca9a1119764c
 SHA512:
-  metadata.gz: 700e0cd5485cd433ceaa520a2d634eb4e5ccf93d4d8993224fae61acdf7dacd73c91029e24ff750cc58ce8704a5b00bb4ed66eff113d0693c46df75fc5aea4df
-  data.tar.gz: aa51396dad778e50b18a53606d316d5f9008ed358cecb7b75c0f7dc72f24d47a3959750102fdddafe50fbb31688256e16b07ec9c9c0ae53cb9431148593bb250
+  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.4.2] - 2026-04-23
+## [0.6.0] - 2026-05-01
 
 
-### Fixed
+### Added
 
-- harden sitemap pinging and indexnow key handling (#7)
+- add the url count to google ping output (#9)
+
+- support named sitemap outputs (#10)
 
 
 

data/README.md

@@ -80,12 +80,15 @@ end
 Then run:
 
 ```bash
-bin/rails sitemap:create
-bin/rails sitemap:format
-bin/rails sitemap:validate
+bin/rails indexmap:sitemap:create
+bin/rails indexmap:sitemap:format
+bin/rails indexmap:sitemap:validate
 ```
 
-`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:
@@ -129,8 +211,15 @@ Indexmap::Validator.new.validate!
 The built-in validator checks for:
 
 - missing sitemap files
+- malformed sitemap XML
+- empty sitemap files
+- missing or duplicate child sitemap references
 - duplicate sitemap URLs
 - parameterized URLs in sitemap entries
+- fragment URLs in sitemap entries
+- non-HTTP or relative URLs
+- URLs outside the configured `base_url`
+- invalid `lastmod` values
 
 ## Search Engine Ping
 
@@ -139,11 +228,11 @@ The built-in validator checks for:
 Available rake tasks:
 
 ```bash
-bin/rails sitemap:validate
-bin/rails sitemap:google:ping
-bin/rails sitemap:index_now:ping
-bin/rails sitemap:index_now:write_key
-bin/rails sitemap:ping
+bin/rails indexmap:sitemap:validate
+bin/rails indexmap:google:ping
+bin/rails indexmap:index_now:ping
+bin/rails indexmap:index_now:write_key
+bin/rails indexmap:ping
 ```
 
 ### Google Search Console
@@ -156,7 +245,7 @@ Indexmap.configure do |config|
 end
 ```
 
-If `config.google.credentials` is blank, `sitemap:google:ping` skips Google submission.
+If `config.google.credentials` is blank, `indexmap:google:ping` skips Google submission.
 
 You can optionally override the Search Console property identifier:
 
@@ -184,21 +273,21 @@ Indexmap.configure do |config|
 end
 ```
 
-If `config.index_now.key` is set, `sitemap:create` also writes the matching `public/<key>.txt` verification file automatically.
+If `config.index_now.key` is set, `indexmap:sitemap:create` also writes the matching `public/<key>.txt` verification file automatically.
 
 If you prefer the file-based flow, run:
 
 ```bash
-bin/rails sitemap:index_now:write_key
+bin/rails indexmap:index_now:write_key
 ```
 
 That task:
 
 - reuses an existing valid key file when present
 - otherwise generates a new key in `public/<key>.txt`
-- makes that key available to `sitemap:index_now:ping` without adding `config.index_now.key`
+- makes that key available to `indexmap:index_now:ping` without adding `config.index_now.key`
 
-If neither a configured key nor a valid key file is present, `sitemap:index_now:ping` skips IndexNow submission.
+If neither a configured key nor a valid key file is present, `indexmap:index_now:ping` skips IndexNow submission.
 
 ## Development
 

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/validator.rb

@@ -1,5 +1,10 @@
 # frozen_string_literal: true
 
+require "nokogiri"
+require "date"
+require "time"
+require "uri"
+
 module Indexmap
   class Validator
     def initialize(configuration: Indexmap.configuration, path: nil)
@@ -14,9 +19,15 @@ module Indexmap
       )
       raise ValidationError, "Missing sitemap file: #{sitemap_path}" unless File.exist?(sitemap_path)
 
+      validate_sitemap_file!(sitemap_path)
       entries = Parser.new(path: sitemap_path).entries
+      validate_presence!(entries)
       validate_duplicates!(entries)
       validate_parameterized_urls!(entries)
+      validate_fragment_urls!(entries)
+      validate_absolute_http_urls!(entries)
+      validate_same_host_urls!(entries)
+      validate_lastmods!(entries)
       true
     end
 
@@ -24,6 +35,65 @@ module Indexmap
 
     attr_reader :configuration, :path
 
+    def validate_sitemap_file!(sitemap_path)
+      document = read_xml_document(sitemap_path)
+      root_name = document.root&.name
+
+      case root_name
+      when "urlset"
+        validate_urlset_document!(document, sitemap_path)
+      when "sitemapindex"
+        validate_sitemap_index_document!(document, sitemap_path)
+      else
+        raise ValidationError, "Invalid sitemap root element in #{sitemap_path}: #{root_name || "none"}"
+      end
+    end
+
+    def read_xml_document(file_path)
+      document = Nokogiri::XML(File.read(file_path, encoding: "UTF-8")) { |config| config.strict }
+      document.remove_namespaces!
+      document
+    rescue Nokogiri::XML::SyntaxError => error
+      raise ValidationError, "Invalid sitemap XML in #{file_path}: #{error.message.lines.first.strip}"
+    end
+
+    def validate_urlset_document!(document, sitemap_path)
+      return if document.xpath("/urlset/url/loc").any?
+
+      raise ValidationError, "Sitemap has no URLs: #{sitemap_path}"
+    end
+
+    def validate_sitemap_index_document!(document, sitemap_path)
+      child_locations = document.xpath("/sitemapindex/sitemap/loc").map { |node| node.text.to_s.strip }.reject(&:empty?)
+      raise ValidationError, "Sitemap index has no child sitemap URLs: #{sitemap_path}" if child_locations.empty?
+
+      duplicate_children = child_locations.group_by(&:itself).select { |_loc, values| values.size > 1 }.keys
+      unless duplicate_children.empty?
+        raise ValidationError, "Duplicate child sitemap URLs detected: #{duplicate_children.first(5).join(", ")}"
+      end
+
+      child_locations.each do |location|
+        child_path = local_child_path(sitemap_path, location)
+        raise ValidationError, "Missing child sitemap file: #{child_path}" unless File.exist?(child_path)
+
+        validate_sitemap_file!(child_path)
+      end
+    end
+
+    def local_child_path(sitemap_path, location)
+      uri = URI.parse(location)
+      filename = (uri.absolute? || location.start_with?("/")) ? File.basename(uri.path) : location
+      File.expand_path(filename, File.dirname(sitemap_path))
+    rescue URI::InvalidURIError
+      File.expand_path(location, File.dirname(sitemap_path))
+    end
+
+    def validate_presence!(entries)
+      return unless entries.empty?
+
+      raise ValidationError, "Sitemap has no URLs"
+    end
+
     def validate_duplicates!(entries)
       duplicates = entries.map(&:loc).group_by(&:itself).select { |_url, values| values.size > 1 }.keys
       return if duplicates.empty?
@@ -37,5 +107,55 @@ module Indexmap
 
       raise ValidationError, "Parameterized sitemap URLs detected: #{param_urls.first(5).join(", ")}"
     end
+
+    def validate_fragment_urls!(entries)
+      fragment_urls = entries.map(&:loc).select { |url| parse_uri(url)&.fragment }
+      return if fragment_urls.empty?
+
+      raise ValidationError, "Fragment sitemap URLs detected: #{fragment_urls.first(5).join(", ")}"
+    end
+
+    def validate_absolute_http_urls!(entries)
+      invalid_urls = entries.map(&:loc).reject do |url|
+        uri = parse_uri(url)
+        uri&.absolute? && %w[http https].include?(uri.scheme)
+      end
+      return if invalid_urls.empty?
+
+      raise ValidationError, "Invalid sitemap URLs detected: #{invalid_urls.first(5).join(", ")}"
+    end
+
+    def validate_same_host_urls!(entries)
+      base_uri = parse_uri(configuration.base_url)
+      return unless base_uri&.host
+
+      invalid_urls = entries.map(&:loc).reject do |url|
+        uri = parse_uri(url)
+        uri&.host == base_uri.host && uri&.scheme == base_uri.scheme && uri&.port == base_uri.port
+      end
+      return if invalid_urls.empty?
+
+      raise ValidationError, "Sitemap URLs outside configured base URL detected: #{invalid_urls.first(5).join(", ")}"
+    end
+
+    def validate_lastmods!(entries)
+      invalid_entries = entries.select do |entry|
+        next false if entry.lastmod.nil?
+
+        Date.iso8601(entry.lastmod)
+        false
+      rescue ArgumentError
+        true
+      end
+      return if invalid_entries.empty?
+
+      raise ValidationError, "Invalid sitemap lastmod values detected: #{invalid_entries.first(5).map(&:loc).join(", ")}"
+    end
+
+    def parse_uri(url)
+      URI.parse(url.to_s)
+    rescue URI::InvalidURIError
+      nil
+    end
   end
 end

data/lib/indexmap/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Indexmap
-  VERSION = "0.4.2"
+  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

@@ -1,35 +1,35 @@
-namespace :sitemap do
-  desc "Create sitemap files"
-  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 "IndexNow key file: #{create_result[:index_now_key_path]}" if create_result[:index_now_key_path]
-  end
+namespace :indexmap do
+  namespace :sitemap do
+    desc "Create sitemap files"
+    task create: :environment do
+      runner = Indexmap::TaskRunner.new
+      create_result = runner.create
+
+      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
 
-  desc "Format sitemap files for better readability"
-  task format: :environment do
-    runner = Indexmap::TaskRunner.new
-    formatted_files = runner.format
+    desc "Format sitemap files for better readability"
+    task format: :environment do
+      runner = Indexmap::TaskRunner.new
+      formatted_files = runner.format
 
-    puts "Formatted #{file_count(formatted_files)} in #{public_directory(runner)}."
-  end
+      puts "Formatted #{file_count(formatted_files)} in #{public_directory(runner)}."
+    end
 
-  desc "Validate sitemap shape and URL hygiene"
-  task validate: :environment do
-    runner = Indexmap::TaskRunner.new
-    validated_files = runner.validate
+    desc "Validate sitemap shape and URL hygiene"
+    task validate: :environment do
+      runner = Indexmap::TaskRunner.new
+      validated_files = runner.validate
 
-    puts "Validated #{file_count(validated_files)} for sitemap shape and URL hygiene."
+      puts "Validated #{file_count(validated_files)} for sitemap shape and URL hygiene."
+    end
   end
 
   desc "Ping all configured search engines"
   task ping: :environment do
-    Rake::Task["sitemap:index_now:ping"].invoke
-    Rake::Task["sitemap:google:ping"].invoke
+    Rake::Task["indexmap:index_now:ping"].invoke
+    Rake::Task["indexmap:google:ping"].invoke
   end
 
   namespace :google do
@@ -39,9 +39,9 @@ namespace :sitemap 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

@@ -8,30 +8,41 @@ class IndexmapConfigurationTest < Minitest::Test
   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/")])]
+    Dir.mktmpdir do |dir|
+      public_path = Pathname(dir)
+
+      Indexmap.configure do |config|
+        config.base_url = -> { "https://example.com" }
+        config.public_path = -> { public_path }
+        config.sections = -> do
+          [Indexmap::Section.new(filename: "sitemap-pages.xml", entries: [Indexmap::Entry.new(loc: "https://example.com/")])]
+        end
       end
-    end
 
-    writer = Indexmap.configuration.writer
+      Indexmap.configuration.writer.write
 
-    assert_equal Pathname("tmp/public"), writer.instance_variable_get(:@public_path)
+      assert_includes public_path.join("sitemap.xml").read, "<loc>https://example.com/sitemap-pages.xml</loc>"
+      assert_includes public_path.join("sitemap-pages.xml").read, "<loc>https://example.com/</loc>"
+    end
   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
+    Dir.mktmpdir do |dir|
+      public_path = Pathname(dir)
+
+      Indexmap.configure do |config|
+        config.base_url = "https://example.com"
+        config.public_path = public_path
+        config.format = :single_file
+        config.entries = -> { [Indexmap::Entry.new(loc: "https://example.com/")] }
+      end
 
-    writer = Indexmap.configuration.writer
+      Indexmap.configuration.writer.write
 
-    assert_equal :single_file, writer.instance_variable_get(:@format)
-    assert_equal [Indexmap::Entry.new(loc: "https://example.com/")], writer.instance_variable_get(:@entries)
+      assert_includes public_path.join("sitemap.xml").read, "<urlset"
+      assert_includes public_path.join("sitemap.xml").read, "<loc>https://example.com/</loc>"
+      refute public_path.join("sitemap-pages.xml").exist?
+    end
   end
 
   def test_writer_raises_without_base_url
@@ -80,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

data/test/indexmap/validator_test.rb

@@ -52,6 +52,120 @@ class IndexmapValidatorTest < Minitest::Test
     end
   end
 
+  def test_validate_raises_for_fragment_urls
+    Dir.mktmpdir do |directory|
+      path = Pathname(directory).join("sitemap.xml")
+      path.write(<<~XML)
+        <?xml version="1.0" encoding="UTF-8"?>
+        <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+          <url><loc>https://example.com/about#team</loc></url>
+        </urlset>
+      XML
+
+      error = assert_raises(Indexmap::ValidationError) do
+        Indexmap::Validator.new(path: path).validate!
+      end
+
+      assert_equal "Fragment sitemap URLs detected: https://example.com/about#team", error.message
+    end
+  end
+
+  def test_validate_raises_for_relative_urls
+    Dir.mktmpdir do |directory|
+      path = Pathname(directory).join("sitemap.xml")
+      path.write(<<~XML)
+        <?xml version="1.0" encoding="UTF-8"?>
+        <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+          <url><loc>/about</loc></url>
+        </urlset>
+      XML
+
+      error = assert_raises(Indexmap::ValidationError) do
+        Indexmap::Validator.new(path: path).validate!
+      end
+
+      assert_equal "Invalid sitemap URLs detected: /about", error.message
+    end
+  end
+
+  def test_validate_raises_for_urls_outside_configured_base_url
+    Dir.mktmpdir do |directory|
+      path = Pathname(directory).join("sitemap.xml")
+      path.write(<<~XML)
+        <?xml version="1.0" encoding="UTF-8"?>
+        <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+          <url><loc>https://other.example.com/about</loc></url>
+        </urlset>
+      XML
+
+      configuration = Indexmap::Configuration.new
+      configuration.base_url = "https://example.com"
+
+      error = assert_raises(Indexmap::ValidationError) do
+        Indexmap::Validator.new(configuration: configuration, path: path).validate!
+      end
+
+      assert_equal "Sitemap URLs outside configured base URL detected: https://other.example.com/about", error.message
+    end
+  end
+
+  def test_validate_raises_for_invalid_lastmod_values
+    Dir.mktmpdir do |directory|
+      path = Pathname(directory).join("sitemap.xml")
+      path.write(<<~XML)
+        <?xml version="1.0" encoding="UTF-8"?>
+        <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+          <url>
+            <loc>https://example.com/about</loc>
+            <lastmod>not-a-date</lastmod>
+          </url>
+        </urlset>
+      XML
+
+      error = assert_raises(Indexmap::ValidationError) do
+        Indexmap::Validator.new(path: path).validate!
+      end
+
+      assert_equal "Invalid sitemap lastmod values detected: https://example.com/about", error.message
+    end
+  end
+
+  def test_validate_raises_for_empty_sitemaps
+    Dir.mktmpdir do |directory|
+      path = Pathname(directory).join("sitemap.xml")
+      path.write(<<~XML)
+        <?xml version="1.0" encoding="UTF-8"?>
+        <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+        </urlset>
+      XML
+
+      error = assert_raises(Indexmap::ValidationError) do
+        Indexmap::Validator.new(path: path).validate!
+      end
+
+      assert_equal "Sitemap has no URLs: #{path}", error.message
+    end
+  end
+
+  def test_validate_raises_for_missing_child_sitemap_files
+    Dir.mktmpdir do |directory|
+      path = Pathname(directory).join("sitemap.xml")
+      child_path = Pathname(directory).join("sitemap-pages.xml")
+      path.write(<<~XML)
+        <?xml version="1.0" encoding="UTF-8"?>
+        <sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+          <sitemap><loc>https://example.com/sitemap-pages.xml</loc></sitemap>
+        </sitemapindex>
+      XML
+
+      error = assert_raises(Indexmap::ValidationError) do
+        Indexmap::Validator.new(path: path).validate!
+      end
+
+      assert_equal "Missing child sitemap file: #{child_path}", error.message
+    end
+  end
+
   def test_validate_passes_for_valid_sitemap
     Dir.mktmpdir do |directory|
       path = Pathname(directory).join("sitemap.xml")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: indexmap
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  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