indexmap 0.6.0 → 0.7.0

data/test/indexmap/task_runner_test.rb

@@ -5,88 +5,117 @@ require "test_helper"
 class IndexmapTaskRunnerTest < Minitest::Test
   VALID_KEY = "1234567890abcdef1234567890abcdef"
 
+  class KeywordContentTypeStorage < Indexmap::Storage::Memory
+    def write(filename, body, content_type:)
+      super
+    end
+
+    def read_file(filename)
+      instance_variable_get(:@files).fetch(filename)
+    end
+  end
+
   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")
+    storage = Indexmap::Storage::Memory.new
+    storage.write("sitemap-pages.xml.gz", "old")
+    storage.write("sitemap-extra.xml", "existing")
 
-      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.index_now.key = VALID_KEY
+    configuration = configuration_with(storage: storage)
+    configuration.index_now.key = VALID_KEY
 
-      result = Indexmap::TaskRunner.new(configuration: configuration).create
+    result = Indexmap::TaskRunner.new(configuration: configuration).create
 
-      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
+    assert storage.exist?("sitemap-pages.xml.gz")
+    assert_equal "existing", storage.read("sitemap-extra.xml")
+    assert_includes storage.read("sitemap.xml"), "<sitemapindex"
+    assert_equal VALID_KEY, storage.read("#{VALID_KEY}.txt")
+    assert_equal ["sitemap-pages.xml", "sitemap.xml"], result[:files]
+    assert_equal ["sitemap-pages.xml", "sitemap.xml"], result[:written_files]
+    assert_equal "#{VALID_KEY}.txt", result[:index_now_key_filename]
   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
+    calls = []
+    storage = Indexmap::Storage::Memory.new
+    configuration = configuration_with(storage: storage)
+    configuration.after_create do
+      calls << :called
+      calls << storage.read("sitemap.xml").include?("<sitemapindex")
+    end
 
-      Indexmap::TaskRunner.new(configuration: configuration).create
+    Indexmap::TaskRunner.new(configuration: configuration).create
 
-      assert_equal [:called, true], calls
-    end
+    assert_equal [:called, true], calls
+  end
+
+  def test_create_reuses_existing_index_now_key_file
+    storage = Indexmap::Storage::Memory.new
+    storage.write("#{VALID_KEY}.txt", VALID_KEY, content_type: "text/plain")
+    configuration = configuration_with(storage: storage)
+    configuration.index_now.key = VALID_KEY
+
+    result = Indexmap::TaskRunner.new(configuration: configuration).create
+
+    assert_equal "#{VALID_KEY}.txt", result[:index_now_key_filename]
+    assert_equal VALID_KEY, storage.read("#{VALID_KEY}.txt")
+  end
+
+  def test_create_can_skip_index_now_key_file_writing
+    storage = Indexmap::Storage::Memory.new
+    configuration = configuration_with(storage: storage)
+    configuration.index_now.key = VALID_KEY
+    configuration.index_now.write_key_file = false
+
+    result = Indexmap::TaskRunner.new(configuration: configuration).create
+
+    refute storage.exist?("#{VALID_KEY}.txt")
+    assert_nil result[:index_now_key_filename]
+    assert_equal ["sitemap-pages.xml", "sitemap.xml"], result[:files]
   end
 
   def test_write_index_now_key_returns_nil_when_key_is_not_configured
-    Dir.mktmpdir do |dir|
-      configuration = Indexmap::Configuration.new
+    result = Indexmap::TaskRunner.new(configuration: configuration_with).write_index_now_key
+
+    assert_nil result
+  end
+
+  def test_write_index_now_key_can_generate_a_key_when_requested
+    storage = Indexmap::Storage::Memory.new
+    configuration = configuration_with(storage: storage)
+
+    result = Indexmap::TaskRunner.new(configuration: configuration).write_index_now_key(generate_if_missing: true)
+
+    assert_match(/\A[a-f0-9]{32}\.txt\z/, result)
+    assert_equal result.delete_suffix(".txt"), storage.read(result)
+  end
+
+  def test_format_passes_content_type_when_rewriting_sitemaps
+    storage = KeywordContentTypeStorage.new
+    storage.write("sitemap.xml", <<~XML, content_type: "application/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></url></urlset>
+    XML
+    configuration = configuration_with(storage: storage)
+
+    result = Indexmap::TaskRunner.new(configuration: configuration).format
+
+    assert_equal ["sitemap.xml"], result
+    assert_equal "application/xml", storage.read_file("sitemap.xml").content_type
+    assert_includes storage.read("sitemap.xml"), "\n  <url>"
+  end
+
+  private
+
+  def configuration_with(storage: Indexmap::Storage::Memory.new)
+    Indexmap::Configuration.new.tap do |configuration|
       configuration.base_url = "https://example.com"
-      configuration.public_path = Pathname(dir)
+      configuration.storage = storage
       configuration.sections = [
         Indexmap::Section.new(
           filename: "sitemap-pages.xml",
           entries: [Indexmap::Entry.new(loc: "https://example.com/about")]
         )
       ]
-
-      result = Indexmap::TaskRunner.new(configuration: configuration).write_index_now_key
-
-      assert_nil result
-    end
-  end
-
-  def test_write_index_now_key_can_generate_a_key_when_requested
-    Dir.mktmpdir do |dir|
-      configuration = Indexmap::Configuration.new
-      configuration.base_url = "https://example.com"
-      configuration.public_path = Pathname(dir)
-
-      result = Indexmap::TaskRunner.new(configuration: configuration).write_index_now_key(generate_if_missing: true)
-
-      assert_match(/\A[a-f0-9]{32}\.txt\z/, result.basename.to_s)
-      assert_equal result.basename(".txt").to_s, result.read
     end
   end
 end

data/test/indexmap/validator_test.rb

@@ -4,115 +4,82 @@ require "test_helper"
 
 class IndexmapValidatorTest < Minitest::Test
   def test_validate_raises_for_missing_sitemap
-    Dir.mktmpdir do |directory|
-      path = Pathname(directory).join("missing.xml")
-
-      error = assert_raises(Indexmap::ValidationError) do
-        Indexmap::Validator.new(path: path).validate!
-      end
-
-      assert_equal "Missing sitemap file: #{path}", error.message
+    error = assert_raises(Indexmap::ValidationError) do
+      Indexmap::Validator.new(configuration: configuration_with).validate!
     end
+
+    assert_equal "Missing sitemap file: sitemap.xml", error.message
   end
 
   def test_validate_raises_for_duplicate_urls
-    Dir.mktmpdir do |directory|
-      path = Pathname(directory).join("sitemap.xml")
-      path.write(<<~XML)
+    error = assert_raises(Indexmap::ValidationError) do
+      validate_sitemap(<<~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></url>
           <url><loc>https://example.com/about</loc></url>
         </urlset>
       XML
-
-      error = assert_raises(Indexmap::ValidationError) do
-        Indexmap::Validator.new(path: path).validate!
-      end
-
-      assert_equal "Duplicate sitemap URLs detected: https://example.com/about", error.message
     end
+
+    assert_equal "Duplicate sitemap URLs detected: https://example.com/about", error.message
   end
 
   def test_validate_raises_for_parameterized_urls
-    Dir.mktmpdir do |directory|
-      path = Pathname(directory).join("sitemap.xml")
-      path.write(<<~XML)
+    error = assert_raises(Indexmap::ValidationError) do
+      validate_sitemap(<<~XML)
         <?xml version="1.0" encoding="UTF-8"?>
         <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
           <url><loc>https://example.com/about?ref=test</loc></url>
         </urlset>
       XML
-
-      error = assert_raises(Indexmap::ValidationError) do
-        Indexmap::Validator.new(path: path).validate!
-      end
-
-      assert_equal "Parameterized sitemap URLs detected: https://example.com/about?ref=test", error.message
     end
+
+    assert_equal "Parameterized sitemap URLs detected: https://example.com/about?ref=test", error.message
   end
 
   def test_validate_raises_for_fragment_urls
-    Dir.mktmpdir do |directory|
-      path = Pathname(directory).join("sitemap.xml")
-      path.write(<<~XML)
+    error = assert_raises(Indexmap::ValidationError) do
+      validate_sitemap(<<~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
+
+    assert_equal "Fragment sitemap URLs detected: https://example.com/about#team", error.message
   end
 
   def test_validate_raises_for_relative_urls
-    Dir.mktmpdir do |directory|
-      path = Pathname(directory).join("sitemap.xml")
-      path.write(<<~XML)
+    error = assert_raises(Indexmap::ValidationError) do
+      validate_sitemap(<<~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
+
+    assert_equal "Invalid sitemap URLs detected: /about", error.message
   end
 
   def test_validate_raises_for_urls_outside_configured_base_url
-    Dir.mktmpdir do |directory|
-      path = Pathname(directory).join("sitemap.xml")
-      path.write(<<~XML)
+    error = assert_raises(Indexmap::ValidationError) do
+      validate_sitemap(<<~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
+
+    assert_equal "Sitemap URLs outside configured base URL detected: https://other.example.com/about", error.message
   end
 
   def test_validate_raises_for_invalid_lastmod_values
-    Dir.mktmpdir do |directory|
-      path = Pathname(directory).join("sitemap.xml")
-      path.write(<<~XML)
+    error = assert_raises(Indexmap::ValidationError) do
+      validate_sitemap(<<~XML)
         <?xml version="1.0" encoding="UTF-8"?>
         <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
           <url>
@@ -121,62 +88,99 @@ class IndexmapValidatorTest < Minitest::Test
           </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
+
+    assert_equal "Invalid sitemap lastmod values detected: https://example.com/about", error.message
   end
 
   def test_validate_raises_for_empty_sitemaps
-    Dir.mktmpdir do |directory|
-      path = Pathname(directory).join("sitemap.xml")
-      path.write(<<~XML)
+    error = assert_raises(Indexmap::ValidationError) do
+      validate_sitemap(<<~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
+
+    assert_equal "Sitemap has no URLs: sitemap.xml", error.message
   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)
+    error = assert_raises(Indexmap::ValidationError) do
+      validate_sitemap(<<~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
+    end
 
-      error = assert_raises(Indexmap::ValidationError) do
-        Indexmap::Validator.new(path: path).validate!
-      end
+    assert_equal "Missing child sitemap file: sitemap-pages.xml", error.message
+  end
 
-      assert_equal "Missing child sitemap file: #{child_path}", error.message
-    end
+  def test_validate_preserves_directory_keys_for_child_sitemap_files
+    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://example.com/sitemaps/sitemap-pages.xml</loc></sitemap>
+      </sitemapindex>
+    XML
+    storage.write("sitemaps/sitemap-pages.xml", <<~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></url>
+      </urlset>
+    XML
+
+    assert Indexmap::Validator.new(
+      configuration: configuration_with(storage: storage, index_filename: "sitemaps/sitemap.xml")
+    ).validate!
+  end
+
+  def test_validate_resolves_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>sitemap-pages.xml</loc></sitemap>
+      </sitemapindex>
+    XML
+    storage.write("sitemaps/sitemap-pages.xml", <<~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></url>
+      </urlset>
+    XML
+
+    assert Indexmap::Validator.new(
+      configuration: configuration_with(storage: storage, index_filename: "sitemaps/sitemap.xml")
+    ).validate!
   end
 
   def test_validate_passes_for_valid_sitemap
-    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></url>
-        </urlset>
-      XML
+    assert validate_sitemap(<<~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></url>
+      </urlset>
+    XML
+  end
 
-      assert Indexmap::Validator.new(path: path).validate!
+  private
+
+  def validate_sitemap(body)
+    storage = Indexmap::Storage::Memory.new
+    storage.write("sitemap.xml", body)
+
+    Indexmap::Validator.new(configuration: configuration_with(storage: storage)).validate!
+  end
+
+  def configuration_with(storage: Indexmap::Storage::Memory.new, index_filename: "sitemap.xml")
+    Indexmap::Configuration.new.tap do |configuration|
+      configuration.base_url = "https://example.com"
+      configuration.index_filename = index_filename
+      configuration.storage = storage
     end
   end
 end

data/test/indexmap/writer_test.rb

@@ -3,97 +3,86 @@
 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))
-          ]
-        )
-      ]
+  def test_writes_sitemap_index_and_child_sitemap_documents
+    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
+    files = Indexmap::Writer.new(
+      sections: sections,
+      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"))
+    index_xml = files.find { |file| file.filename == "sitemap.xml" }.body
+    child_xml = files.find { |file| file.filename == "sitemap-pages.xml" }.body
 
-      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
+    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
 
   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
+    files = Indexmap::Writer.new(
+      sections: [
+        {
+          filename: "sitemap-pages.xml",
+          entries: [
+            {loc: "https://example.com/about", lastmod: "2026-04-20T09:15:00Z"}
+          ]
+        }
+      ],
+      base_url: "https://example.com"
+    ).write
 
-      child_xml = File.read(File.join(directory, "sitemap-pages.xml"))
+    child_xml = files.find { |file| file.filename == "sitemap-pages.xml" }.body
 
-      assert_includes child_xml, "<loc>https://example.com/about</loc>"
-      assert_includes child_xml, "<lastmod>2026-04-20T09:15:00Z</lastmod>"
-    end
+    assert_includes child_xml, "<loc>https://example.com/about</loc>"
+    assert_includes child_xml, "<lastmod>2026-04-20T09:15:00Z</lastmod>"
   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
+    files = 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"}
+      ],
+      base_url: "https://example.com"
+    ).write
 
-      sitemap_xml = File.read(File.join(directory, "sitemap.xml"))
+    sitemap_xml = files.fetch(0).body
 
-      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
+    assert_equal 1, files.size
+    assert_equal "sitemap.xml", files.fetch(0).filename
+    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"
   end
 
   def test_omits_sitemap_index_lastmod_when_sections_have_no_lastmod
-    Dir.mktmpdir do |directory|
-      Indexmap::Writer.new(
-        sections: [
-          Indexmap::Section.new(
-            filename: "sitemap-pages.xml",
-            entries: [Indexmap::Entry.new(loc: "https://example.com/about")]
-          )
-        ],
-        public_path: directory,
-        base_url: "https://example.com"
-      ).write
+    files = Indexmap::Writer.new(
+      sections: [
+        Indexmap::Section.new(
+          filename: "sitemap-pages.xml",
+          entries: [Indexmap::Entry.new(loc: "https://example.com/about")]
+        )
+      ],
+      base_url: "https://example.com"
+    ).write
 
-      index_xml = File.read(File.join(directory, "sitemap.xml"))
+    index_xml = files.find { |file| file.filename == "sitemap.xml" }.body
 
-      refute_includes index_xml, "<lastmod>"
-    end
+    refute_includes index_xml, "<lastmod>"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: indexmap
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Paulo Fidalgo
@@ -183,12 +183,15 @@ files:
 - lib/indexmap/index_now_configuration.rb
 - lib/indexmap/output.rb
 - lib/indexmap/parser.rb
-- lib/indexmap/path.rb
 - lib/indexmap/pinger/base.rb
 - lib/indexmap/pinger/google.rb
 - lib/indexmap/pinger/index_now.rb
 - lib/indexmap/railtie.rb
 - lib/indexmap/section.rb
+- lib/indexmap/storage/active_storage.rb
+- lib/indexmap/storage/file.rb
+- lib/indexmap/storage/filesystem.rb
+- lib/indexmap/storage/memory.rb
 - lib/indexmap/task_runner.rb
 - lib/indexmap/validator.rb
 - lib/indexmap/version.rb
@@ -196,9 +199,9 @@ files:
 - lib/tasks/indexmap_tasks.rake
 - test/indexmap/configuration_test.rb
 - test/indexmap/parser_test.rb
-- test/indexmap/path_test.rb
 - test/indexmap/pinger/google_test.rb
 - test/indexmap/pinger/index_now_test.rb
+- test/indexmap/storage_test.rb
 - test/indexmap/task_runner_test.rb
 - test/indexmap/validator_test.rb
 - test/indexmap/writer_test.rb