site_maps 0.0.1.beta1 → 0.0.1.beta3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 58b8a07d1b6a6b8774a2ee2d1dd0e3ae9ebea70095ebbf5b3c0abe4edfdece6b
-  data.tar.gz: 472ea2dcc6760eb0f072f9ffb30b8f31fbf4fcbc25041802f44daed83c81f27c
+  metadata.gz: d0b92468df93a09f176223cd329a97253051d3beece1ebd3c33efe2a8a23b109
+  data.tar.gz: 6d47acbaa8f176cd931929100a26ea1c3184005c6a127dc69bea41fa5ff6194f
 SHA512:
-  metadata.gz: f86928a65fb91dc0f655bf45d87c3b2eedcb1fdeb08a99f509346ec9e7d8388220386322069ba6a9ecc9fb7abab667e5683ea1be42816a8dca83462251f58f27
-  data.tar.gz: 4fafbd0e7da884694f13bf4cc6ff47db28ad8e6b04fcc0680eb671d45fbddafbec1f3d0f6420f5d6190ee439b3f9ecf74cc1307e593c8d11b97e230255788e2f
+  metadata.gz: 58bf88572f4e54bbdf784d33146908198d6fccb4558573946f84ee566a1b2fcb600eada66d81e0c2bc6b4529cee9eb7e631559f1ee863756d8ed561f13beb818
+  data.tar.gz: 4c432015c4a7e2463a22f47742ad779efe2fbcfa7577c408ad50681855bc2b6d8697cde7bc04acb9f8c2113d6f8d41c0571e3c40de53513cf6aa3275ba60a635

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    site_maps (0.0.1.beta1)
+    site_maps (0.0.1.beta3)
       builder (~> 3.0)
       concurrent-ruby (>= 1.1)
       rack (>= 2.0)
@@ -111,7 +111,7 @@ GEM
       addressable (>= 2.8.0)
       crack (>= 0.3.2)
       hashdiff (>= 0.4.0, < 2.0.0)
-    zeitwerk (2.6.18)
+    zeitwerk (2.7.1)
 
 PLATFORMS
   x86_64-linux

data/README.md

@@ -42,15 +42,60 @@ end
 
 After creating the configuration file, you can run the following command to generate the sitemap:
 
-```bash
+```ruby
 SiteMaps.generate(config_file: "config/sitemap.rb")
   .enqueue_all
   .run
 ```
 
-Sitemap links are defined in the `process` block because the gem is designed to generate sitemaps for large websites in parallel. The `process` block will be executed in a separate thread for each process, which will improve the performance of the sitemap generation. Each process can have a unique name and a unique sitemap file location. By omitting the name and the file location, the process will use the `:default` value.
+or you can use the CLI to generate the sitemap:
+
+```bash
+bundle exec site_maps generate --config-file config/sitemap.rb
+```
+
+### Configuration
+
+Configuration can be defined using the `configure` block or by passing the configuration options to the `use` method. Each adapter may have specific configuration options, but the following options are common to all adapters:
+
+* `url` - URL of the main sitemap index file. This URL must ends with `.xml` or `.xml.gz`.
+* `directory` - Directory where the sitemap files will be stored.
+
+Configuration using the `#configure` block
+
+```ruby
+SiteMaps.use(:file_system) do
+  configure do |config|
+    config.url = "https://example.com/sitemaps/sitemap.xml.gz"
+    config.directory = "/home/www/public"
+  end
+  # define sitemap processes..
+end
+```
+
+Configuration using `#config` method
 
-Bellows is an example of a configuration file with multiple processes:
+```ruby
+SiteMaps.use(:file_system) do
+  config.url = "https://example.com/sitemaps/sitemap.xml.gz"
+  config.directory = "/home/www/public"
+  # define sitemap processes..
+end
+```
+
+Configuration passing options to the `#use` method
+
+```ruby
+SiteMaps.use(:file_system, url: "https://example.com/sitemaps/sitemap.xml.gz", directory: "/home/www/public") do
+  # define sitemap processes..
+end
+```
+
+Refer to the adapter documentation to see the specific configuration options.
+
+### Gzip Compression
+
+The sitemap files can be automatically compressed using the gzip algorithm. To enable the gzip compression, just pass the sitemap url with the `.gz` extension.
 
 ```ruby
 # config/sitemap.rb
@@ -59,6 +104,39 @@ SiteMaps.use(:file_system) do
     config.url = "https://example.com/sitemaps/sitemap.xml.gz" # Location of main sitemap index file
     config.directory = "/home/www/public"
   end
+  process do |s|
+    # Add sitemap links
+  end
+end
+```
+
+### Sitemap Index
+
+For small websites, you can use a single sitemap file to store all the links. However, for large websites with thousands of links, you should use a sitemap index file to store the sitemap links. This library will automatically generate the sitemap index file if you define multiple processes or if the amount of links exceeds the maximum limit of links or file size.
+
+
+Criteria to generate the sitemap index file:
+* Multiple processes defined in the configuration file.
+* The amount of links exceeds the maximum limit of links (50,000 links).
+* The amount of news links exceeds the maximum limit of news links (1,000 links).
+* The uncompressed file size exceeds the maximum limit of file size (50MB).
+
+### Static and Dynamic Processes
+
+Sitemap links are defined in the `process` block because the gem is designed to generate sitemaps for large websites in parallel. It means that each process will be executed in a separate thread, which will improve the performance of the sitemap generation.
+
+Each process can have a unique name and a unique sitemap file location. By omitting the name and the file location, the process will use the `:default` value.
+
+Bellow is an example of a configuration file with multiple processes:
+
+```ruby
+# config/sitemap.rb
+SiteMaps.use(:file_system) do
+  configure do |config|
+    config.url = "https://example.com/sitemaps/sitemap.xml" # Location of main sitemap index file
+    config.directory = "/home/www/public"
+  end
+  # Static Processes
   process do |s|
     s.add('/', priority: 1.0, changefreq: "daily")
     s.add('/about', priority: 0.9, changefreq: "weekly")
@@ -68,38 +146,281 @@ SiteMaps.use(:file_system) do
       s.add(category_path(category), priority: 0.7)
     end
   end
-  process :posts, "posts/%{year}-%{month}/sitemap.xml", year: Date.today.year, month: Date.today.month do |s, year, month|
-    Post.where(year: year, month: month).find_each do |post|
+  # Dynamic Processes
+  process :posts, "posts/%{year}-%{month}/sitemap.xml", year: Date.today.year, month: Date.today.month do |s, year:, month:|
+    Post.where(year: year.to_i, month: month.to_i).find_each do |post|
       s.add(post_path(post), priority: 0.8)
     end
   end
 end
 ```
 
-The `process` block can receive a name and a file location as arguments. The file location can contain placeholders that will be replaced by the values passed to the process block. The `process` block can receive a hash with the values that will be used to replace the placeholders in the file location. It will allow you to incrementally generate sitemaps by year and month, for example.
+Dynamic `process` are defined by passing a process name, a location, and a list of extra arguments that will be dinamically replaced by the given values in the `enqueue` method.
+
+Location can contain placeholders that will be replaced by the values passed to the process block(The `%{year}` and `%{month}` of example bellow). Both relative and absolute paths are supported. Note that when using relative paths, the base dir of main sitemap index file will be used as the root directory.
+
+It will let you enqueue the same process multiple times with different values.
 
 ```ruby
 SiteMaps.generate(config_file: "config/sitemap.rb")
-  .enqueue(:posts, year: 2021, month: 1)
-  .enqueue(:posts, year: 2021, month: 2)
+  .enqueue(:posts, year: "2021", month: "01")
+  .enqueue(:posts, year: "2021", month: "02")
   .enqueue_remaining # Enqueue all remaining processes (default and categories)
   .run
 ```
 
-If you are using Rails, you may want to add routes to the sitemap builder. You can use the `include_module` adapter method.
+**Important Considerations:**
+
+* The values of the extra arguments may be strings when they are coming from the CLI or other sources.
+* By omitting the extra arguments, the process will be enqueued with the default values defined in the configuration file. So make sure you define default values or properly add nil checks in the process block to avoid errors.
+
+### Sitemap Extensions
+
+The sitemap builder supports the following sitemap extensions:
+
+* [Alternate](http://support.google.com/webmasters/bin/answer.py?hl=en&answer=2620865)
+* [Image](https://support.google.com/webmasters/answer/178636?hl=en)
+* [Mobile](http://support.google.com/webmasters/bin/answer.py?hl=en&answer=34648)
+* [News](https://support.google.com/news/publisher-center/answer/9606710?hl=en)
+* [PageMap](https://developers.google.com/custom-search/docs/structured_data?csw=1#pagemaps)
+* [Video](https://support.google.com/webmasters/answer/80471?hl=en)
+
+You can add the sitemap links with the extensions by passing a hash with the extension name as the key and the extension attributes as the value.
+
+#### Image
+
+Images can be added to the sitemap links by passing `images` attributes to the `add` method. The `images` attribute should be an array of hashes with the image attributes.
+
+Check out the Google specification [here](https://support.google.com/webmasters/answer/178636?hl=en).
 
 ```ruby
-# config/sitemap.rb
-SiteMaps.use(:file_system) do
-  include_module Rails.application.routes.url_helpers # It's the same of `extend Rails.application.routes.url_helpers`
+config = { ... }
+SiteMaps.use(:file_system, **config) do
+  process do |s|
+    s.add(
+      '/',
+      priority: 1.0,
+      changefreq: "daily",
+      images: [
+        { loc: "https://example.com/image.jpg" }
+      ],
+    )
+  end
+end
+```
+
+Supported attributes:
+* `loc` - URL of the image.
+* `caption` - Image caption.
+* `geo_location` - Image geo location.
+* `title` - Image title.
+* `license` - Image license.
+
+#### Video
+
+Videos can be added to the sitemap links by passing `videos` attributes to the `add` method. The `videos` attribute should be an array of hashes with the video attributes.
+
+Check out the Google specification [here](https://support.google.com/webmasters/answer/80471?hl=en).
+
+```ruby
+config = { ... }
+SiteMaps.use(:file_system, **config) do
+  process do |s|
+    s.add(
+      '/',
+      priority: 1.0,
+      changefreq: "daily",
+      videos: [
+        {
+          thumbnail_loc: "https://example.com/thumbnail.jpg",
+          title: "Video Title",
+          description: "Video Description",
+          content_loc: "https://example.com/video.mp4",
+          player_loc: "https://example.com/player.swf",
+          allow_embed: "yes",
+          autoplay: "ap=1",
+          # ...
+        }
+      ],
+    )
+  end
+end
+```
+Supported attributes:
+* `thumbnail_loc` - URL of the thumbnail image.
+* `title` - Title of the video.
+* `description` - Description of the video.
+* `content_loc` - URL of the video content.
+* `player_loc` - URL of the video player.
+* `allow_embed` - Allow embed attribute of the player location.
+* `autoplay` - Autoplay attribute of the player location.
+* `duration` - Duration of the video in seconds.
+* `expiration_date` - Expiration date of the video.
+* `rating` - Rating of the video.
+* `view_count` - View count of the video.
+* `publication_date` - Publication date of the video.
+* `tags` - Tags of the video.
+* `tag` - Single tag of the video.
+* `category` - Category of the video.
+* `family_friendly` - Family friendly attribute of the video.
+* `gallery_loc` - URL of the video gallery.
+* `gallery_title` - Title of the video gallery.
+* `uploader` - Uploader of the video.
+* `uploader_info` - Uploader info of the video.
+* `price` - Price of the video.
+* `price_currency` - Currency of the video price.
+* `price_type` - Type of the video price.
+* `price_resolution` - Resolution of the video price.
+* `live` - Live attribute of the video.
+* `requires_subscription` - Requires subscription attribute of the video.
+
+#### PageMap
+
+PageMap sitemaps can be added to the sitemap links by passing `pagemap` attributes to the `add` method. The `pagemap` attribute should be a hash with the pagemap attributes.
+
+Check out the Google specification [here](https://developers.google.com/custom-search/docs/structured_data?csw=1#pagemaps).
+
+```ruby
+config = { ... }
+SiteMaps.use(:file_system, **config) do
+  process do |s|
+    s.add(
+      '/',
+      priority: 1.0,
+      changefreq: "daily",
+      pagemap: {
+        dataobjects: [
+          {
+            type: "document",
+            id: "1",
+            attributes: [
+              { name: "title", value: "Page Title" },
+              { name: "description", value: "Page Description" },
+              { name: "url", value: "https://example.com" },
+            ]
+          }
+        ]
+      }
+    )
+  end
+end
+```
+
+Supported attributes:
+* `dataobjects` - Array of hashes with the data objects.
+    * `type` - Type of the object.
+    * `id` - ID of the object.
+    * `attributes` - Array of hashes with the attributes.
+        * `name` - Name of the attribute.
+        * `value` - Value of the attribute.
+
+#### News
+
+News sitemaps can be added to the sitemap links by passing `news` attributes to the `add` method. The `news` attribute should be a hash with the news attributes.
+
+Check out the Google specification [here](https://support.google.com/news/publisher-center/answer/9606710?hl=en).
+
+```ruby
+config = { ... }
+SiteMaps.use(:file_system, **config) do
+  process do |s|
+    s.add(
+      '/',
+      priority: 1.0,
+      changefreq: "daily",
+      news: {
+        publication_name: "Publication Name",
+        publication_language: "en",
+        publication_date: Time.now,
+        genres: "PressRelease",
+        access: "Subscription",
+        title: "News Title",
+        keywords: "News Keywords",
+        stock_tickers: "NASDAQ:GOOG",
+      }
+    )
+  end
+end
+```
+
+Supported attributes:
+* `publication_name` - Name of the publication.
+* `publication_language` - Language of the publication.
+* `publication_date` - Publication date of the news.
+* `genres` - Genres of the news.
+* `access` - Access of the news.
+* `title` - Title of the news.
+* `keywords` - Keywords of the news.
+* `stock_tickers` - Stock tickers of the news.
+
+#### Alternates
+
+You can add alternate links to the sitemap links by passing `alternates` attributes to the `add` method. The `alternates` attribute should be an array of hashes with the alternate attributes.
+
+Check out the Google specification [here](http://support.google.com/webmasters/bin/answer.py?hl=en&answer=2620865).
+
+```ruby
+config = { ... }
+SiteMaps.use(:file_system, **config) do
+  process do |s|
+    s.add(
+      '/',
+      priority: 1.0,
+      changefreq: "daily",
+      alternates: [
+        { href: "https://example.com/en", lang: "en" },
+        { href: "https://example.com/es", lang: "es" },
+      ],
+    )
+  end
+end
+```
+
+Supported attributes:
+* `href` - URL of the alternate link. (Required)
+* `lang` - Language of the alternate link. (Optional)
+* `nofollow` - Nofollow attribute of the alternate link. (Optional)
+* `media` - Media targets for responsive design pages. (Optional)
+
+#### Mobile
+
+Mobile sitemaps include a specific <mobile:mobile/> tag.
+
+Check out the Google specification [here](http://support.google.com/webmasters/bin/answer.py?hl=en&answer=34648).
+
+```ruby
+config = { ... }
+SiteMaps.use(:file_system, **config) do
+  process do |s|
+    s.add('/', mobile: true)
+  end
+end
+```
+
+Supported attributes:
+
+* `mobile` - Mobile attribute of the sitemap link.
 
+## Adapters
+
+The gem provides adapters to store the sitemaps in different locations. The following adapters are available:
+
+* File System
+* AWS S3
+
+### File System
+
+You can use the file system adapter to store the sitemaps in the file system. The configuration is simple, you just need to provide the directory where the sitemaps will be stored.
+
+```ruby
+
+SiteMaps.use(:file_system) do
   configure do |config|
-    config.url = "https://example.com/sitemaps/sitemap.xml.gz" # Location of main sitemap index file
+    config.url = "https://example.com/sitemaps/sitemap.xml.gz"
     config.directory = "/home/www/public"
   end
   process do |s|
-    s.add(root_path, priority: 1.0, changefreq: "daily")
-    s.add(about_path, priority: 0.9, changefreq: "weekly")
+    # Add sitemap links
   end
 end
 ```
@@ -109,23 +430,107 @@ end
 You can use the AWS S3 adapter to store the sitemaps in an S3 bucket. The configuration is similar to the file system adapter, but you need to provide the AWS SDK options.
 
 ```ruby
-aws_sdk_options = {
-  bucket: "my-bucket",
-  region: "us-east-1",
-  aws_access_key: ENV["AWS_ACCESS_KEY_ID"],
-  aws_secret_key: ENV["AWS_SECRET_ACCESS_KEY"],
-  # Optional parameters (default values)
-  acl: "public-read",
-  cache_control: "private, max-age=0, no-cache",
-}
+SiteMaps.use(:aws_sdk) do
+  configure do |config|
+    config.url = "https://my-bucket.s3.amazonaws.com/sitemaps/sitemap.xml"
+    config.directory = "/tmp" # Local directory to store the sitemaps before uploading to S3
+    # AWS S3 specific options
+    config.bucket = "my-bucket"
+    config.region = "us-east-1"
+    config.aws_access_key = ENV["AWS_ACCESS_KEY_ID"]
+    config.aws_secret_key = ENV["AWS_SECRET_ACCESS_KEY"]
+    # Optional parameters (default values)
+    config.acl = "public-read"
+    config.cache_control = "private, max-age=0, no-cache"
+  end
+  process do |s|
+    # Add sitemap links
+  end
+end
+```
+
+If you want to let your rails application as a proxy to the sitemap files, you can create a controller to serve the sitemap files from the S3 bucket.
+
+```ruby
+# config/routes.rb
+get "sitemaps/*relative_path", to: "sitemaps#show", as: :sitemap
+```
+
+```ruby
+# app/controllers/sitemaps_controller.rb
+class SitemapsController < ApplicationController
+  def show
+    location = params.permit("relative_path", "format").to_h.values.join(".")
+
+    unless location =~ /\.xml(\.gz)?$/ # You may want add more validations here
+      raise ActionController::RoutingError, "Not found"
+    end
+
+    data, meta = SiteMaps.current_adapter.read(File.join("sitemaps", location))
+    if location.ends_with?(".xml")
+      render xml: data
+    else
+      send_data(data, disposition: "attachment", type: meta[:content_type])
+    end
+  rescue SiteMaps::FileNotFoundError
+    raise ActionController::RoutingError, "Not found"
+  end
+end
+```
+
+Make sure to let sitemap config in the initializer. You may want to add some caching to avoid hitting the S3 bucket on every request.
+
+
+### Custom Adapters
+
+You can create custom adapters to store the sitemaps in different locations. You just need to create a class that implements the `SiteMaps::Adapters::Adapter` interface. The adapter should implement the following methods:
+
+* `write(url, raw_data, **extra)` - Write the sitemap data to the storage.
+* `read(url)` - Read the sitemap data from the storage.
+* `delete(url)` - Delete the sitemap data from the storage.
+
+```ruby
+class MyAdapter < SiteMaps::Adapters::Adapter
+  def write(url, raw_data, **extra)
+    # Write the sitemap data to the storage
+  end
+
+  def read(url)
+    # Read the sitemap data from the storage
+  end
 
-SiteMaps.use(:aws_sdk, **aws_sdk_options) do
+  def delete(url)
+    # Delete the sitemap data from the storage
+  end
+end
+
+SiteMaps.use(MyAdapter, **config) do
+  process do |s|
+    # Add sitemap links
+  end
+end
+```
+
+#### Adapter Configuration
+
+If you adapter requires additional configuration, you can define a `<adapter class>::Config` inheriting from `SiteMaps::Configuration` and implement the required configuration options.
+
+```ruby
+class MyAdapter::Config < SiteMaps::Configuration
+  attribute :api_key, String
+end
+```
+
+During the adapter initialization, it will automatically detect the configuration class and use it to load the configuration options.
+
+```ruby
+SiteMaps.use(MyAdapter) do
   configure do |config|
-    config.url = "https://my-bucket.s3.amazonaws.com/sitemaps/sitemap.xml.gz"
+    # ...
+    config.api_key = "my-api-key"
   end
   process do |s|
-    s.add('/', priority: 1.0, changefreq: "daily")
-    s.add('/about', priority: 0.9, changefreq: "weekly")
+    # Add sitemap links
   end
 end
 ```
@@ -141,22 +546,41 @@ bundle exec site_maps generate --config-file config/sitemap.rb
 To enqueue dynamic processes, you can pass the process name with the context values.
 
 ```bash
-bundle exec site_maps generate monthly_posts --config-file config/sitemap.rb --context=year:2021,month:1
+bundle exec site_maps generate monthly_posts \
+  --config-file config/sitemap.rb \
+  --context=year:2021 month:1
+```
+
+Enqueue dynamic + remaining processes
+
+```bash
+bundle exec site_maps generate monthly_posts \
+  --config-file config/sitemap.rb \
+  --context=year:2021 month:1 \
+  --enqueue-remaining
+```
+
+passing max threads to run the processes in parallel
+
+```bash
+bundle exec site_maps generate \
+  --config-file config/sitemap.rb \
+  --max-threads 10
 ```
 
 ## Notification
 
 You can subscribe to the internal events to receive notifications about the sitemap generation. The following events are available:
 
-* `sitemaps.runner.enqueue_process` - Triggered when a process is enqueued.
-* `sitemaps.runner.before_process_execution` - Triggered before a process starts execution
-* `sitemaps.runner.process_execution` - Triggered when a process finishes execution.
-* `sitemaps.builder.finalize_urlset` - Triggered when the sitemap builder finishes the URL set.
+* `sitemaps.enqueue_process` - Triggered when a process is enqueued.
+* `sitemaps.before_process_execution` - Triggered before a process starts execution
+* `sitemaps.process_execution` - Triggered when a process finishes execution.
+* `sitemaps.finalize_urlset` - Triggered when the sitemap builder finishes the URL set.
 
 You can subscribe to the events using the following code:
 
 ```ruby
-SiteMaps::Notification.subscribe("sitemaps.runner.enqueue_process") do |event|
+SiteMaps::Notification.subscribe("sitemaps.enqueue_process") do |event|
   puts "Enqueueing process #{event.payload[:name]}"
 end
 ```
@@ -170,6 +594,43 @@ SiteMaps.generate(config_file: "config/sitemap.rb")
   .run
 ```
 
+## Mixins
+
+You can use mixins to extend the sitemap builder with additional methods. The mixins can be used to define common methods that will be used in multiple processes. Make sure they are thread-safe, otherwise I recommend to define them in the process block.
+
+```ruby
+module MyMixin
+  def repository
+    Repository.new
+  end
+
+  def post_path(post)
+    "/posts/#{post.slug}"
+  end
+end
+
+SiteMaps.use(:file_system) do
+  include_module(MyMixin)
+  process do |s|
+    repository.posts.each do |post|
+      s.add(post_path(post), priority: 0.8)
+    end
+  end
+end
+```
+
+We already have a built-in mixin for Rails applications that provides the url helpers through the `route` method.
+
+```ruby
+SiteMaps.use(:file_system) do
+  include_module(SiteMaps::Mixins::Rails)
+  process do |s|
+    s.add(route.root_path, priority: 1.0)
+    s.add(route.about_path, priority: 0.9)
+  end
+end
+```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/site_maps/notification.rb

@@ -28,9 +28,9 @@ module SiteMaps
 
     include Publisher
 
-    register_event "sitemaps.builder.finalize_urlset"
-    register_event "sitemaps.runner.before_process_execution"
-    register_event "sitemaps.runner.enqueue_process"
-    register_event "sitemaps.runner.process_execution"
+    register_event "sitemaps.finalize_urlset"
+    register_event "sitemaps.before_process_execution"
+    register_event "sitemaps.enqueue_process"
+    register_event "sitemaps.process_execution"
   end
 end

data/lib/site_maps/process.rb

@@ -1,7 +1,13 @@
 # frozen_string_literal: true
 
+require "securerandom"
+
 module SiteMaps
   Process = Concurrent::ImmutableStruct.new(:name, :location_template, :kwargs_template, :block) do
+    def id
+      @id ||= SecureRandom.hex(4)
+    end
+
     def location(**kwargs)
       return unless location_template
 

data/lib/site_maps/runner/event_listener.rb

@@ -13,54 +13,58 @@ module SiteMaps
       method(:"on_#{method_name}")
     end
 
-    def on_sitemaps_runner_enqueue_process(event)
+    def on_sitemaps_enqueue_process(event)
       process = event[:process]
       kwargs = event[:kwargs]
       location = process.location(**kwargs)
       print_message(
-        "Enqueue process %<name>s#{" at %<location>s" if location}",
+        "[%<id>s] Enqueue process %<name>s#{" at %<location>s" if location}",
+        id: process.id,
         name: colorize(process.name, :bold),
         location: colorize(location, :lightgray)
       )
       if kwargs.any?
-        print_message("└── Keyword Arguments: {%<kwargs>s}", kwargs: kwargs.map { |k, v| "#{k}: #{v.inspect}" }.join(", "))
+        print_message("     └──── Context: {%<kwargs>s}", kwargs: kwargs.map { |k, v| "#{k}: #{v.inspect}" }.join(", "))
       end
     end
 
-    def on_sitemaps_runner_before_process_execution(event)
+    def on_sitemaps_before_process_execution(event)
       process = event[:process]
       kwargs = event[:kwargs]
       location = process.location(**kwargs)
       print_message(
-        "Executing process %<name>s#{" at %<location>s" if location}",
+        "[%<id>s] Executing process %<name>s#{" at %<location>s" if location}",
+        id: process.id,
         name: colorize(process.name, :bold),
         location: colorize(location, :lightgray)
       )
       if kwargs.any?
-        print_message("└── Keyword Arguments: {%<kwargs>s}", kwargs: kwargs.map { |k, v| "#{k}: #{v.inspect}" }.join(", "))
+        print_message("     └──── Context: {%<kwargs>s}", kwargs: kwargs.map { |k, v| "#{k}: #{v.inspect}" }.join(", "))
       end
     end
 
-    def on_sitemaps_runner_process_execution(event)
+    def on_sitemaps_process_execution(event)
       process = event[:process]
       kwargs = event[:kwargs]
       location = process.location(**kwargs)
       print_message(
-        "[%<runtime>s] Executed process %<name>s#{" at %<location>s" if location}",
+        "[%<id>s][%<runtime>s] Executed process %<name>s#{" at %<location>s" if location}",
+        id: process.id,
         name: colorize(process.name, :bold),
         location: colorize(location, :lightgray),
         runtime: formatted_runtime(event[:runtime])
       )
       if kwargs.any?
-        print_message("└── Keyword Arguments: {%<kwargs>s}", kwargs: kwargs.map { |k, v| "#{k}: #{v.inspect}" }.join(", "))
+        print_message("     └──── Context: {%<kwargs>s}", kwargs: kwargs.map { |k, v| "#{k}: #{v.inspect}" }.join(", "))
       end
     end
 
-    def on_sitemaps_builder_finalize_urlset(event)
+    def on_sitemaps_finalize_urlset(event)
+      process = event[:process]
       links_count = event[:links_count]
       news_count = event[:news_count]
       url = event[:url]
-      text = +"[%<runtime>s] Finalize URLSet with "
+      text = +"[%<id>s][%<runtime>s] Finalize URLSet with "
       text << "%<links>d links" if links_count > 0
       text << " and " if links_count > 0 && news_count > 0
       text << "%<news>d news" if news_count > 0
@@ -68,6 +72,7 @@ module SiteMaps
 
       print_message(
         text,
+        id: process.id,
         links: links_count,
         news: news_count,
         url: colorize(url, :lightgray),

data/lib/site_maps/runner.rb

@@ -18,7 +18,7 @@ module SiteMaps
         raise ArgumentError, "Process :#{process_name} not found"
       end
       kwargs = process.keyword_arguments(kwargs)
-      SiteMaps::Notification.instrument("sitemaps.runner.enqueue_process") do |payload|
+      SiteMaps::Notification.instrument("sitemaps.enqueue_process") do |payload|
         payload[:process] = process
         payload[:kwargs] = kwargs
         if process.dynamic?
@@ -53,15 +53,16 @@ module SiteMaps
       futures = []
       @execution.each do |_process_name, items|
         items.each do |process, kwargs|
-          SiteMaps::Notification.publish("sitemaps.runner.before_process_execution", process: process, kwargs: kwargs)
+          SiteMaps::Notification.publish("sitemaps.before_process_execution", process: process, kwargs: kwargs)
           futures << Concurrent::Future.execute(executor: pool) do
             wrap_process_execution(process) do
-              SiteMaps::Notification.instrument("sitemaps.runner.process_execution") do |payload|
+              SiteMaps::Notification.instrument("sitemaps.process_execution") do |payload|
                 payload[:process] = process
                 payload[:kwargs] = kwargs
                 builder = SiteMaps::SitemapBuilder.new(
                   adapter: adapter,
-                  location: process.location(**kwargs)
+                  location: process.location(**kwargs),
+                  notification_payload: { process: process }
                 )
                 process.call(builder, **kwargs)
                 builder.finalize!

data/lib/site_maps/sitemap_builder.rb

@@ -4,11 +4,12 @@ module SiteMaps
   class SitemapBuilder
     extend Forwardable
 
-    def initialize(adapter:, location: nil)
+    def initialize(adapter:, location: nil, notification_payload: {})
       @adapter = adapter
       @url_set = SiteMaps::Builder::URLSet.new
       @location = location
       @mutex = Mutex.new
+      @notification_payload = notification_payload
     end
 
     def add(path, params: nil, **options)
@@ -31,7 +32,7 @@ module SiteMaps
 
       raw_data = url_set.finalize!
 
-      SiteMaps::Notification.instrument("sitemaps.builder.finalize_urlset") do |payload|
+      SiteMaps::Notification.instrument("sitemaps.finalize_urlset", notification_payload) do |payload|
         payload[:links_count] = url_set.links_count
         payload[:news_count] = url_set.news_count
         payload[:last_modified] = url_set.last_modified
@@ -50,13 +51,13 @@ module SiteMaps
 
     protected
 
-    attr_reader :url_set, :adapter, :location
+    attr_reader :url_set, :adapter, :location, :notification_payload
 
     def_delegators :adapter, :sitemap_index, :config, :repo
 
     def finalize_and_start_next_urlset!
       raw_data = url_set.finalize!
-      SiteMaps::Notification.instrument("sitemaps.builder.finalize_urlset") do |payload|
+      SiteMaps::Notification.instrument("sitemaps.finalize_urlset", notification_payload) do |payload|
         sitemap_url = repo.generate_url(location)
         payload[:url] = sitemap_url
         payload[:links_count] = url_set.links_count

data/lib/site_maps/sitemap_reader.rb

@@ -5,8 +5,8 @@ require "open-uri"
 module SiteMaps
   class SitemapReader
     Error = Class.new(SiteMaps::Error)
-    FileNotFound = Class.new(Error)
-    MalformedFile = Class.new(Error)
+    FileNotFoundError = Class.new(Error)
+    MalformedFileError = Class.new(Error)
 
     def initialize(location)
       @location = Pathname.new(location)
@@ -19,7 +19,7 @@ module SiteMaps
         read_file.read
       end
     rescue Zlib::GzipFile::Error => _e
-      raise MalformedFile.new("The file #{@location} is not a valid Gzip file")
+      raise MalformedFileError.new("The file #{@location} is not a valid Gzip file")
     end
 
     def to_doc
@@ -40,9 +40,9 @@ module SiteMaps
         ::File.open(@location, "r")
       end
     rescue Errno::ENOENT
-      raise FileNotFound.new("The file #{@location} does not exist")
+      raise FileNotFoundError.new("The file #{@location} does not exist")
     rescue OpenURI::HTTPError
-      raise FileNotFound.new("The file #{@location} could not be opened")
+      raise FileNotFoundError.new("The file #{@location} could not be opened")
     end
 
     def compressed?

data/lib/site_maps/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SiteMaps
-  VERSION = "0.0.1.beta1"
+  VERSION = "0.0.1.beta3"
 end

data/site_maps.gemspec

@@ -9,10 +9,10 @@ Gem::Specification.new do |spec|
   spec.email = ["mgzmaster@gmail.com"]
 
   spec.summary = <<~SUMMARY
-    SiteMaps simplifies the generation of sitemaps for ruby or rails applications.
+    Concurrent and Incremental sitemap.xml builder for ruby applications
   SUMMARY
   spec.description = <<~DESCRIPTION
-    SiteMaps is gem that provides a simple way to generate static sitemaps for your ruby or rails applications.
+    SiteMaps is a framework-agnostic library for building sitemap.xml files in a concurrent and incremental way.
   DESCRIPTION
 
   spec.homepage = "https://github.com/marcosgz/site_maps"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: site_maps
 version: !ruby/object:Gem::Version
-  version: 0.0.1.beta1
+  version: 0.0.1.beta3
 platform: ruby
 authors:
 - Marcos G. Zimmermann
 autorequire:
 bindir: exec
 cert_chain: []
-date: 2024-11-21 00:00:00.000000000 Z
+date: 2024-11-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -80,8 +80,8 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.0.0
-description: 'SiteMaps is gem that provides a simple way to generate static sitemaps
-  for your ruby or rails applications.
+description: 'SiteMaps is a framework-agnostic library for building sitemap.xml files
+  in a concurrent and incremental way.
 
   '
 email:
@@ -168,5 +168,5 @@ requirements: []
 rubygems_version: 3.5.21
 signing_key:
 specification_version: 4
-summary: SiteMaps simplifies the generation of sitemaps for ruby or rails applications.
+summary: Concurrent and Incremental sitemap.xml builder for ruby applications
 test_files: []