jekyll-docs 3.6.0 → 3.6.1

data/lib/jekyll/filters/grouping_filters.rb

@@ -0,0 +1,65 @@
+# 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
+
+      private
+      def groupable?(element)
+        element.respond_to?(:group_by)
+      end
+
+      private
+      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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "addressable/uri"
+
+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?
+        return input if Addressable::URI.parse(input.to_s).absolute?
+        site = @context.registers[:site]
+        return relative_url(input) if site.config["url"].nil?
+        Addressable::URI.parse(
+          site.config["url"].to_s + relative_url(input)
+        ).normalize.to_s
+      end
+
+      # Produces a URL relative to the domain root based on site.baseurl.
+      #
+      # 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?
+        parts = [sanitized_baseurl, input]
+        Addressable::URI.parse(
+          parts.compact.map { |part| ensure_leading_slash(part.to_s) }.join
+        ).normalize.to_s
+      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 sanitized_baseurl
+        site = @context.registers[:site]
+        site.config["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

data/lib/jekyll/frontmatter_defaults.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module Jekyll
+  # This class handles custom defaults for YAML frontmatter settings.
+  # These are set in _config.yml and apply both to internal use (e.g. layout)
+  # and the data available to liquid.
+  #
+  # It is exposed via the frontmatter_defaults method on the site class.
+  class FrontmatterDefaults
+    # Initializes a new instance.
+    def initialize(site)
+      @site = site
+    end
+
+    def update_deprecated_types(set)
+      return set unless set.key?("scope") && set["scope"].key?("type")
+
+      set["scope"]["type"] =
+        case set["scope"]["type"]
+        when "page"
+          Deprecator.defaults_deprecate_type("page", "pages")
+          "pages"
+        when "post"
+          Deprecator.defaults_deprecate_type("post", "posts")
+          "posts"
+        when "draft"
+          Deprecator.defaults_deprecate_type("draft", "drafts")
+          "drafts"
+        else
+          set["scope"]["type"]
+        end
+
+      set
+    end
+
+    def ensure_time!(set)
+      return set unless set.key?("values") && set["values"].key?("date")
+      return set if set["values"]["date"].is_a?(Time)
+      set["values"]["date"] = Utils.parse_date(
+        set["values"]["date"],
+        "An invalid date format was found in a front-matter default set: #{set}"
+      )
+      set
+    end
+
+    # Finds a default value for a given setting, filtered by path and type
+    #
+    # path - the path (relative to the source) of the page,
+    # post or :draft the default is used in
+    # type - a symbol indicating whether a :page,
+    # a :post or a :draft calls this method
+    #
+    # Returns the default value or nil if none was found
+    def find(path, type, setting)
+      value = nil
+      old_scope = nil
+
+      matching_sets(path, type).each do |set|
+        if set["values"].key?(setting) && has_precedence?(old_scope, set["scope"])
+          value = set["values"][setting]
+          old_scope = set["scope"]
+        end
+      end
+      value
+    end
+
+    # Collects a hash with all default values for a page or post
+    #
+    # path - the relative path of the page or post
+    # type - a symbol indicating the type (:post, :page or :draft)
+    #
+    # Returns a hash with all default values (an empty hash if there are none)
+    def all(path, type)
+      defaults = {}
+      old_scope = nil
+      matching_sets(path, type).each do |set|
+        if has_precedence?(old_scope, set["scope"])
+          defaults = Utils.deep_merge_hashes(defaults, set["values"])
+          old_scope = set["scope"]
+        else
+          defaults = Utils.deep_merge_hashes(set["values"], defaults)
+        end
+      end
+      defaults
+    end
+
+    private
+
+    # Checks if a given default setting scope matches the given path and type
+    #
+    # scope - the hash indicating the scope, as defined in _config.yml
+    # path - the path to check for
+    # type - the type (:post, :page or :draft) to check for
+    #
+    # Returns true if the scope applies to the given path and type
+    def applies?(scope, path, type)
+      applies_path?(scope, path) && applies_type?(scope, type)
+    end
+
+    def applies_path?(scope, path)
+      return true if !scope.key?("path") || scope["path"].empty?
+
+      scope_path = Pathname.new(scope["path"])
+      Pathname.new(sanitize_path(path)).ascend do |ascended_path|
+        if ascended_path.to_s == scope_path.to_s
+          return true
+        end
+      end
+    end
+
+    # Determines whether the scope applies to type.
+    # The scope applies to the type if:
+    #   1. no 'type' is specified
+    #   2. the 'type' in the scope is the same as the type asked about
+    #
+    # scope - the Hash defaults set being asked about application
+    # type  - the type of the document being processed / asked about
+    #         its defaults.
+    #
+    # Returns true if either of the above conditions are satisfied,
+    #   otherwise returns false
+    def applies_type?(scope, type)
+      !scope.key?("type") || scope["type"].eql?(type.to_s)
+    end
+
+    # Checks if a given set of default values is valid
+    #
+    # set - the default value hash, as defined in _config.yml
+    #
+    # Returns true if the set is valid and can be used in this class
+    def valid?(set)
+      set.is_a?(Hash) && set["values"].is_a?(Hash)
+    end
+
+    # Determines if a new scope has precedence over an old one
+    #
+    # old_scope - the old scope hash, or nil if there's none
+    # new_scope - the new scope hash
+    #
+    # Returns true if the new scope has precedence over the older
+    # rubocop: disable PredicateName
+    def has_precedence?(old_scope, new_scope)
+      return true if old_scope.nil?
+
+      new_path = sanitize_path(new_scope["path"])
+      old_path = sanitize_path(old_scope["path"])
+
+      if new_path.length != old_path.length
+        new_path.length >= old_path.length
+      elsif new_scope.key?("type")
+        true
+      else
+        !old_scope.key? "type"
+      end
+    end
+    # rubocop: enable PredicateName
+
+    # Collects a list of sets that match the given path and type
+    #
+    # Returns an array of hashes
+    def matching_sets(path, type)
+      valid_sets.select do |set|
+        !set.key?("scope") || applies?(set["scope"], path, type)
+      end
+    end
+
+    # Returns a list of valid sets
+    #
+    # This is not cached to allow plugins to modify the configuration
+    # and have their changes take effect
+    #
+    # Returns an array of hashes
+    def valid_sets
+      sets = @site.config["defaults"]
+      return [] unless sets.is_a?(Array)
+
+      sets.map do |set|
+        if valid?(set)
+          ensure_time!(update_deprecated_types(set))
+        else
+          Jekyll.logger.warn "Defaults:", "An invalid front-matter default set was found:"
+          Jekyll.logger.warn set.to_s
+          nil
+        end
+      end.compact
+    end
+
+    # Sanitizes the given path by removing a leading and adding a trailing slash
+    def sanitize_path(path)
+      if path.nil? || path.empty?
+        ""
+      else
+        path.gsub(%r!\A/|(?<=[^/])\z!, "".freeze)
+      end
+    end
+  end
+end

data/lib/jekyll/generator.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Jekyll
+  Generator = Class.new(Plugin)
+end

data/lib/jekyll/hooks.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module Hooks
+    DEFAULT_PRIORITY = 20
+
+    # compatibility layer for octopress-hooks users
+    PRIORITY_MAP = {
+      :low    => 10,
+      :normal => 20,
+      :high   => 30,
+    }.freeze
+
+    # initial empty hooks
+    @registry = {
+      :site      => {
+        :after_init  => [],
+        :after_reset => [],
+        :post_read   => [],
+        :pre_render  => [],
+        :post_render => [],
+        :post_write  => [],
+      },
+      :pages     => {
+        :post_init   => [],
+        :pre_render  => [],
+        :post_render => [],
+        :post_write  => [],
+      },
+      :posts     => {
+        :post_init   => [],
+        :pre_render  => [],
+        :post_render => [],
+        :post_write  => [],
+      },
+      :documents => {
+        :post_init   => [],
+        :pre_render  => [],
+        :post_render => [],
+        :post_write  => [],
+      },
+    }
+
+    # map of all hooks and their priorities
+    @hook_priority = {}
+
+    NotAvailable = Class.new(RuntimeError)
+    Uncallable = Class.new(RuntimeError)
+
+    # register hook(s) to be called later, public API
+    def self.register(owners, event, priority: DEFAULT_PRIORITY, &block)
+      Array(owners).each do |owner|
+        register_one(owner, event, priority_value(priority), &block)
+      end
+    end
+
+    # Ensure the priority is a Fixnum
+    def self.priority_value(priority)
+      return priority if priority.is_a?(Integer)
+      PRIORITY_MAP[priority] || DEFAULT_PRIORITY
+    end
+
+    # register a single hook to be called later, internal API
+    def self.register_one(owner, event, priority, &block)
+      @registry[owner] ||= {
+        :post_init   => [],
+        :pre_render  => [],
+        :post_render => [],
+        :post_write  => [],
+      }
+
+      unless @registry[owner][event]
+        raise NotAvailable, "Invalid hook. #{owner} supports only the " \
+          "following hooks #{@registry[owner].keys.inspect}"
+      end
+
+      unless block.respond_to? :call
+        raise Uncallable, "Hooks must respond to :call"
+      end
+
+      insert_hook owner, event, priority, &block
+    end
+
+    def self.insert_hook(owner, event, priority, &block)
+      @hook_priority[block] = [-priority, @hook_priority.size]
+      @registry[owner][event] << block
+    end
+
+    # interface for Jekyll core components to trigger hooks
+    def self.trigger(owner, event, *args)
+      # proceed only if there are hooks to call
+      return unless @registry[owner]
+      return unless @registry[owner][event]
+
+      # hooks to call for this owner and event
+      hooks = @registry[owner][event]
+
+      # sort and call hooks according to priority and load order
+      hooks.sort_by { |h| @hook_priority[h] }.each do |hook|
+        hook.call(*args)
+      end
+    end
+  end
+end

data/lib/jekyll/layout.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Jekyll
+  class Layout
+    include Convertible
+
+    # Gets the Site object.
+    attr_reader :site
+
+    # Gets the name of this layout.
+    attr_reader :name
+
+    # Gets the path to this layout.
+    attr_reader :path
+
+    # Gets the path to this layout relative to its base
+    attr_reader :relative_path
+
+    # Gets/Sets the extension of this layout.
+    attr_accessor :ext
+
+    # Gets/Sets the Hash that holds the metadata for this layout.
+    attr_accessor :data
+
+    # Gets/Sets the content of this layout.
+    attr_accessor :content
+
+    # Initialize a new Layout.
+    #
+    # site - The Site.
+    # base - The String path to the source.
+    # name - The String filename of the post file.
+    def initialize(site, base, name)
+      @site = site
+      @base = base
+      @name = name
+
+      if site.theme && site.theme.layouts_path.eql?(base)
+        @base_dir = site.theme.root
+        @path = site.in_theme_dir(base, name)
+      else
+        @base_dir = site.source
+        @path = site.in_source_dir(base, name)
+      end
+      @relative_path = @path.sub(@base_dir, "")
+
+      self.data = {}
+
+      process(name)
+      read_yaml(base, name)
+    end
+
+    # Extract information from the layout filename.
+    #
+    # name - The String filename of the layout file.
+    #
+    # Returns nothing.
+    def process(name)
+      self.ext = File.extname(name)
+    end
+  end
+end