jekyll-paginate-v3 0.1.0.alpha

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cfe3b140435a9e8b5011cc8ff234547046323329bf1fba18dc0cdbc649fb1266
+  data.tar.gz: '039c94ad587c94ce7ebf66a828aa856b0092cf9f28a489da2aedc0e7102c2ed7'
+SHA512:
+  metadata.gz: cf32cbe5e10d028b59b8f9807ae3d52bb63421eb0ffa57d3f104b7bdc953f483da24d1453d5974bfcba186e969674ebf1ee1ae39a8e8993456f1033661a873da
+  data.tar.gz: 2278e72f4b899f3cfaf21e62eb55c776fff719bd1e88c2374206f627a070e4dc35cf6bca7613c189590e8be3c5657c40f0e2ad2fd21b4776f48deb7c6b90aa92

data/lib/jekyll-paginate-v3/config/defaults.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Jekyll
+module Plugins
+module PaginateV3
+
+# Default configuration for jekyll-paginate-v3.
+#
+# These defaults intentionally describe the new v3 behaviour. Legacy
+# v1/v2 behaviour is layered on top through compatibility profiles.
+module Config
+	KEYWORD_DEFAULTS = {
+		'pages' => 'pages',
+		'all' => 'all',
+		'everything' => 'everything',
+		'self' => 'self',
+		'shadow' => 'shadow',
+		'clone' => 'clone',
+		'now' => 'now',
+		'today' => 'today',
+		'day' => 'day',
+		'month' => 'month',
+		'year' => 'year',
+		'hour' => 'hour',
+		'minute' => 'minute',
+		'second' => 'second',
+		'items' => 'items'
+	}.freeze
+
+	DEFAULTS = {
+		'enabled' => true,
+		'compatibility' => nil,
+		'debug' => false,
+		'syntax' => {
+			'separator' => '.',
+			'split' => ','
+		},
+		'keywords' => {},
+		'equivalents' => [
+			['tag', 'tags'],
+			['category', 'categories']
+		],
+		'items' => nil,
+		'collection' => ['self', 'shadow'],
+		'filters' => nil,
+		'sort' => 'date desc',
+		'per_page' => 10,
+		'limit' => 0,
+		'offset' => 0,
+		'trail' => 5,
+		'title' => ':title - :num',
+		'permalink' => ':num',
+		'layout' => nil,
+		'layouts' => [],
+		'group' => nil,
+		'slugify' => {
+			'mode' => 'default',
+			'lowercase' => true
+		},
+		'templates' => {
+			'location' => 'pages',
+			'generate' => []
+		}
+	}.freeze
+
+	# Compatibility overlays merged after DEFAULTS but before user config.
+	#
+	# v2 keeps historical public contract where the paginator payload key is
+	# `posts` and where legacy shorthand keys are accepted and up-migrated.
+	#
+	# v1 keeps legacy config keys working while staying on the shared v3
+	# pagination pipeline.
+	COMPATIBILITY_PROFILES = {
+		'v2' => {
+			'enabled' => true,
+			'syntax' => {
+				'separator' => ':'
+			},
+			'keywords' => {
+				'all' => 'collections',
+				'items' => 'posts'
+			},
+			'items' => 'posts',
+			'title' => ':title - page :num',
+			'permalink' => '/page/:num/',
+			'trail' => {
+				'before' => 2,
+				'after' => 2
+			}
+		},
+		'v1' => {
+			'enabled' => true,
+			'keywords' => {
+				'items' => 'posts'
+			},
+			'items' => 'posts',
+			'templates' => {
+				'location' => 'pages',
+				'generate' => []
+			}
+		}
+	}.freeze
+end
+
+end
+end
+end

data/lib/jekyll-paginate-v3/config/normaliser/core.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Jekyll
+module Plugins
+module PaginateV3
+module Config
+
+# Normalises site and template pagination config into predictable internal structures consumed by pagination runtime classes.
+#
+# Site-level config is normalised to the nested public v3 structure:
+# - pagination.syntax.*
+# - pagination.templates.location
+# - pagination.templates.generate
+# - pagination.*
+#
+# Template-level config is normalised to a flat hash used during
+# pagination emission for one concrete template page/document.
+class Normaliser
+	
+	LEGACY_FILTER_KEYS = %w[category tag locale].freeze
+	LEGACY_TEMPLATE_DEFAULT_KEYS = %w[items collection filters sort per_page limit offset trail title permalink layout layouts group slugify sort_field sort_reverse indexpage extension].freeze
+	LEGACY_SITE_KEY_ALIASES = %w[split separator nested_key_separator].freeze
+	SITE_RESERVED_KEYS = %w[enabled templates compatibility keywords equivalents syntax debug].freeze
+	V2_AUTOPAGE_DEFAULTS = {
+		'tags' => {
+			'layout' => 'autopage_tags.html',
+			'title' => 'Posts tagged with :tag',
+			'permalink' => '/tag/:tag',
+			'slugify' => {
+				'mode' => 'default',
+				'lowercase' => true
+			}
+		},
+		'categories' => {
+			'layout' => 'autopage_category.html',
+			'title' => 'Posts in category :cat',
+			'permalink' => '/category/:cat',
+			'slugify' => {
+				'mode' => 'default',
+				'lowercase' => true
+			}
+		},
+		'collections' => {
+			'layout' => 'autopage_collection.html',
+			'title' => 'Posts in collection :coll',
+			'permalink' => '/collection/:coll/',
+			'slugify' => {
+				'mode' => 'default',
+				'lowercase' => true
+			}
+		}
+	}.freeze
+
+	# Produces canonical site-level pagination config.
+	#
+	# Merge order:
+	# defaults -> compatibility profile -> legacy overlays -> user config.
+	def self.normalise_site_config(site_config)
+		site_hash = Utils.safe_hash(site_config)
+		raw_pagination = normalise_site_pagination_source(site_hash['pagination'])
+
+		compatibility_mode = normalise_compatibility(raw_pagination['compatibility'])
+
+		config = Utils.deep_copy(DEFAULTS)
+		if compatibility_mode && COMPATIBILITY_PROFILES.key?(compatibility_mode)
+			config = Jekyll::Utils.deep_merge_hashes(config, Utils.deep_copy(COMPATIBILITY_PROFILES[compatibility_mode]))
+		end
+
+		if compatibility_mode == 'v1'
+			config = Jekyll::Utils.deep_merge_hashes(config, legacy_v1_overlay(site_hash))
+		end
+
+		config = Jekyll::Utils.deep_merge_hashes(config, raw_pagination)
+		config['compatibility'] = compatibility_mode unless compatibility_mode.nil?
+
+		normalise_site_common!(config, compatibility_mode, raw_pagination)
+		migrate_legacy_shortcuts!(config, compatibility_mode, raw_pagination)
+		apply_v2_legacy_page_templates!(config, raw_pagination, compatibility_mode)
+		migrate_v2_autopages!(config, site_hash['autopages'], compatibility_mode)
+
+		config
+	end
+
+	# Produces template-level pagination config used while paginating one
+	# template page/document.
+	#
+	# The output is intentionally flat so downstream pipeline code can read
+	# values directly without re-resolving site defaults.
+	def self.normalise_template_config(site_config, template_pagination_config)
+		raw_template_pagination = Utils.safe_hash(template_pagination_config)
+		compatibility_mode = normalise_compatibility(raw_template_pagination['compatibility']) || normalise_compatibility(site_config['compatibility'])
+		site_template_defaults = extract_site_template_defaults(site_config)
+
+		page_config = Jekyll::Utils.deep_merge_hashes(
+			Utils.deep_copy(site_template_defaults),
+			raw_template_pagination
+		)
+
+		page_config['enabled'] = if raw_template_pagination.key?('enabled')
+																!!raw_template_pagination['enabled']
+															else
+																!!site_config['enabled']
+															end
+		page_config['compatibility'] = compatibility_mode unless compatibility_mode.nil?
+
+		syntax = resolve_template_syntax(raw_template_pagination, site_config['syntax'])
+		page_config['split'] = syntax['split']
+		page_config['separator'] = syntax['separator']
+
+		page_config = normalise_template_defaults(
+			page_config,
+			raw_overrides: raw_template_pagination,
+			split_delimiter: syntax['split'],
+			keywords: site_config['keywords']
+		)
+
+		migrate_legacy_shortcuts!(page_config, compatibility_mode, raw_template_pagination)
+		apply_v2_legacy_page_templates!(page_config, raw_template_pagination, compatibility_mode)
+
+		page_config
+	end
+end
+
+end
+end
+end
+end

data/lib/jekyll-paginate-v3/config/normaliser/legacy_compatibility.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module Jekyll
+module Plugins
+module PaginateV3
+module Config
+
+# Legacy compatibility migration helpers for v1/v2 style configuration.
+# Structure: each helper converts a specific legacy shape into the shared
+# v3 config model consumed by the runtime pipeline.
+class Normaliser
+	class << self
+
+		private
+		def migrate_legacy_shortcuts!(template_config, compatibility_mode, raw_overrides = nil)
+			return unless compatibility_mode == 'v2'
+
+			override_hash = Utils.safe_hash(raw_overrides)
+			template_overrides = extract_template_defaults_overrides(override_hash)
+			explicit_filters = Utils.safe_hash(template_overrides['filters'])
+
+			LEGACY_FILTER_KEYS.each do |legacy_key|
+				next unless override_hash.key?(legacy_key)
+				next unless present_config_value?(override_hash[legacy_key])
+				next if explicit_filters.key?(legacy_key)
+				next if legacy_key == 'category' && override_hash[legacy_key].to_s.strip == 'posts'
+
+				template_config['filters'][legacy_key] = override_hash[legacy_key]
+			end
+
+			LEGACY_FILTER_KEYS.each { |legacy_key| template_config.delete(legacy_key) }
+		end
+
+		# Applies v2 `indexpage`/`extension` legacy behaviour by translating
+		# those keys into internal page1/page2 permalink templates.
+		def apply_v2_legacy_page_templates!(template_config, raw_overrides, compatibility_mode)
+			return unless compatibility_mode == 'v2'
+
+			override_hash = extract_template_defaults_overrides(raw_overrides)
+			return unless override_hash.key?('indexpage') || override_hash.key?('extension')
+
+			index_name = override_hash.key?('indexpage') ? override_hash['indexpage'].to_s : 'index'
+			extension = override_hash.key?('extension') ? override_hash['extension'].to_s : 'html'
+
+			template_config['page_templates'] ||= build_page_templates(template_config['title'], template_config['permalink'])
+			template_config['page_templates']['page1']['permalink'] = Utils.ensure_full_path('/', index_name, extension)
+			template_config['page_templates']['page2']['permalink'] = Utils.ensure_full_path(template_config['permalink'], index_name, extension)
+		end
+
+		# Imports legacy top-level `paginate` settings used by
+		# jekyll-paginate v1.
+		def legacy_v1_overlay(site_hash)
+			overlay = {}
+			return overlay if site_hash['paginate'].nil?
+
+			overlay['enabled'] = true
+			overlay['keywords'] = { 'items' => 'posts' }
+			overlay['per_page'] = site_hash['paginate'].to_i
+			overlay['items'] = 'posts'
+			unless site_hash['paginate_path'].nil?
+				overlay['permalink'] = site_hash['paginate_path'].to_s
+			end
+
+			overlay
+		end
+
+		# Legacy migration path for v2 `autopages` into
+		# `pagination.templates.generate`.
+		def migrate_v2_autopages!(config, raw_autopages, compatibility_mode)
+			return unless compatibility_mode == 'v2'
+
+			autopages = Utils.safe_hash(raw_autopages)
+			return if autopages.empty? || autopages['enabled'] == false
+
+			migrated = []
+
+			migrated.concat(migrate_v2_autopage_group(
+												raw_group: autopages['tags'],
+												index_key: 'tag',
+												items: 'all',
+												defaults: V2_AUTOPAGE_DEFAULTS['tags'],
+												split_delimiter: config.dig('syntax', 'split')
+											))
+			migrated.concat(migrate_v2_autopage_group(
+												raw_group: autopages['categories'],
+												index_key: 'category',
+												items: 'all',
+												defaults: V2_AUTOPAGE_DEFAULTS['categories'],
+												split_delimiter: config.dig('syntax', 'split')
+											))
+			migrated.concat(migrate_v2_autopage_group(
+												raw_group: autopages['collections'],
+												index_key: 'collection',
+												items: 'all',
+												defaults: V2_AUTOPAGE_DEFAULTS['collections'],
+												split_delimiter: config.dig('syntax', 'split')
+											))
+
+			return if migrated.empty?
+
+			config['templates']['generate'].concat(migrated)
+		end
+
+		# Maps one v2 autopages group (tags/categories/collections) to one
+		# generate definition.
+		def migrate_v2_autopage_group(raw_group:, index_key:, items:, defaults:, split_delimiter:)
+			group = Utils.safe_hash(raw_group)
+			return [] if group.empty? || group['enabled'] == false
+
+			layouts = Utils.normalise_layouts(group, split_delimiter: split_delimiter)
+			layouts = [defaults['layout']] if layouts.empty?
+
+			title = group['title']
+			title = defaults['title'] unless present_config_value?(title)
+
+			permalink = group['permalink']
+			permalink = defaults['permalink'] unless present_config_value?(permalink)
+
+			slugify = if group.key?('slugify')
+									Utils.safe_hash(group['slugify'])
+								else
+									Utils.deep_copy(defaults['slugify'])
+								end
+
+			[
+				{
+					'items' => items,
+					'group' => index_key,
+					'layouts' => layouts,
+					'frontmatter' => {
+						'title' => title,
+						'permalink' => permalink
+					},
+					'slugify' => slugify
+				}
+			]
+		end
+
+		# Indicates whether a config value should be treated as explicitly set.
+		def present_config_value?(value)
+			return false if value.nil?
+			return false if value.is_a?(String) && value.strip.empty?
+			return false if value.is_a?(Array) && value.empty?
+			return false if value.is_a?(Hash) && value.empty?
+
+			true
+		end
+
+	end
+end
+
+end
+end
+end
+end