indexmap 0.6.0 → 0.7.1

data/lib/indexmap/writer.rb

@@ -4,18 +4,15 @@ 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)
+    def initialize(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 [write_file(index_filename, urlset_xml(entries))] if single_file?
 
       paths = sections.map do |section|
@@ -25,8 +22,6 @@ module Indexmap
       paths + [write_file(index_filename, index_xml(sections))]
     end
 
-    attr_accessor :public_path
-
     private
 
     attr_reader :base_url, :entries, :format, :index_filename, :sections
@@ -58,9 +53,7 @@ module Indexmap
     end
 
     def write_file(filename, body)
-      path = public_path.join(filename)
-      path.write(body)
-      path
+      Storage::File.new(filename: filename, body: body, content_type: "application/xml")
     end
 
     def urlset_xml(entries)

data/lib/indexmap.rb

@@ -8,11 +8,14 @@ require "time"
 require_relative "indexmap/version"
 require_relative "indexmap/google_configuration"
 require_relative "indexmap/index_now_configuration"
+require_relative "indexmap/storage/file"
+require_relative "indexmap/storage/memory"
+require_relative "indexmap/storage/filesystem"
+require_relative "indexmap/storage/active_storage"
 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"
 require_relative "indexmap/pinger/google"

data/lib/tasks/indexmap_tasks.rake

@@ -5,8 +5,12 @@ namespace :indexmap 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]
+      puts "Created, formatted, and validated #{file_count(create_result[:files])}."
+      puts "Files created:"
+      create_result[:sitemaps].each do |sitemap|
+        puts "  - #{sitemap[:location]} (#{link_count(sitemap[:link_count])})"
+      end
+      puts "IndexNow key file: #{create_result[:index_now_key_filename]}" if create_result[:index_now_key_filename]
     end
 
     desc "Format sitemap files for better readability"
@@ -14,7 +18,7 @@ namespace :indexmap do
       runner = Indexmap::TaskRunner.new
       formatted_files = runner.format
 
-      puts "Formatted #{file_count(formatted_files)} in #{public_directory(runner)}."
+      puts "Formatted #{file_count(formatted_files)} in #{storage_description(runner)}."
     end
 
     desc "Validate sitemap shape and URL hygiene"
@@ -87,8 +91,12 @@ namespace :indexmap do
     "#{count} sitemap #{(count == 1) ? "file" : "files"}"
   end
 
-  def public_directory(runner)
-    runner.public_path
+  def storage_description(runner)
+    runner.storage
+  end
+
+  def link_count(count)
+    "#{count} #{(count == 1) ? "link" : "links"}"
   end
 
   def format_google_ping_failure(failure)

data/test/indexmap/configuration_test.rb

@@ -8,41 +8,49 @@ class IndexmapConfigurationTest < Minitest::Test
   end
 
   def test_writer_builds_from_configured_callables
-    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
+    Indexmap.configure do |config|
+      config.base_url = -> { "https://example.com" }
+      config.sections = -> do
+        [Indexmap::Section.new(filename: "sitemap-pages.xml", entries: [Indexmap::Entry.new(loc: "https://example.com/")])]
       end
+    end
+
+    files = Indexmap.configuration.writer.write
 
-      Indexmap.configuration.writer.write
+    assert_includes files.find { |file| file.filename == "sitemap.xml" }.body, "<loc>https://example.com/sitemap-pages.xml</loc>"
+    assert_includes files.find { |file| file.filename == "sitemap-pages.xml" }.body, "<loc>https://example.com/</loc>"
+  end
+
+  def test_create_writes_to_configured_storage
+    storage = Indexmap::Storage::Memory.new
 
-      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>"
+    Indexmap.configure do |config|
+      config.base_url = "https://example.com"
+      config.storage = storage
+      config.sections = [
+        Indexmap::Section.new(filename: "sitemap-pages.xml", entries: [Indexmap::Entry.new(loc: "https://example.com/")])
+      ]
     end
+
+    files = Indexmap.create
+
+    assert_equal ["sitemap-pages.xml", "sitemap.xml"], files
+    assert_includes storage.read("sitemap.xml"), "<loc>https://example.com/sitemap-pages.xml</loc>"
+    assert_includes storage.read("sitemap-pages.xml"), "<loc>https://example.com/</loc>"
   end
 
   def test_writer_builds_single_file_writer_from_configured_entries
-    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
+    Indexmap.configure do |config|
+      config.base_url = "https://example.com"
+      config.format = :single_file
+      config.entries = -> { [Indexmap::Entry.new(loc: "https://example.com/")] }
+    end
 
-      Indexmap.configuration.writer.write
+    files = Indexmap.configuration.writer.write
 
-      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
+    assert_equal ["sitemap.xml"], files.map(&:filename)
+    assert_includes files.fetch(0).body, "<urlset"
+    assert_includes files.fetch(0).body, "<loc>https://example.com/</loc>"
   end
 
   def test_writer_raises_without_base_url
@@ -83,141 +91,102 @@ class IndexmapConfigurationTest < Minitest::Test
       config.google.credentials = -> { "{\"type\":\"service_account\"}" }
       config.google.property = -> { "sc-domain:example.com" }
       config.index_now.key = -> { "example-key" }
+      config.index_now.key_filename = -> { "index-now-key.txt" }
       config.index_now.max_urls_per_request = -> { 250 }
+      config.index_now.write_key_file = -> { false }
     end
 
     assert_equal "{\"type\":\"service_account\"}", Indexmap.configuration.google.credentials
     assert_equal "sc-domain:example.com", Indexmap.configuration.google.property
     assert_equal "example-key", Indexmap.configuration.index_now.key
+    assert_equal "index-now-key.txt", Indexmap.configuration.index_now.key_filename
     assert_equal 250, Indexmap.configuration.index_now.max_urls_per_request
+    refute Indexmap.configuration.index_now.write_key_file?
   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
+  def test_index_now_key_file_writing_defaults_to_configured_key_presence
+    config = Indexmap::Configuration.new
 
-      files = Indexmap.create(:reports)
+    refute config.index_now.write_key_file?
 
-      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
+    config.index_now.key = "1234567890abcdef1234567890abcdef"
 
-  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
+    assert config.index_now.write_key_file?
+  end
 
-      files = Indexmap.create(:dynamic)
+  def test_index_now_key_file_writing_can_be_disabled_with_a_configured_key
+    config = Indexmap::Configuration.new
+    config.index_now.key = "1234567890abcdef1234567890abcdef"
+    config.index_now.write_key_file = false
 
-      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
+    refute config.index_now.write_key_file?
   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 = [
+  def test_named_outputs_inherit_configuration_defaults
+    storage = Indexmap::Storage::Memory.new
+
+    Indexmap.configure do |config|
+      config.base_url = "https://example.com"
+      config.storage = storage
+      config.output :reports do |output|
+        output.sections = [
           Indexmap::Section.new(
-            filename: "sitemap-pages.xml",
-            entries: [Indexmap::Entry.new(loc: "https://example.com/about?utm_source=test")]
+            filename: "sitemap-reports.xml",
+            entries: [Indexmap::Entry.new(loc: "https://example.com/reports")]
           )
         ]
       end
+    end
 
-      error = assert_raises(Indexmap::ValidationError) { Indexmap.create }
+    files = Indexmap.create(:reports)
 
-      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
+    assert_equal ["sitemap-reports.xml", "sitemap.xml"], files
+    assert_includes storage.read("sitemap.xml"), "https://example.com/sitemap-reports.xml"
   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
+    storage = Indexmap::Storage::Memory.new
+
+    Indexmap.configure do |config|
+      config.base_url = "https://example.com"
+      config.storage = storage
+      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)
+    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
+    assert_equal ["sitemap-dynamic.xml"], files
+    refute storage.exist?("sitemap.xml")
+    assert_includes storage.read("sitemap-dynamic.xml"), "https://example.com/dynamic"
   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) }
+  def test_create_preserves_existing_files_when_validation_fails
+    storage = Indexmap::Storage::Memory.new
+    storage.write("sitemap.xml", "old index")
+    storage.write("sitemap-pages.xml", "old child")
 
-      assert_match "Parameterized sitemap URLs detected", error.message
-      assert_equal "old dynamic", public_path.join("sitemap-dynamic.xml").read
+    Indexmap.configure do |config|
+      config.base_url = "https://example.com"
+      config.storage = storage
+      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", storage.read("sitemap.xml")
+    assert_equal "old child", storage.read("sitemap-pages.xml")
   end
 
   def test_after_create_requires_a_block

data/test/indexmap/parser_test.rb

@@ -16,7 +16,7 @@ class IndexmapParserTest < Minitest::Test
         XML
       )
 
-    parser = Indexmap::Parser.new(path: "https://www.example.com/sitemap.xml")
+    parser = Indexmap::Parser.new(source: "https://www.example.com/sitemap.xml")
 
     assert_equal ["/", "/pages/features"], parser.paths
   end
@@ -44,7 +44,7 @@ class IndexmapParserTest < Minitest::Test
         XML
       )
 
-    parser = Indexmap::Parser.new(path: "https://www.example.com/sitemap.xml")
+    parser = Indexmap::Parser.new(source: "https://www.example.com/sitemap.xml")
 
     assert_equal ["/tools/google-reviews-calculator"], parser.paths
     assert_equal ["https://www.reviato.com/tools/google-reviews-calculator"], parser.urls(base_url: "https://www.reviato.com")
@@ -73,9 +73,50 @@ class IndexmapParserTest < Minitest::Test
         XML
       )
 
-    parser = Indexmap::Parser.new(path: "http://localhost:3001/sitemap.xml", rebase_remote_children: true)
+    parser = Indexmap::Parser.new(source: "http://localhost:3001/sitemap.xml", rebase_remote_children: true)
 
     assert_equal ["/pages/pricing"], parser.paths
     assert_equal ["http://localhost:3001/pages/pricing"], parser.urls(base_url: "http://localhost:3001")
   end
+
+  def test_parses_storage_sitemap_index_with_directory_keys
+    storage = Indexmap::Storage::Memory.new
+    storage.write("sitemaps/sitemap.xml", <<~XML)
+      <?xml version="1.0" encoding="UTF-8"?>
+      <sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+        <sitemap><loc>https://www.example.com/sitemaps/content.xml</loc></sitemap>
+      </sitemapindex>
+    XML
+    storage.write("sitemaps/content.xml", <<~XML)
+      <?xml version="1.0" encoding="UTF-8"?>
+      <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+        <url><loc>https://www.example.com/pages/features</loc></url>
+      </urlset>
+    XML
+
+    parser = Indexmap::Parser.new(source: "sitemaps/sitemap.xml", storage: storage)
+
+    assert_equal ["/pages/features"], parser.paths
+    assert_equal ["sitemaps/content.xml"], parser.entries.map(&:source_sitemap)
+  end
+
+  def test_parses_relative_child_sitemaps_from_parent_directory
+    storage = Indexmap::Storage::Memory.new
+    storage.write("sitemaps/sitemap.xml", <<~XML)
+      <?xml version="1.0" encoding="UTF-8"?>
+      <sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+        <sitemap><loc>content.xml</loc></sitemap>
+      </sitemapindex>
+    XML
+    storage.write("sitemaps/content.xml", <<~XML)
+      <?xml version="1.0" encoding="UTF-8"?>
+      <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+        <url><loc>https://www.example.com/pages/pricing</loc></url>
+      </urlset>
+    XML
+
+    parser = Indexmap::Parser.new(source: "sitemaps/sitemap.xml", storage: storage)
+
+    assert_equal ["/pages/pricing"], parser.paths
+  end
 end