jekyll-paginate-v3 0.2.0.alpha → 0.2.1.alpha

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 800113e7a994aa5e6b1a85ec42a7af7a2d14af9c47e8ad9db98de54763b4b6db
-  data.tar.gz: d1e054fdd4621e09fb37f36d98c7009d6d8891e12ce485ef3d6fc0bb3aa7aa99
+  metadata.gz: e41115e64f970d6f2d2daf447c81230cb2550ed6d38ac462e96c11a10681b7d3
+  data.tar.gz: 54778efed89955bd2095392a43f35e19958210ed4cb3d87855487087d3d8d81d
 SHA512:
-  metadata.gz: 9a955153959b071277e958f5b6d24518a49295b401edd2fc15ee74f282e85e4f3ca5af6ae1be61a5b8af0c72b2a9163d49e6ee4214df11886609c56c29363e9b
-  data.tar.gz: 56c0a857ce7e8275c5f4081b427bf6dd6e79ff2ab571cb6446a4d8901c5cc0229c416ed263a9ed497d1737149556dc181b8ef37337209fec743dfa347287f776
+  metadata.gz: cf2d428b82e079b9435959f1d58ba2da88464beb23fe0cc7d3e4c89f539e1abc93e7c4ebab825aace5f41424a37ec15111549fdc0b3f905024e7a853b7cf5939
+  data.tar.gz: ba8014531b022ea9bf76f2b078483f890d7725b3f2a118f1a0d675763b0a12a2a80589888ae4c80ccfe70077b27efeb9ba557f788e1cb8d09ed7aecf3a6a84ec

data/lib/jekyll-paginate-v3/query/filter/evaluation.rb

@@ -150,7 +150,7 @@ class Filter
 
 	# Checks one item value against an optional min/max range.
 	def range_match?(value, min_value, max_value, range_mode)
-		comparable_value = normalise_comparable_scalar(value)
+		comparable_value = normalise_range_candidate(value, min_value, max_value)
 		return false if comparable_value.nil?
 
 		min_inclusive, max_inclusive = parse_range_mode_flags(range_mode)
@@ -178,6 +178,18 @@ class Filter
 		false
 	end
 
+	# Coerces a range candidate according to its already-normalised boundary
+	# type. Date parsing is therefore explicit to range evaluation and never
+	# leaks into ordinary scalar equality.
+	def normalise_range_candidate(value, min_value, max_value)
+		boundary = min_value.nil? ? max_value : min_value
+		if boundary.is_a?(Date) || boundary.is_a?(DateTime) || boundary.is_a?(Time)
+			return Jekyll::Plugins::PaginateV3::Support::LooseScalar.datetime(value)
+		end
+
+		Jekyll::Plugins::PaginateV3::Support::LooseScalar.number(value)
+	end
+
 	# Parses one canonical range mode string into inclusion flags.
 	def parse_range_mode_flags(range_mode)
 		mode_text = range_mode.to_s

data/lib/jekyll-paginate-v3/query/filter/normalisation.rb

@@ -531,7 +531,13 @@ class Filter
 			return today_expression unless today_expression.nil?
 		end
 
-		interpret_numeric(value, must_cast: true)
+		numeric_value = Jekyll::Plugins::PaginateV3::Support::LooseScalar.number(value)
+		return numeric_value unless numeric_value.nil?
+
+		datetime_value = Jekyll::Plugins::PaginateV3::Support::LooseScalar.datetime(value)
+		return datetime_value unless datetime_value.nil?
+
+		false
 	end
 
 	# Parses configured now-keyword expressions into DateTime values.
@@ -572,7 +578,7 @@ class Filter
 		end
 	end
 
-	# Casts string values to Integer, Float, or DateTime when possible.
+	# Casts string values to Integer or Float when possible.
 	# Returns the original string unless strict casting is requested.
 	def interpret_numeric(value, must_cast: false)
 		comparable_value = Jekyll::Plugins::PaginateV3::Support::LooseScalar.comparable(value, must_cast: must_cast)

data/lib/jekyll-paginate-v3/support/loose_scalar.rb

@@ -12,6 +12,42 @@ module Support
 # Structure: callers can ask for one specific scalar family without
 # committing the whole pipeline to one feature's semantics.
 module LooseScalar
+	# Captures the supported ISO-shaped date/time profile without exposing
+	# callers to Ruby's permissive and time-dependent `DateTime.parse` rules.
+	# Date separators repeat independently of the time separator, which also
+	# repeats inside a numeric timezone offset.
+	DATETIME_STRING_PATTERN = %r{
+		\A
+		(?<year>\d{4})
+		(?<date_separator>[:.\/-])
+		(?<month>\d{2})
+		\k<date_separator>
+		(?<day>\d{2})
+		(?:
+			(?:T|[ \t]+)
+			(?<hour>\d{2})
+			(?<time_separator>[:.-])
+			(?<minute>\d{2})
+			(?:
+				\k<time_separator>
+				(?<second>\d{2})
+				(?<fraction>\.\d+)?
+			)?
+			(?:
+				[ \t]*
+				(?:
+					(?<utc_timezone>Z)
+					|
+					(?<timezone_sign>[+-])
+					(?<timezone_hour>\d{2})
+					\k<time_separator>
+					(?<timezone_minute>\d{2})
+				)
+			)?
+		)?
+		\z
+	}x.freeze
+
 	# Interprets one value as a strict boolean or a loose `true`/`false`
 	# string. Returns `nil` when no boolean meaning can be inferred.
 	def self.boolean(value)
@@ -50,8 +86,9 @@ module LooseScalar
 		(numeric_value % 1).zero?
 	end
 
-	# Interprets one value as a datetime in the same loose way used by
-	# filter range comparisons.
+	# Interprets one value as a datetime for explicitly date-aware operations.
+	# Strings must satisfy `DATETIME_STRING_PATTERN`; captured components are
+	# rebuilt as canonical ISO before the standard parser validates them.
 	def self.datetime(value)
 		return value if value.is_a?(DateTime)
 		return value.to_datetime if value.is_a?(Time)
@@ -61,7 +98,11 @@ module LooseScalar
 		stripped = value.strip
 		return nil if stripped.empty?
 
-		DateTime.parse(stripped)
+		match = DATETIME_STRING_PATTERN.match(stripped)
+		return nil if match.nil?
+		return nil unless valid_datetime_components?(match)
+
+		DateTime.iso8601(canonical_datetime(match))
 	rescue ArgumentError
 		nil
 	end
@@ -71,9 +112,9 @@ module LooseScalar
 		datetime(value)
 	end
 
-	# Converts one value into the loose comparable scalar form used by
-	# filtering. Strings become numbers or datetimes when possible, or a
-	# stripped string otherwise.
+	# Converts one value into the generic comparable scalar form used by
+	# exact filtering. Strings become numbers when possible, but date-shaped
+	# strings remain strings unless a date-aware caller invokes `datetime`.
 	def self.comparable(value, must_cast: false)
 		return value if value.is_a?(Integer) || value.is_a?(Float) || value.is_a?(DateTime)
 		return value.to_datetime if value.is_a?(Time)
@@ -90,14 +131,48 @@ module LooseScalar
 		numeric_value = number(stripped)
 		return numeric_value unless numeric_value.nil?
 
-		datetime_value = datetime(stripped)
-		return datetime_value unless datetime_value.nil?
-
 		return nil if must_cast
 
 		stripped
 	end
 
+	# Rebuilds one lexical match as strict ISO text for calendar validation.
+	def self.canonical_datetime(match)
+		date = "#{match[:year]}-#{match[:month]}-#{match[:day]}"
+		return date if match[:hour].nil?
+
+		second = match[:second] || '00'
+		fraction = match[:fraction].to_s
+		timezone = canonical_timezone(match)
+
+		"#{date}T#{match[:hour]}:#{match[:minute]}:#{second}#{fraction}#{timezone}"
+	end
+	private_class_method :canonical_datetime
+
+	# Converts an optional loose timezone into canonical ISO syntax. Missing
+	# timezone information deliberately means offset zero rather than local time.
+	def self.canonical_timezone(match)
+		return 'Z' unless match[:utc_timezone].nil?
+		return 'Z' if match[:timezone_sign].nil?
+
+		"#{match[:timezone_sign]}#{match[:timezone_hour]}:#{match[:timezone_minute]}"
+	end
+	private_class_method :canonical_timezone
+
+	# Validates component ranges explicitly because `DateTime.iso8601` accepts
+	# and normalises some out-of-range timezone offsets on older Ruby versions.
+	def self.valid_datetime_components?(match)
+		return false unless Date.valid_date?(match[:year].to_i, match[:month].to_i, match[:day].to_i)
+		return true if match[:hour].nil?
+		return false unless (0..23).cover?(match[:hour].to_i)
+		return false unless (0..59).cover?(match[:minute].to_i)
+		return false unless match[:second].nil? || (0..59).cover?(match[:second].to_i)
+		return true if match[:timezone_sign].nil?
+
+		(0..23).cover?(match[:timezone_hour].to_i) && (0..59).cover?(match[:timezone_minute].to_i)
+	end
+	private_class_method :valid_datetime_components?
+
 	# Safe comparability check for mixed scalar types.
 	def self.comparable_values?(left, right)
 		return true if left.class == right.class

data/lib/jekyll-paginate-v3/templates/grouped_index/config_normalisation.rb

@@ -252,7 +252,10 @@ class GroupedIndex
 		keyword_value = interpret_datetime_keyword_expression(stripped, range_key: 'min')
 		return keyword_value unless keyword_value.nil?
 
-		DateTime.parse(stripped)
+		datetime_value = Jekyll::Plugins::PaginateV3::Support::LooseScalar.datetime(stripped)
+		return datetime_value unless datetime_value.nil?
+
+		raise ArgumentError
 	rescue ArgumentError
 		raise ArgumentError, "`group.start` could not be parsed as datetime: #{raw_value.inspect}."
 	end
@@ -355,10 +358,10 @@ class GroupedIndex
 		return true if stripped.match?(/\A(?:#{precise_units})(?:\s*\(|\z)/i)
 		return true if stripped.match?(/\A#{Regexp.escape(@now_keyword)}(?:\s*[+-]\s*\d+)?\z/i)
 
-		parsed = DateTime.parse(stripped)
+		parsed = Jekyll::Plugins::PaginateV3::Support::LooseScalar.datetime(stripped)
+		return false if parsed.nil?
+
 		parsed.hour.positive? || parsed.min.positive? || parsed.sec.positive?
-	rescue ArgumentError
-		false
 	end
 end
 

data/lib/jekyll-paginate-v3/version.rb

@@ -4,7 +4,7 @@ module Jekyll
 module Plugins
 
 module PaginateV3
-	VERSION = '0.2.0.alpha'
+	VERSION = '0.2.1.alpha'
 end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jekyll-paginate-v3
 version: !ruby/object:Gem::Version
-  version: 0.2.0.alpha
+  version: 0.2.1.alpha
 platform: ruby
 authors:
 - Convincible
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-08 00:00:00.000000000 Z
+date: 2026-09-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jekyll