jekyll 4.2.1 → 4.2.2

data/lib/jekyll/filters/date_filters.rb

@@ -1,110 +1,110 @@
-# frozen_string_literal: true
-
-module Jekyll
-  module Filters
-    module DateFilters
-      # Format a date in short format e.g. "27 Jan 2011".
-      # Ordinal format is also supported, in both the UK
-      # (e.g. "27th Jan 2011") and US ("e.g. Jan 27th, 2011") formats.
-      # UK format is the default.
-      #
-      # date - the Time to format.
-      # type - if "ordinal" the returned String will be in ordinal format
-      # style - if "US" the returned String will be in US format.
-      #         Otherwise it will be in UK format.
-      #
-      # Returns the formatting String.
-      def date_to_string(date, type = nil, style = nil)
-        stringify_date(date, "%b", type, style)
-      end
-
-      # Format a date in long format e.g. "27 January 2011".
-      # Ordinal format is also supported, in both the UK
-      # (e.g. "27th January 2011") and US ("e.g. January 27th, 2011") formats.
-      # UK format is the default.
-      #
-      # date - the Time to format.
-      # type - if "ordinal" the returned String will be in ordinal format
-      # style - if "US" the returned String will be in US format.
-      #         Otherwise it will be in UK format.
-      #
-      # Returns the formatted String.
-      def date_to_long_string(date, type = nil, style = nil)
-        stringify_date(date, "%B", type, style)
-      end
-
-      # Format a date for use in XML.
-      #
-      # date - The Time to format.
-      #
-      # Examples
-      #
-      #   date_to_xmlschema(Time.now)
-      #   # => "2011-04-24T20:34:46+08:00"
-      #
-      # Returns the formatted String.
-      def date_to_xmlschema(date)
-        return date if date.to_s.empty?
-
-        time(date).xmlschema
-      end
-
-      # Format a date according to RFC-822
-      #
-      # date - The Time to format.
-      #
-      # Examples
-      #
-      #   date_to_rfc822(Time.now)
-      #   # => "Sun, 24 Apr 2011 12:34:46 +0000"
-      #
-      # Returns the formatted String.
-      def date_to_rfc822(date)
-        return date if date.to_s.empty?
-
-        time(date).rfc822
-      end
-
-      private
-
-      # month_type: Notations that evaluate to 'Month' via `Time#strftime` ("%b", "%B")
-      # type: nil (default) or "ordinal"
-      # style: nil (default) or "US"
-      #
-      # Returns a stringified date or the empty input.
-      def stringify_date(date, month_type, type = nil, style = nil)
-        return date if date.to_s.empty?
-
-        time = time(date)
-        if type == "ordinal"
-          day = time.day
-          ordinal_day = "#{day}#{ordinal(day)}"
-          return time.strftime("#{month_type} #{ordinal_day}, %Y") if style == "US"
-
-          return time.strftime("#{ordinal_day} #{month_type} %Y")
-        end
-        time.strftime("%d #{month_type} %Y")
-      end
-
-      def ordinal(number)
-        return "th" if (11..13).cover?(number)
-
-        case number % 10
-        when 1 then "st"
-        when 2 then "nd"
-        when 3 then "rd"
-        else "th"
-        end
-      end
-
-      def time(input)
-        date = Liquid::Utils.to_date(input)
-        unless date.respond_to?(:to_time)
-          raise Errors::InvalidDateError,
-                "Invalid Date: '#{input.inspect}' is not a valid datetime."
-        end
-        date.to_time.dup.localtime
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Jekyll
+  module Filters
+    module DateFilters
+      # Format a date in short format e.g. "27 Jan 2011".
+      # Ordinal format is also supported, in both the UK
+      # (e.g. "27th Jan 2011") and US ("e.g. Jan 27th, 2011") formats.
+      # UK format is the default.
+      #
+      # date - the Time to format.
+      # type - if "ordinal" the returned String will be in ordinal format
+      # style - if "US" the returned String will be in US format.
+      #         Otherwise it will be in UK format.
+      #
+      # Returns the formatting String.
+      def date_to_string(date, type = nil, style = nil)
+        stringify_date(date, "%b", type, style)
+      end
+
+      # Format a date in long format e.g. "27 January 2011".
+      # Ordinal format is also supported, in both the UK
+      # (e.g. "27th January 2011") and US ("e.g. January 27th, 2011") formats.
+      # UK format is the default.
+      #
+      # date - the Time to format.
+      # type - if "ordinal" the returned String will be in ordinal format
+      # style - if "US" the returned String will be in US format.
+      #         Otherwise it will be in UK format.
+      #
+      # Returns the formatted String.
+      def date_to_long_string(date, type = nil, style = nil)
+        stringify_date(date, "%B", type, style)
+      end
+
+      # Format a date for use in XML.
+      #
+      # date - The Time to format.
+      #
+      # Examples
+      #
+      #   date_to_xmlschema(Time.now)
+      #   # => "2011-04-24T20:34:46+08:00"
+      #
+      # Returns the formatted String.
+      def date_to_xmlschema(date)
+        return date if date.to_s.empty?
+
+        time(date).xmlschema
+      end
+
+      # Format a date according to RFC-822
+      #
+      # date - The Time to format.
+      #
+      # Examples
+      #
+      #   date_to_rfc822(Time.now)
+      #   # => "Sun, 24 Apr 2011 12:34:46 +0000"
+      #
+      # Returns the formatted String.
+      def date_to_rfc822(date)
+        return date if date.to_s.empty?
+
+        time(date).rfc822
+      end
+
+      private
+
+      # month_type: Notations that evaluate to 'Month' via `Time#strftime` ("%b", "%B")
+      # type: nil (default) or "ordinal"
+      # style: nil (default) or "US"
+      #
+      # Returns a stringified date or the empty input.
+      def stringify_date(date, month_type, type = nil, style = nil)
+        return date if date.to_s.empty?
+
+        time = time(date)
+        if type == "ordinal"
+          day = time.day
+          ordinal_day = "#{day}#{ordinal(day)}"
+          return time.strftime("#{month_type} #{ordinal_day}, %Y") if style == "US"
+
+          return time.strftime("#{ordinal_day} #{month_type} %Y")
+        end
+        time.strftime("%d #{month_type} %Y")
+      end
+
+      def ordinal(number)
+        return "th" if (11..13).cover?(number)
+
+        case number % 10
+        when 1 then "st"
+        when 2 then "nd"
+        when 3 then "rd"
+        else "th"
+        end
+      end
+
+      def time(input)
+        date = Liquid::Utils.to_date(input)
+        unless date.respond_to?(:to_time)
+          raise Errors::InvalidDateError,
+                "Invalid Date: '#{input.inspect}' is not a valid datetime."
+        end
+        date.to_time.dup.localtime
+      end
+    end
+  end
+end

data/lib/jekyll/filters/grouping_filters.rb

@@ -1,64 +1,64 @@
-# frozen_string_literal: true
-
-module Jekyll
-  module Filters
-    module GroupingFilters
-      # Group an array of items by a property
-      #
-      # input - the inputted Enumerable
-      # property - the property
-      #
-      # Returns an array of Hashes, each looking something like this:
-      #  {"name"  => "larry"
-      #   "items" => [...] } # all the items where `property` == "larry"
-      def group_by(input, property)
-        if groupable?(input)
-          groups = input.group_by { |item| item_property(item, property).to_s }
-          grouped_array(groups)
-        else
-          input
-        end
-      end
-
-      # Group an array of items by an expression
-      #
-      # input - the object array
-      # variable - the variable to assign each item to in the expression
-      # expression -a Liquid comparison expression passed in as a string
-      #
-      # Returns the filtered array of objects
-      def group_by_exp(input, variable, expression)
-        return input unless groupable?(input)
-
-        parsed_expr = parse_expression(expression)
-        @context.stack do
-          groups = input.group_by do |item|
-            @context[variable] = item
-            parsed_expr.render(@context)
-          end
-          grouped_array(groups)
-        end
-      end
-
-      private
-
-      def parse_expression(str)
-        Liquid::Variable.new(str, Liquid::ParseContext.new)
-      end
-
-      def groupable?(element)
-        element.respond_to?(:group_by)
-      end
-
-      def grouped_array(groups)
-        groups.each_with_object([]) do |item, array|
-          array << {
-            "name"  => item.first,
-            "items" => item.last,
-            "size"  => item.last.size,
-          }
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Jekyll
+  module Filters
+    module GroupingFilters
+      # Group an array of items by a property
+      #
+      # input - the inputted Enumerable
+      # property - the property
+      #
+      # Returns an array of Hashes, each looking something like this:
+      #  {"name"  => "larry"
+      #   "items" => [...] } # all the items where `property` == "larry"
+      def group_by(input, property)
+        if groupable?(input)
+          groups = input.group_by { |item| item_property(item, property).to_s }
+          grouped_array(groups)
+        else
+          input
+        end
+      end
+
+      # Group an array of items by an expression
+      #
+      # input - the object array
+      # variable - the variable to assign each item to in the expression
+      # expression -a Liquid comparison expression passed in as a string
+      #
+      # Returns the filtered array of objects
+      def group_by_exp(input, variable, expression)
+        return input unless groupable?(input)
+
+        parsed_expr = parse_expression(expression)
+        @context.stack do
+          groups = input.group_by do |item|
+            @context[variable] = item
+            parsed_expr.render(@context)
+          end
+          grouped_array(groups)
+        end
+      end
+
+      private
+
+      def parse_expression(str)
+        Liquid::Variable.new(str, Liquid::ParseContext.new)
+      end
+
+      def groupable?(element)
+        element.respond_to?(:group_by)
+      end
+
+      def grouped_array(groups)
+        groups.each_with_object([]) do |item, array|
+          array << {
+            "name"  => item.first,
+            "items" => item.last,
+            "size"  => item.last.size,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/jekyll/filters/url_filters.rb

@@ -1,98 +1,98 @@
-# frozen_string_literal: true
-
-module Jekyll
-  module Filters
-    module URLFilters
-      # Produces an absolute URL based on site.url and site.baseurl.
-      #
-      # input - the URL to make absolute.
-      #
-      # Returns the absolute URL as a String.
-      def absolute_url(input)
-        return if input.nil?
-
-        cache = if input.is_a?(String)
-                  (@context.registers[:site].filter_cache[:absolute_url] ||= {})
-                else
-                  (@context.registers[:cached_absolute_url] ||= {})
-                end
-        cache[input] ||= compute_absolute_url(input)
-
-        # Duplicate cached string so that the cached value is never mutated by
-        # a subsequent filter.
-        cache[input].dup
-      end
-
-      # Produces a URL relative to the domain root based on site.baseurl
-      # unless it is already an absolute url with an authority (host).
-      #
-      # input - the URL to make relative to the domain root
-      #
-      # Returns a URL relative to the domain root as a String.
-      def relative_url(input)
-        return if input.nil?
-
-        cache = if input.is_a?(String)
-                  (@context.registers[:site].filter_cache[:relative_url] ||= {})
-                else
-                  (@context.registers[:cached_relative_url] ||= {})
-                end
-        cache[input] ||= compute_relative_url(input)
-
-        # Duplicate cached string so that the cached value is never mutated by
-        # a subsequent filter.
-        cache[input].dup
-      end
-
-      # Strips trailing `/index.html` from URLs to create pretty permalinks
-      #
-      # input - the URL with a possible `/index.html`
-      #
-      # Returns a URL with the trailing `/index.html` removed
-      def strip_index(input)
-        return if input.nil? || input.to_s.empty?
-
-        input.sub(%r!/index\.html?$!, "/")
-      end
-
-      private
-
-      def compute_absolute_url(input)
-        input = input.url if input.respond_to?(:url)
-        return input if Addressable::URI.parse(input.to_s).absolute?
-
-        site = @context.registers[:site]
-        site_url = site.config["url"]
-        return relative_url(input) if site_url.nil? || site_url == ""
-
-        Addressable::URI.parse(
-          site_url.to_s + relative_url(input)
-        ).normalize.to_s
-      end
-
-      def compute_relative_url(input)
-        input = input.url if input.respond_to?(:url)
-        return input if Addressable::URI.parse(input.to_s).absolute?
-
-        parts = [sanitized_baseurl, input]
-        Addressable::URI.parse(
-          parts.map! { |part| ensure_leading_slash(part.to_s) }.join
-        ).normalize.to_s
-      end
-
-      def sanitized_baseurl
-        site = @context.registers[:site]
-        baseurl = site.config["baseurl"]
-        return "" if baseurl.nil?
-
-        baseurl.to_s.chomp("/")
-      end
-
-      def ensure_leading_slash(input)
-        return input if input.nil? || input.empty? || input.start_with?("/")
-
-        "/#{input}"
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Jekyll
+  module Filters
+    module URLFilters
+      # Produces an absolute URL based on site.url and site.baseurl.
+      #
+      # input - the URL to make absolute.
+      #
+      # Returns the absolute URL as a String.
+      def absolute_url(input)
+        return if input.nil?
+
+        cache = if input.is_a?(String)
+                  (@context.registers[:site].filter_cache[:absolute_url] ||= {})
+                else
+                  (@context.registers[:cached_absolute_url] ||= {})
+                end
+        cache[input] ||= compute_absolute_url(input)
+
+        # Duplicate cached string so that the cached value is never mutated by
+        # a subsequent filter.
+        cache[input].dup
+      end
+
+      # Produces a URL relative to the domain root based on site.baseurl
+      # unless it is already an absolute url with an authority (host).
+      #
+      # input - the URL to make relative to the domain root
+      #
+      # Returns a URL relative to the domain root as a String.
+      def relative_url(input)
+        return if input.nil?
+
+        cache = if input.is_a?(String)
+                  (@context.registers[:site].filter_cache[:relative_url] ||= {})
+                else
+                  (@context.registers[:cached_relative_url] ||= {})
+                end
+        cache[input] ||= compute_relative_url(input)
+
+        # Duplicate cached string so that the cached value is never mutated by
+        # a subsequent filter.
+        cache[input].dup
+      end
+
+      # Strips trailing `/index.html` from URLs to create pretty permalinks
+      #
+      # input - the URL with a possible `/index.html`
+      #
+      # Returns a URL with the trailing `/index.html` removed
+      def strip_index(input)
+        return if input.nil? || input.to_s.empty?
+
+        input.sub(%r!/index\.html?$!, "/")
+      end
+
+      private
+
+      def compute_absolute_url(input)
+        input = input.url if input.respond_to?(:url)
+        return input if Addressable::URI.parse(input.to_s).absolute?
+
+        site = @context.registers[:site]
+        site_url = site.config["url"]
+        return relative_url(input) if site_url.nil? || site_url == ""
+
+        Addressable::URI.parse(
+          site_url.to_s + relative_url(input)
+        ).normalize.to_s
+      end
+
+      def compute_relative_url(input)
+        input = input.url if input.respond_to?(:url)
+        return input if Addressable::URI.parse(input.to_s).absolute?
+
+        parts = [sanitized_baseurl, input]
+        Addressable::URI.parse(
+          parts.map! { |part| ensure_leading_slash(part.to_s) }.join
+        ).normalize.to_s
+      end
+
+      def sanitized_baseurl
+        site = @context.registers[:site]
+        baseurl = site.config["baseurl"]
+        return "" if baseurl.nil?
+
+        baseurl.to_s.chomp("/")
+      end
+
+      def ensure_leading_slash(input)
+        return input if input.nil? || input.empty? || input.start_with?("/")
+
+        "/#{input}"
+      end
+    end
+  end
+end