jekyll-uj-powertools 1.6.24 → 1.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e244425c0a57091b17d74eeb82b585314a5892bc4d2185e6dc50b5d66d7d16c
-  data.tar.gz: e999ee1ea01bee859c675e451c3d8323c984b225a7ae2438f3d06f1f43158848
+  metadata.gz: a39cadef84f1c25e0d674e7004e3f6f041f94d27d5df354eea0f31d1c86bc8e3
+  data.tar.gz: 12f5642a57b3c8bd4dd7a62f1392c95fa665871c2dc304fdd2f2f75432619d40
 SHA512:
-  metadata.gz: 4042544bbfb0c7e818b9d56ab22adb617c0e5ab74f5284e03eaab1c2a5fed114b77e3d7860759cdef9d0ba9d057b542e5e916f690bda237defbf7426056fcff7
-  data.tar.gz: cd588783c0bd5b02069eb47363352d6200d03de8b4208004a34a23db7372a123dffc47b2138174e7969f4380cf39f649ac977c06a41e6dfbedd7469592732a5f
+  metadata.gz: e2c52117d2069807c586ad07e37792fca82216786528d1ecea4d304941f559fa808bc2b8c4bb2eac20dc84c1a9135956fe1c1db35651386336a3ec6053e3ef5c
+  data.tar.gz: a62ca9ec4f212468d6c2e8ade617843907dd46c68f76b328d3e0351424c286554a974ec63add70f4f1931e0e38859c7fe83c7f26b4a1004fa56fbeda607601ea

data/README.md

@@ -294,6 +294,122 @@ Creates language-specific URLs for multilingual sites.
 {% uj_translation_url target_lang, "/pricing" %}
 ```
 
+## Generators
+
+### Dynamic Pages Generator
+Automatically generate pages from collection data based on frontmatter fields. This is useful for creating category, tag, or any taxonomy pages dynamically without manually creating each page.
+
+#### Configuration
+Add to your `_config.yml`:
+
+```yaml
+generators:
+  collection_categories:
+    # Example 1: Extract category from nested frontmatter field
+    - collection: recipes
+      field: recipe.cuisine       # Dot notation for nested fields
+      layout: recipe-category
+      permalink: /recipes/:slug
+      title: ":name Recipes"
+      description: "Browse our collection of :name recipes."
+
+    # Example 2: Simple frontmatter field
+    - collection: products
+      field: category
+      layout: product-category
+      permalink: /products/:slug
+      title: ":name Products"
+      description: "Shop our :name products."
+
+    # Example 3: Minimal config (uses defaults)
+    - collection: articles
+      field: category
+      layout: article-category
+```
+
+#### Template Variables
+Use these placeholders in `title`, `description`, and `permalink`:
+- `:name` - The formatted category name (e.g., "Asian Cuisine")
+- `:slug` - The URL-safe slug (e.g., "asian-cuisine")
+
+#### Defaults
+- `permalink`: `/:collection/:slug` (e.g., `/recipes/asian`)
+- `title`: `:name`
+- `description`: `Browse our collection of :name.`
+
+#### Generated Page Data
+Each generated page includes the following data accessible in the layout:
+- `page.title` - The formatted title
+- `page.description` - The formatted description
+- `page.category_slug` - URL-safe slug (e.g., "asian-cuisine")
+- `page.category_name` - Human-readable name (e.g., "Asian Cuisine")
+- `page.collection_name` - Source collection name (e.g., "recipes")
+- `page.meta.title` - SEO title with site name appended
+- `page.meta.description` - SEO description
+
+#### Example Layout
+Create a layout file (e.g., `_layouts/recipe-category.html`) to display the category page:
+
+```liquid
+---
+layout: default
+---
+<h1>{{ page.category_name }}</h1>
+<p>{{ page.description }}</p>
+
+{% assign items = site.recipes | where_exp: "item", "item.recipe.cuisine == page.category_name" %}
+{% for item in items %}
+  <article>
+    <h2><a href="{{ item.url }}">{{ item.title }}</a></h2>
+  </article>
+{% endfor %}
+```
+
+## Parallel Build
+Speed up Jekyll builds by rendering pages and documents in parallel using multiple CPU threads. This can significantly reduce build times for sites with many pages.
+
+**Enabled by default** - no configuration needed! The plugin automatically uses all available CPU cores.
+
+### Configuration
+Customize parallel build behavior in `_config.yml`:
+
+```yaml
+parallel_build:
+  enabled: true          # Enable/disable parallel builds (default: true)
+  threads: 8             # Number of threads (default: number of CPU cores)
+  min_items: 1           # Minimum items before parallelizing (default: 1)
+```
+
+### Disabling Parallel Build
+If you encounter issues with thread-safety in custom Liquid tags:
+
+```yaml
+# Option 1: Disable entirely
+parallel_build: false
+
+# Option 2: Disable via enabled flag
+parallel_build:
+  enabled: false
+```
+
+### Performance Tips
+- Parallel builds work best with CPU-bound Liquid rendering
+- For maximum speed, combine with `limit_collections` during development
+- Use `--profile` to identify slow templates that benefit most from parallelization
+
+## Development Config (`_config.dev.yml`)
+Speed up dev builds by limiting collections. Create `_config.dev.yml` in your Jekyll source:
+
+```yaml
+limit_collections:
+  recipes: 50
+  products: 20
+```
+
+Run with: `bundle exec jekyll serve --config _config.yml,_config.dev.yml`
+
+UJ auto-loads this file in dev mode.
+
 ## Final notes
 These examples show how you can use the features of `jekyll-uj-powertools` in your Jekyll site.
 

data/jekyll-uj-powertools.gemspec

@@ -5,7 +5,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 Gem::Specification.new do |spec|
   # Gem info
   spec.name = "jekyll-uj-powertools"
-  spec.version = "1.6.24"
+  spec.version = "1.7.1"
 
   # Author info
   spec.authors = ["ITW Creative Works"]
@@ -31,10 +31,14 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
   spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "ostruct"
 
   # Translation and HTML manipulation requires Nokogiri
   spec.add_runtime_dependency 'nokogiri', '>= 1.17'
 
+  # Parallel processing for faster builds
+  spec.add_runtime_dependency 'parallel', '>= 1.20'
+
   # Ruby version
   spec.required_ruby_version = ">= 2.0.0"
 end

data/lib/generators/dynamic-pages.rb

@@ -0,0 +1,152 @@
+# Dynamic Pages Generator
+# Automatically generates pages from collection data based on config
+#
+# Usage in _config.yml:
+#
+#   generators:
+#     collection_categories:
+#       # Example 1: Extract category from frontmatter field
+#       - collection: recipes
+#         field: recipe.cuisine       # Dot notation for nested fields
+#         layout: recipe-category
+#         permalink: /recipes/:slug
+#         title: ":name Recipes"
+#         description: "Browse our collection of :name recipes."
+#
+#       # Example 2: Simple frontmatter field
+#       - collection: products
+#         field: category
+#         layout: product-category
+#         permalink: /products/:slug
+#         title: ":name Products"
+#         description: "Shop our :name products."
+#
+#       # Example 3: Minimal config (uses defaults)
+#       - collection: articles
+#         field: category
+#         layout: article-category
+#
+# Template variables for title/description/permalink:
+#   :name - The formatted category name (e.g., "Asian Cuisine")
+#   :slug - The URL-safe slug (e.g., "asian-cuisine")
+#
+# Defaults:
+#   permalink: /:collection/:slug (e.g., /recipes/asian)
+#   title: :name
+#   description: "Browse our collection of :name."
+
+module Jekyll
+  class DynamicPagesGenerator < Generator
+    safe true
+    priority :normal  # Run before InjectProperties (:low) so dynamic pages get resolved data
+
+    def generate(site)
+      config = site.config.dig('generators', 'collection_categories')
+      return unless config.is_a?(Array)
+
+      config.each do |category_config|
+        generate_category_pages(site, category_config)
+      end
+    end
+
+    private
+
+    def generate_category_pages(site, config)
+      collection_name = config['collection']
+      field = config['field']
+      return unless collection_name && field
+
+      collection = site.collections[collection_name]
+      return unless collection
+
+      # Configuration with defaults
+      layout = config['layout']
+      permalink_template = config['permalink'] || "/#{collection_name}/:slug"
+      title_template = config['title'] || ':name'
+      description_template = config['description'] || 'Browse our collection of :name.'
+
+      # Extract unique categories from documents
+      categories = {}
+
+      collection.docs.each do |doc|
+        category_value = dig_value(doc.data, field)
+        next unless category_value && !category_value.empty?
+
+        category_slug = slugify(category_value)
+        next if categories.key?(category_slug)
+
+        # Format category name: titleize
+        category_name = titleize(category_value)
+
+        # Apply templates
+        permalink = apply_template(permalink_template, category_name, category_slug)
+        title = apply_template(title_template, category_name, category_slug)
+        description = apply_template(description_template, category_name, category_slug)
+
+        categories[category_slug] = {
+          'slug' => category_slug,
+          'name' => category_name,
+          'title' => title,
+          'description' => description,
+          'permalink' => permalink
+        }
+      end
+
+      # Generate a page for each category
+      categories.each do |slug, data|
+        page = DynamicCategoryPage.new(site, layout, data, collection_name)
+        site.pages << page
+      end
+
+      Jekyll.logger.info "DynamicPages:", "Generated #{categories.size} category pages for '#{collection_name}'"
+    end
+
+    # Dig into nested hash using dot notation (e.g., "recipe.cuisine")
+    def dig_value(hash, field)
+      keys = field.split('.')
+      value = hash
+      keys.each do |key|
+        return nil unless value.is_a?(Hash)
+        value = value[key]
+      end
+      value.is_a?(String) ? value : nil
+    end
+
+    def slugify(str)
+      str.to_s.downcase.strip.gsub(/[^\w\s-]/, '').gsub(/[\s_]+/, '-')
+    end
+
+    def titleize(str)
+      str.to_s.split(/[\s_-]+/).map(&:capitalize).join(' ')
+    end
+
+    def apply_template(template, name, slug)
+      template.gsub(':name', name).gsub(':slug', slug)
+    end
+  end
+
+  # Custom page class for dynamically generated category pages
+  class DynamicCategoryPage < Page
+    def initialize(site, layout, data, collection_name)
+      @site = site
+      @base = site.source
+      @dir = ''
+      @name = "#{data['slug']}.html"
+
+      self.process(@name)
+      self.data = {
+        'layout' => layout,
+        'title' => data['title'],
+        'description' => data['description'],
+        'category_slug' => data['slug'],
+        'category_name' => data['name'],
+        'collection_name' => collection_name,
+        'permalink' => data['permalink'],
+        'meta' => {
+          'title' => "#{data['title']} - #{site.config.dig('brand', 'name') || site.config['title']}",
+          'description' => data['description']
+        }
+      }
+    end
+  end
+end

data/lib/generators/inject-properties.rb

@@ -5,7 +5,7 @@
 module Jekyll
   class InjectProperties < Generator
     safe true
-    priority :low
+    priority :lowest  # Run LAST so all pages from other generators exist before injecting resolved data
 
     def generate(site)
       # Define a global variable accessible in templates

data/lib/generators/limit-collections.rb

@@ -0,0 +1,56 @@
+# Limit Collections Generator
+# Limits the number of documents in collections during development for faster builds
+#
+# Usage in _config.dev.yml:
+#   limit_collections:
+#     recipes: 50
+#     products: 20
+#
+# By default, uses a seeded random sample for diverse selection across categories.
+# To disable randomization and take first N documents:
+#   limit_collections:
+#     recipes: 50
+#     products: 20
+#     randomize: false
+#
+# Run Jekyll with: bundle exec jekyll serve --config _config.yml,_config.dev.yml
+
+module Jekyll
+  class LimitCollectionsGenerator < Generator
+    safe true
+    priority :highest  # Run before other generators
+
+    def generate(site)
+      limits = site.config['limit_collections']
+      return unless limits.is_a?(Hash)
+
+      # Check if randomization is disabled (default: true)
+      randomize = limits.fetch('randomize', true)
+
+      limits.each do |collection_name, limit|
+        # Skip the 'randomize' option itself
+        next if collection_name == 'randomize'
+        next unless limit.is_a?(Integer) && limit > 0
+
+        collection = site.collections[collection_name]
+        next unless collection
+
+        original_count = collection.docs.size
+        next if original_count <= limit
+
+        if randomize
+          # Use a seeded random for repeatable but diverse sampling
+          # Seed based on collection name so it's consistent across rebuilds
+          rng = Random.new(collection_name.hash.abs)
+          sampled_docs = collection.docs.shuffle(random: rng).first(limit)
+          collection.docs.replace(sampled_docs)
+          Jekyll.logger.info "LimitCollections:", "Limited '#{collection_name}' from #{original_count} to #{limit} documents (random sample)"
+        else
+          # Take first N documents in order
+          collection.docs.replace(collection.docs.first(limit))
+          Jekyll.logger.info "LimitCollections:", "Limited '#{collection_name}' from #{original_count} to #{limit} documents"
+        end
+      end
+    end
+  end
+end

data/lib/hooks/parallel-build.rb

@@ -0,0 +1,129 @@
+# Parallel Build Generator
+# Speeds up Jekyll builds by rendering pages and documents in parallel
+#
+# This runs as a Generator with :lowest priority to ensure it processes
+# all pages AFTER other generators (like DynamicPages) have created them.
+#
+# Configuration in _config.yml:
+#
+#   parallel_build:
+#     enabled: true          # Enable/disable parallel builds (default: true)
+#     threads: 8             # Number of threads (default: number of CPU cores)
+#     min_items: 1           # Minimum items before parallelizing (default: 1)
+#
+# Note: Parallel builds work best with CPU-bound rendering.
+# Some Liquid tags may not be thread-safe - if you encounter issues,
+# disable with `parallel_build: false` or `parallel_build.enabled: false`
+
+require 'parallel'
+
+module Jekyll
+  class ParallelBuildGenerator < Generator
+    safe true
+    priority :lowest  # Run AFTER all other generators
+
+    def generate(site)
+      config = site.config['parallel_build']
+
+      # Handle both `parallel_build: false` and `parallel_build.enabled: false`
+      if config == false
+        Jekyll.logger.info "ParallelBuild:", "Disabled via config"
+        return
+      end
+
+      config = {} if config.nil? || config == true
+      return unless config.fetch('enabled', true)
+
+      threads = config.fetch('threads', Parallel.processor_count)
+      min_items = config.fetch('min_items', 1)
+
+      # Render documents in parallel (posts, collections)
+      render_documents_parallel(site, threads, min_items)
+
+      # Render pages in parallel
+      render_pages_parallel(site, threads, min_items)
+    end
+
+    private
+
+    def render_documents_parallel(site, threads, min_items)
+      # Collect all documents that need rendering
+      documents = site.collections.flat_map do |_name, collection|
+        collection.docs.select { |doc| doc.respond_to?(:render) && !doc.data['rendered_parallel'] }
+      end
+
+      return if documents.size < min_items
+
+      Jekyll.logger.info "ParallelBuild:", "Rendering #{documents.size} documents with #{threads} threads..."
+
+      start_time = Time.now
+
+      # Pre-render: prepare payload and info for each document
+      # We need to do the actual Liquid rendering in parallel
+      Parallel.each(documents, in_threads: threads) do |doc|
+        begin
+          # Mark as rendered to avoid double-rendering
+          doc.data['rendered_parallel'] = true
+
+          # Render content through Liquid
+          if doc.content && !doc.content.empty?
+            payload = site.site_payload
+            info = {
+              filters: [Jekyll::Filters],
+              registers: {
+                site: site,
+                page: doc.to_liquid
+              }
+            }
+
+            # Parse and render Liquid template
+            template = site.liquid_renderer.file(doc.path).parse(doc.content)
+            doc.content = template.render!(payload, info)
+          end
+        rescue => e
+          Jekyll.logger.warn "ParallelBuild:", "Error rendering #{doc.relative_path}: #{e.message}"
+        end
+      end
+
+      elapsed = Time.now - start_time
+      Jekyll.logger.info "ParallelBuild:", "Documents rendered in #{elapsed.round(2)}s"
+    end
+
+    def render_pages_parallel(site, threads, min_items)
+      # Get all pages (including dynamically generated ones without content)
+      pages = site.pages.reject { |page| page.data['rendered_parallel'] }
+
+      return if pages.size < min_items
+
+      Jekyll.logger.info "ParallelBuild:", "Rendering #{pages.size} pages with #{threads} threads..."
+
+      start_time = Time.now
+
+      Parallel.each(pages, in_threads: threads) do |page|
+        begin
+          page.data['rendered_parallel'] = true
+
+          # Only render if there's content to process
+          if page.content && !page.content.empty?
+            payload = site.site_payload
+            info = {
+              filters: [Jekyll::Filters],
+              registers: {
+                site: site,
+                page: page.to_liquid
+              }
+            }
+
+            template = site.liquid_renderer.file(page.path).parse(page.content)
+            page.content = template.render!(payload, info)
+          end
+        rescue => e
+          Jekyll.logger.warn "ParallelBuild:", "Error rendering #{page.name}: #{e.message}"
+        end
+      end
+
+      elapsed = Time.now - start_time
+      Jekyll.logger.info "ParallelBuild:", "Pages rendered in #{elapsed.round(2)}s"
+    end
+  end
+end

data/lib/jekyll-uj-powertools.rb

@@ -1,17 +1,21 @@
 # Libraries
 require "jekyll"
+require "parallel"
 
 module Jekyll
   # Load Filters
   require_relative "filters/main"
 
   # Load Generators
+  require_relative "generators/limit-collections"
   require_relative "generators/inject-properties"
   require_relative "generators/blog-taxonomy"
+  require_relative "generators/dynamic-pages"
 
   # Load Hooks
   require_relative "hooks/inject-properties"
   require_relative "hooks/markdown-images"
+  require_relative "hooks/parallel-build"
 
   # Load Tags
   require_relative "tags/external"

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: jekyll-uj-powertools
 version: !ruby/object:Gem::Version
-  version: 1.6.24
+  version: 1.7.1
 platform: ruby
 authors:
 - ITW Creative Works
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-12-17 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jekyll
@@ -86,6 +85,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: nokogiri
   requirement: !ruby/object:Gem::Requirement
@@ -100,6 +113,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.17'
+- !ruby/object:Gem::Dependency
+  name: parallel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.20'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.20'
 description: jekyll-uj-powertools provides a powerful set of utilities for Jekyll,
   including functions to remove ads from strings and escape JSON characters.
 email:
@@ -115,10 +142,13 @@ files:
 - jekyll-uj-powertools.gemspec
 - lib/filters/main.rb
 - lib/generators/blog-taxonomy.rb
+- lib/generators/dynamic-pages.rb
 - lib/generators/inject-properties.rb
+- lib/generators/limit-collections.rb
 - lib/helpers/variable_resolver.rb
 - lib/hooks/inject-properties.rb
 - lib/hooks/markdown-images.rb
+- lib/hooks/parallel-build.rb
 - lib/jekyll-uj-powertools.rb
 - lib/tags/external.rb
 - lib/tags/fake_comments.rb
@@ -140,7 +170,6 @@ homepage: https://github.com/itw-creative-works/jekyll-uj-powertools
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -155,8 +184,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
-signing_key:
+rubygems_version: 4.0.3
 specification_version: 4
 summary: A powerful set of utilities for Jekyll
 test_files: []