site_maps 0.0.1.beta3 → 0.1.1

data/lib/site_maps/builder/url.rb

@@ -11,20 +11,23 @@ module SiteMaps::Builder
 
     attr_reader :attributes
 
-    def initialize(link, **attributes)
-      @attributes = DEFAULTS.merge(attributes)
+    def initialize(link, emit_priority: true, emit_changefreq: true, **attributes)
+      defaults = DEFAULTS.dup
+      defaults.delete(:priority) unless emit_priority
+      defaults.delete(:changefreq) unless emit_changefreq
+      @attributes = defaults.merge(attributes)
       @attributes[:loc] = link
-      @attributes[:alternates] = SiteMaps::Primitives::Array.wrap(@attributes[:alternates])
-      @attributes[:videos] = SiteMaps::Primitives::Array.wrap(@attributes[:videos])
-      @attributes[:images] = SiteMaps::Primitives::Array.wrap(@attributes[:images])
+      @attributes[:alternates] = SiteMaps::Primitive::Array.wrap(@attributes[:alternates])
+      @attributes[:videos] = SiteMaps::Primitive::Array.wrap(@attributes[:videos])
+      @attributes[:images] = SiteMaps::Primitive::Array.wrap(@attributes[:images])
       if (video = @attributes.delete(:video))
-        @attributes[:videos].concat(SiteMaps::Primitives::Array.wrap(video))
+        @attributes[:videos].concat(SiteMaps::Primitive::Array.wrap(video))
       end
       if (alternate = @attributes.delete(:alternate))
-        @attributes[:alternates].concat(SiteMaps::Primitives::Array.wrap(alternate))
+        @attributes[:alternates].concat(SiteMaps::Primitive::Array.wrap(alternate))
       end
       if (image = @attributes.delete(:image))
-        @attributes[:images].concat(SiteMaps::Primitives::Array.wrap(image))
+        @attributes[:images].concat(SiteMaps::Primitive::Array.wrap(image))
       end
       @attributes[:images] = @attributes[:images][0...SiteMaps::MAX_LENGTH[:images]]
     end
@@ -121,9 +124,9 @@ module SiteMaps::Builder
 
         if self[:pagemap].is_a?(Hash) && (pagemap = self[:pagemap]).any?
           builder.pagemap :PageMap do
-            SiteMaps::Primitives::Array.wrap(pagemap[:dataobjects]).each do |dataobject|
+            SiteMaps::Primitive::Array.wrap(pagemap[:dataobjects]).each do |dataobject|
               builder.pagemap :DataObject, type: dataobject[:type].to_s, id: dataobject[:id].to_s do
-                SiteMaps::Primitives::Array.wrap(dataobject[:attributes]).each do |attribute|
+                SiteMaps::Primitive::Array.wrap(dataobject[:attributes]).each do |attribute|
                   builder.pagemap :Attribute, attribute[:value].to_s, name: attribute[:name].to_s
                 end
               end

data/lib/site_maps/builder/url_set.rb

@@ -10,32 +10,42 @@ module SiteMaps::Builder
       "video" => "http://www.google.com/schemas/sitemap-video/1.1"
     }.freeze
 
-    HEADER = <<~HEADER
-      <?xml version="1.0" encoding="UTF-8"?>
+    XML_DECLARATION = %(<?xml version="1.0" encoding="UTF-8"?>)
+    URLSET_OPEN = <<~URLSET_OPEN
       <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns:xhtml="http://www.w3.org/1999/xhtml"
         xsi:schemaLocation="http://www.sitemaps.org/schemas/sitemap/0.9 http://www.sitemaps.org/schemas/sitemap/0.9/sitemap.xsd"
       #{SCHEMAS.map { |name, uri| "  xmlns:#{name}=\"#{uri}\"" }.join("\n")}
       >
-    HEADER
+    URLSET_OPEN
+    HEADER = "#{XML_DECLARATION}\n#{URLSET_OPEN}"
     FOOTER = "</urlset>"
     FOOTER_BYTESIZE = FOOTER.bytesize
 
     attr_reader :content, :links_count, :news_count
 
-    def initialize
+    def initialize(max_links: SiteMaps::MAX_LENGTH[:links], emit_priority: true, emit_changefreq: true, xsl_url: nil)
       @content = StringIO.new
-      @content.puts(HEADER)
+      if xsl_url
+        @content.puts(XML_DECLARATION)
+        @content.puts(XSLStylesheet.processing_instruction(xsl_url))
+        @content.puts(URLSET_OPEN)
+      else
+        @content.puts(HEADER)
+      end
       @links_count = 0
       @news_count = 0
       @last_modified = nil
+      @max_links = max_links
+      @emit_priority = emit_priority
+      @emit_changefreq = emit_changefreq
     end
 
     def add(link, **options)
       raise SiteMaps::FullSitemapError if finalized?
 
-      url = SiteMaps::Builder::URL.new(link, **options)
+      url = SiteMaps::Builder::URL.new(link, emit_priority: @emit_priority, emit_changefreq: @emit_changefreq, **options)
       raise SiteMaps::FullSitemapError unless fit?(url)
 
       content.puts(url.to_xml)
@@ -83,7 +93,7 @@ module SiteMaps::Builder
 
     # @param url [Builder::URL]
     def fit?(url)
-      return false if links_count >= SiteMaps::MAX_LENGTH[:links]
+      return false if links_count >= @max_links
       return false if url.news? && news_count >= SiteMaps::MAX_LENGTH[:news]
 
       (bytesize + url.bytesize + FOOTER_BYTESIZE) <= SiteMaps::MAX_FILESIZE

data/lib/site_maps/builder/xsl_stylesheet.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+module SiteMaps::Builder
+  class XSLStylesheet
+    URLSET_XSL = <<~XSL
+      <?xml version="1.0" encoding="UTF-8"?>
+      <xsl:stylesheet version="2.0"
+        xmlns:html="http://www.w3.org/TR/REC-html40"
+        xmlns:sitemap="http://www.sitemaps.org/schemas/sitemap/0.9"
+        xmlns:image="http://www.google.com/schemas/sitemap-image/1.1"
+        xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+        <xsl:output method="html" version="1.0" encoding="UTF-8" indent="yes"/>
+        <xsl:template match="/">
+          <html xmlns="http://www.w3.org/1999/xhtml">
+            <head>
+              <title>XML Sitemap</title>
+              <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+              <style type="text/css">
+                body {
+                  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen-Sans, Ubuntu, Cantarell, "Helvetica Neue", sans-serif;
+                  font-size: 13px;
+                  color: #545353;
+                }
+                a { color: #05809e; text-decoration: none; }
+                a:visited { color: #06577d; }
+                a:hover { text-decoration: underline; }
+                #content {
+                  margin: 0 auto;
+                  padding: 0 20px;
+                  max-width: 1200px;
+                }
+                h1 { font-size: 24px; margin: 20px 0 10px; }
+                p.desc { color: #777; margin: 0 0 20px; }
+                table {
+                  border: none;
+                  border-collapse: collapse;
+                  width: 100%;
+                  margin: 0 0 20px;
+                }
+                th {
+                  text-align: left;
+                  padding: 10px 8px;
+                  font-size: 12px;
+                  border-bottom: 1px solid #ccc;
+                }
+                td {
+                  padding: 8px;
+                  font-size: 12px;
+                  border-bottom: 1px solid #eee;
+                }
+                tr:nth-child(odd) td { background-color: #f8f8f8; }
+                tr:hover td { background-color: #e8e8e8; }
+                td.url { max-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+                #footer { margin: 10px 0 30px; font-size: 11px; color: #999; }
+              </style>
+            </head>
+            <body>
+              <div id="content">
+                <h1>XML Sitemap</h1>
+                <p class="desc">
+                  This XML sitemap is used by search engines which follow the
+                  <a href="https://www.sitemaps.org">XML sitemap standard</a>.
+                </p>
+                <table>
+                  <tr>
+                    <th style="width:80%">URL</th>
+                    <th style="width:5%">Images</th>
+                    <th style="width:15%">Last Modified</th>
+                  </tr>
+                  <xsl:for-each select="sitemap:urlset/sitemap:url">
+                    <tr>
+                      <td class="url">
+                        <a href="{sitemap:loc}"><xsl:value-of select="sitemap:loc"/></a>
+                      </td>
+                      <td>
+                        <xsl:value-of select="count(image:image)"/>
+                      </td>
+                      <td>
+                        <xsl:value-of select="concat(substring(sitemap:lastmod, 0, 11), ' ', substring(sitemap:lastmod, 12, 5))"/>
+                      </td>
+                    </tr>
+                  </xsl:for-each>
+                </table>
+                <p id="footer">
+                  Generated by <a href="https://github.com/marcosgz/site_maps">SiteMaps</a>
+                </p>
+              </div>
+            </body>
+          </html>
+        </xsl:template>
+      </xsl:stylesheet>
+    XSL
+
+    INDEX_XSL = <<~XSL
+      <?xml version="1.0" encoding="UTF-8"?>
+      <xsl:stylesheet version="2.0"
+        xmlns:html="http://www.w3.org/TR/REC-html40"
+        xmlns:sitemap="http://www.sitemaps.org/schemas/sitemap/0.9"
+        xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+        <xsl:output method="html" version="1.0" encoding="UTF-8" indent="yes"/>
+        <xsl:template match="/">
+          <html xmlns="http://www.w3.org/1999/xhtml">
+            <head>
+              <title>XML Sitemap Index</title>
+              <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+              <style type="text/css">
+                body {
+                  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen-Sans, Ubuntu, Cantarell, "Helvetica Neue", sans-serif;
+                  font-size: 13px;
+                  color: #545353;
+                }
+                a { color: #05809e; text-decoration: none; }
+                a:visited { color: #06577d; }
+                a:hover { text-decoration: underline; }
+                #content {
+                  margin: 0 auto;
+                  padding: 0 20px;
+                  max-width: 1200px;
+                }
+                h1 { font-size: 24px; margin: 20px 0 10px; }
+                p.desc { color: #777; margin: 0 0 20px; }
+                table {
+                  border: none;
+                  border-collapse: collapse;
+                  width: 100%;
+                  margin: 0 0 20px;
+                }
+                th {
+                  text-align: left;
+                  padding: 10px 8px;
+                  font-size: 12px;
+                  border-bottom: 1px solid #ccc;
+                }
+                td {
+                  padding: 8px;
+                  font-size: 12px;
+                  border-bottom: 1px solid #eee;
+                }
+                tr:nth-child(odd) td { background-color: #f8f8f8; }
+                tr:hover td { background-color: #e8e8e8; }
+                td.url { max-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+                #footer { margin: 10px 0 30px; font-size: 11px; color: #999; }
+              </style>
+            </head>
+            <body>
+              <div id="content">
+                <h1>XML Sitemap Index</h1>
+                <p class="desc">
+                  This XML sitemap index file contains
+                  <xsl:value-of select="count(sitemap:sitemapindex/sitemap:sitemap)"/> sitemaps.
+                </p>
+                <table>
+                  <tr>
+                    <th style="width:75%">Sitemap</th>
+                    <th style="width:25%">Last Modified</th>
+                  </tr>
+                  <xsl:for-each select="sitemap:sitemapindex/sitemap:sitemap">
+                    <tr>
+                      <td class="url">
+                        <a href="{sitemap:loc}"><xsl:value-of select="sitemap:loc"/></a>
+                      </td>
+                      <td>
+                        <xsl:value-of select="concat(substring(sitemap:lastmod, 0, 11), ' ', substring(sitemap:lastmod, 12, 5))"/>
+                      </td>
+                    </tr>
+                  </xsl:for-each>
+                </table>
+                <p id="footer">
+                  Generated by <a href="https://github.com/marcosgz/site_maps">SiteMaps</a>
+                </p>
+              </div>
+            </body>
+          </html>
+        </xsl:template>
+      </xsl:stylesheet>
+    XSL
+
+    class << self
+      def processing_instruction(url)
+        %(<?xml-stylesheet type="text/xsl" href="#{url}"?>)
+      end
+
+      def urlset_xsl
+        URLSET_XSL
+      end
+
+      def index_xsl
+        INDEX_XSL
+      end
+    end
+  end
+end

data/lib/site_maps/cli.rb

@@ -9,6 +9,7 @@ module SiteMaps
     method_option :max_threads, type: :numeric, aliases: "-c", default: 4
     method_option :context, type: :hash, default: {}
     method_option :enqueue_remaining, type: :boolean, default: false
+    method_option :ping, type: :boolean, default: false, desc: "Ping search engines after generation"
 
     desc "generate 1st_process,2nd_process ... ,Nth_process", "Generate sitemap.xml files for the given processes"
     default_command :start
@@ -26,14 +27,17 @@ module SiteMaps
 
       SiteMaps::Notification.subscribe(SiteMaps::Runner::EventListener)
 
+      context = (opts[:context] || {}).transform_keys(&:to_sym)
       runner = SiteMaps.generate(
         config_file: opts[:config_file],
-        max_threads: opts[:max_threads]
+        max_threads: opts[:max_threads],
+        context: context.empty? ? nil : context,
+        ping: opts[:ping] || nil
       )
       if processes.empty?
         runner.enqueue_all
       else
-        kwargs = (opts[:context] || {}).transform_keys(&:to_sym)
+        kwargs = context
         processes.split(",").each do |process|
           runner.enqueue(process.strip.to_sym, **kwargs)
         end

data/lib/site_maps/configuration.rb

@@ -37,6 +37,13 @@ module SiteMaps
 
     attribute :url
     attribute :directory, default: "/tmp/sitemaps"
+    attribute :max_links, default: 50_000
+    attribute :emit_priority, default: true
+    attribute :emit_changefreq, default: true
+    attribute :xsl_stylesheet_url
+    attribute :xsl_index_stylesheet_url
+    attribute :ping_search_engines, default: false
+    attribute :ping_engines
 
     def initialize(**options)
       default_attributes.merge(options).each do |key, value|
@@ -90,7 +97,7 @@ module SiteMaps
 
     def remote_sitemap_directory
       path = ::URI.parse(url).path
-      path = path[1..-1] if path.start_with?("/")
+      path = path[1..] if path.start_with?("/")
       path.split("/")[0..-2].join("/")
     end
 

data/lib/site_maps/incremental_location.rb

@@ -53,7 +53,7 @@ module SiteMaps
       end
       base = uri.dup.tap { |v| v.path = "" }.to_s
       basename = File.basename(uri.path)
-      index_basename = basename.sub(/[\.](xml|xml\.gz)$/, "#{PLACEHOLDER}.\\1")
+      index_basename = basename.sub(/\.(xml|xml\.gz)$/, "#{PLACEHOLDER}.\\1")
 
       @placeholder_url = File.join(base, File.join(File.dirname(uri.path), index_basename))
       @uri = URI(File.join(base, File.join(File.dirname(uri.path), basename)))

data/lib/site_maps/middleware.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module SiteMaps
+  class Middleware
+    DEFAULT_X_ROBOTS_TAG = "noindex, follow"
+    DEFAULT_CACHE_CONTROL = "public, max-age=3600"
+    URLSET_XSL_PATH = "/_sitemap-stylesheet.xsl"
+    INDEX_XSL_PATH = "/_sitemap-index-stylesheet.xsl"
+
+    # @param adapter [Object, #call, nil] Adapter instance, a callable (0-arg or 1-arg
+    #   receiving the Rack env) that returns an adapter, or nil to fall back to
+    #   SiteMaps.current_adapter.
+    #
+    # @param public_prefix [String, #call, nil] A prefix present in the **public URL**
+    #   that is absent from the storage path. Stripped from the incoming request path
+    #   to derive the internal lookup path.
+    #
+    #   Example: sitemaps stored at `/sitemap.xml`, served publicly at
+    #   `/sitemaps/tenant/sitemap.xml` → `public_prefix: "/sitemaps/tenant"`
+    #
+    # @param storage_prefix [String, #call, nil] A prefix present in the **storage
+    #   path** that is absent from the public URL. Prepended to the incoming request
+    #   path to derive the internal lookup path.
+    #
+    #   Example: sitemaps stored at `/sitemaps/tenant/sitemap.xml`, served publicly at
+    #   `/sitemap.xml` → `storage_prefix: "/sitemaps/tenant"`
+    #
+    # Both options accept a callable (0-arg or 1-arg receiving env), which is useful
+    # in multi-tenant setups where the prefix depends on the current request/site.
+    #
+    def initialize(
+      app,
+      adapter: nil,
+      public_prefix: nil,
+      storage_prefix: nil,
+      x_robots_tag: DEFAULT_X_ROBOTS_TAG,
+      cache_control: DEFAULT_CACHE_CONTROL
+    )
+      @app = app
+      @adapter = adapter
+      @public_prefix = public_prefix
+      @storage_prefix = storage_prefix
+      @x_robots_tag = x_robots_tag
+      @cache_control = cache_control
+    end
+
+    def call(env)
+      path = env["PATH_INFO"]
+
+      if xsl_request?(path)
+        serve_xsl(path)
+      elsif path.end_with?(".xml", ".xml.gz")
+        pub_prefix = resolve_value(@public_prefix, env)
+        sto_prefix = resolve_value(@storage_prefix, env)
+
+        # Strip public prefix (nil = no match when prefix is configured but doesn't match)
+        stripped = strip_prefix(path, pub_prefix)
+
+        # Prepend storage prefix to get the internal path used for adapter lookups
+        internal_path = stripped && prepend_prefix(stripped, sto_prefix)
+
+        # Only resolve the adapter (potentially expensive: DB lookup, callable) when
+        # the path already looks like a sitemap file and passed prefix checks.
+        current_adapter = resolve_adapter(env) if internal_path
+        if current_adapter && sitemap_request?(internal_path, current_adapter)
+          serve_sitemap(internal_path, current_adapter, pub_prefix: pub_prefix, sto_prefix: sto_prefix)
+        else
+          @app.call(env)
+        end
+      else
+        @app.call(env)
+      end
+    end
+
+    private
+
+    def resolve_adapter(env)
+      if @adapter.respond_to?(:call)
+        call_with_env(@adapter, env)
+      else
+        @adapter || SiteMaps.current_adapter
+      end
+    end
+
+    # Resolves a string-or-callable option, normalising the trailing slash.
+    def resolve_value(option, env)
+      value = option.respond_to?(:call) ? call_with_env(option, env) : option
+      value&.chomp("/")
+    end
+
+    # Calls a callable with env if it accepts an argument, otherwise with no
+    # arguments. Supports both `-> { Current.site }` (0-arg, when upstream
+    # middleware already set thread-local state) and `->(env) { ... }` (1-arg).
+    def call_with_env(callable, env)
+      callable.arity.zero? ? callable.call : callable.call(env)
+    end
+
+    # Returns the path with the prefix stripped.
+    # Returns nil  when a prefix is configured but the path doesn't start with it
+    # (so the middleware can pass through non-matching requests).
+    # Returns the original path when no prefix is configured.
+    def strip_prefix(path, prefix)
+      return path if prefix.nil? || prefix.empty?
+      return nil unless path.start_with?(prefix)
+
+      stripped = path[prefix.length..]
+      stripped.start_with?("/") ? stripped : "/#{stripped}"
+    end
+
+    # Prepends a storage prefix to a path. A nil/empty prefix is a no-op.
+    def prepend_prefix(path, prefix)
+      return path if prefix.nil? || prefix.empty?
+
+      "#{prefix}#{path}"
+    end
+
+    def sitemap_request?(path, adapter)
+      sitemap_dir = adapter.config.remote_sitemap_directory
+      prefix = sitemap_dir.empty? ? "/" : "/#{sitemap_dir}/"
+      path.start_with?(prefix) && path.end_with?(".xml", ".xml.gz")
+    end
+
+    def xsl_request?(path)
+      path == URLSET_XSL_PATH || path == INDEX_XSL_PATH
+    end
+
+    def serve_sitemap(path, adapter, pub_prefix: nil, sto_prefix: nil)
+      url = "#{adapter.config.base_uri}#{path}"
+      raw_data, metadata = adapter.read(url)
+      body = decompress(raw_data, metadata)
+      body = rewrite_locs(body, adapter.config.base_uri, pub_prefix, sto_prefix)
+
+      [200, sitemap_headers("text/xml; charset=UTF-8"), [body]]
+    rescue SiteMaps::FileNotFoundError
+      @app.call({"PATH_INFO" => path, "REQUEST_METHOD" => "GET"})
+    end
+
+    # Rewrites <loc> URLs in served XML so they match the public paths the
+    # middleware actually handles, not the internal storage paths.
+    #
+    # storage_prefix case: strips the storage prefix from all <loc> URLs.
+    #   stored:  https://example.com/sitemaps/tenant/static/sitemap.xml
+    #   public:  https://example.com/static/sitemap.xml
+    #
+    # public_prefix case: prepends the public prefix to <loc> URLs in sitemap
+    #   index files only (URL sets contain page URLs that must not be touched).
+    #   stored:  https://example.com/static/sitemap.xml
+    #   public:  https://example.com/sitemaps/tenant/static/sitemap.xml
+    def rewrite_locs(body, base_uri, pub_prefix, sto_prefix)
+      base = base_uri.to_s
+
+      if sto_prefix && !sto_prefix.empty?
+        body.gsub("#{base}#{sto_prefix}/", "#{base}/")
+      elsif pub_prefix && !pub_prefix.empty? && body.include?("<sitemapindex")
+        body.gsub("<loc>#{base}/", "<loc>#{base}#{pub_prefix}/")
+      else
+        body
+      end
+    end
+
+    # The adapter may return gzip-compressed data (raw bytes) or already-decompressed
+    # XML. Always serve as plain XML so sitemaps are browsable with XSL stylesheets.
+    def decompress(raw_data, metadata)
+      return raw_data unless metadata && metadata[:content_type] == "application/gzip"
+
+      Zlib::GzipReader.new(StringIO.new(raw_data)).read
+    rescue Zlib::GzipFile::Error
+      # Data was already decompressed (e.g., FileSystem adapter decompresses on read)
+      raw_data
+    end
+
+    def serve_xsl(path)
+      body = if path == INDEX_XSL_PATH
+        Builder::XSLStylesheet.index_xsl
+      else
+        Builder::XSLStylesheet.urlset_xsl
+      end
+
+      [200, xsl_headers, [body]]
+    end
+
+    def sitemap_headers(content_type)
+      {
+        "content-type" => content_type,
+        "x-robots-tag" => @x_robots_tag,
+        "cache-control" => @cache_control
+      }
+    end
+
+    def xsl_headers
+      {
+        "content-type" => "text/xsl; charset=UTF-8",
+        "cache-control" => @cache_control
+      }
+    end
+  end
+end

data/lib/site_maps/notification/event.rb

@@ -43,7 +43,7 @@ module SiteMaps
 
       # @api private
       def listener_method
-        @listener_method ||= Primitives::String.new("on_#{id}").underscore.to_sym
+        @listener_method ||= Primitive::String.new("on_#{id}").underscore.to_sym
       end
     end
   end

data/lib/site_maps/notification/publisher.rb

@@ -11,6 +11,7 @@ module SiteMaps::Notification
     # @api public
     module ClassMethods
       extend Forwardable
+
       def_delegators :bus, :publish, :subscribed?, :unsubscribe
 
       # Register a new event type

data/lib/site_maps/notification.rb

@@ -32,5 +32,6 @@ module SiteMaps
     register_event "sitemaps.before_process_execution"
     register_event "sitemaps.enqueue_process"
     register_event "sitemaps.process_execution"
+    register_event "sitemaps.ping"
   end
 end

data/lib/site_maps/ping.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "net/http"
+
+module SiteMaps
+  module Ping
+    ENGINES = {
+      bing: "https://www.bing.com/ping?sitemap=%{url}"
+    }.freeze
+
+    class << self
+      def ping(sitemap_url, engines: nil)
+        engines ||= ENGINES
+        encoded_url = ERB::Util.url_encode(sitemap_url)
+
+        engines.each_with_object({}) do |(name, url_template), results|
+          ping_url = url_template % {url: encoded_url}
+          uri = URI.parse(ping_url)
+
+          response = Net::HTTP.get_response(uri)
+          results[name] = {status: response.code.to_i, url: ping_url}
+
+          SiteMaps.logger.info("[SiteMaps] Pinged #{name}: #{response.code} - #{ping_url}")
+        rescue => e
+          results[name] = {status: nil, error: e.message, url: ping_url}
+          SiteMaps.logger.warn("[SiteMaps] Failed to ping #{name}: #{e.message}")
+        end
+      end
+
+      def default_engines
+        ENGINES
+      end
+    end
+  end
+end

data/lib/site_maps/{primitives → primitive}/array.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module SiteMaps::Primitives
+module SiteMaps::Primitive
   class Array < ::Array
     def self.wrap(object)
       if object.nil?

data/lib/site_maps/{primitives → primitive}/output.rb

@@ -6,7 +6,7 @@ rescue LoadError
 end
 
 module SiteMaps
-  module Primitives
+  module Primitive
     module Output
       module_function