bridgetown-core 1.3.4 → 2.0.0.beta1

data/lib/bridgetown-core/filters.rb

@@ -40,7 +40,7 @@ module Bridgetown
     # See Utils.slugify for more detail.
     def slugify(input, mode = nil)
       mode = @context.registers[:site].config.slugify_mode if mode.nil?
-      Utils.slugify(input, mode: mode)
+      Utils.slugify(input, mode:)
     end
 
     # Titleize a slug or identifier string.
@@ -395,8 +395,8 @@ module Bridgetown
       end
     end
 
-    FLOAT_LIKE   = %r!\A\s*-?(?:\d+\.?\d*|\.\d+)\s*\Z!.freeze
-    INTEGER_LIKE = %r!\A\s*-?\d+\s*\Z!.freeze
+    FLOAT_LIKE   = %r!\A\s*-?(?:\d+\.?\d*|\.\d+)\s*\Z!
+    INTEGER_LIKE = %r!\A\s*-?\d+\s*\Z!
     private_constant :FLOAT_LIKE, :INTEGER_LIKE
 
     # return numeric values as numbers for proper sorting

data/lib/bridgetown-core/front_matter/defaults.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module FrontMatter
+    # This class handles custom defaults for front matter settings.
+    # It is exposed via the frontmatter_defaults method on the site class.
+    class Defaults
+      # @return [Bridgetown::Site]
+      attr_reader :site
+
+      def initialize(site)
+        @site = site
+        @defaults_cache = {}
+      end
+
+      def reset
+        @glob_cache = {}
+        @defaults_cache = {}
+      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
+
+      # Collects a hash with all default values for a resource
+      #
+      # @param path [String] the relative path of the resource
+      # @param collection_name [Symbol] :posts, :pages, etc.
+      #
+      # @return [Hash] all default values (an empty hash if there are none)
+      def all(path, collection_name)
+        if @defaults_cache.key?([path, collection_name])
+          return @defaults_cache[[path, collection_name]]
+        end
+
+        defaults = {}
+        merge_data_cascade_for_path(path, defaults)
+
+        old_scope = nil
+        matching_sets(path, collection_name).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_cache[[path, collection_name]] = defaults
+      end
+
+      private
+
+      def merge_data_cascade_for_path(path, merged_data)
+        absolute_path = site.in_source_dir(path)
+        site.defaults_reader.path_defaults
+          .select { |k, _v| absolute_path.include? k }
+          .sort_by { |k, _v| k.length }
+          .each do |defaults|
+          merged_data.merge!(defaults[1])
+        end
+      end
+
+      # Checks if a given default setting scope matches the given path and collection
+      #
+      # scope - the hash indicating the scope, as defined in bridgetown.config.yml
+      # path - the path to check for
+      # collection - the collection (:posts or :pages) to check for
+      #
+      # Returns true if the scope applies to the given collection and path
+      def applies?(scope, path, collection)
+        applies_collection?(scope, collection) && applies_path?(scope, path)
+      end
+
+      def applies_path?(scope, path)
+        rel_scope_path = scope["path"]
+        return true if !rel_scope_path.is_a?(String) || rel_scope_path.empty?
+
+        sanitized_path = strip_collections_dir(sanitize_path(path))
+
+        if rel_scope_path.include?("*")
+          glob_scope(sanitized_path, rel_scope_path)
+        else
+          path_is_subpath?(sanitized_path, strip_collections_dir(rel_scope_path))
+        end
+      end
+
+      def glob_scope(sanitized_path, rel_scope_path)
+        site_source    = Pathname.new(site.source)
+        abs_scope_path = site_source.join(rel_scope_path).to_s
+
+        glob_cache(abs_scope_path).each do |scope_path|
+          scope_path = Pathname.new(scope_path).relative_path_from(site_source).to_s
+          scope_path = strip_collections_dir(scope_path)
+          Bridgetown.logger.debug "Globbed Scope Path:", scope_path
+          return true if path_is_subpath?(sanitized_path, scope_path)
+        end
+        false
+      end
+
+      def glob_cache(path)
+        @glob_cache ||= {}
+        @glob_cache[path] ||= Dir.glob(path)
+      end
+
+      def path_is_subpath?(path, parent_path)
+        path.start_with?(parent_path)
+      end
+
+      def strip_collections_dir(path)
+        collections_dir  = site.config["collections_dir"]
+        slashed_coll_dir = collections_dir.empty? ? "/" : "#{collections_dir}/"
+        return path if collections_dir.empty? || !path.to_s.start_with?(slashed_coll_dir)
+
+        path.sub(slashed_coll_dir, "")
+      end
+
+      # Determines whether the scope applies to collection.
+      # The scope applies to the collection if:
+      #   1. no 'collection' is specified
+      #   2. the 'collection' in the scope is the same as the collection asked about
+      #
+      # @param scope [Hash] the defaults set being asked about
+      # @param collection [Symbol] the collection of the resource being processed
+      #
+      # @return [Boolean] whether either of the above conditions are satisfied
+      def applies_collection?(scope, collection)
+        !scope.key?("collection") || scope["collection"].eql?(collection.to_s)
+      end
+
+      # Checks if a given set of default values is valid
+      #
+      # @param set [Hash] the default value hash as defined in bridgetown.config.yml
+      #
+      # @return [Boolean] if the set is valid and can be used
+      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 Naming/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?("collection")
+          true
+        else
+          !old_scope.key? "collection"
+        end
+      end
+      # rubocop: enable Naming/PredicateName
+
+      # Collects a list of sets that match the given path and collection
+      #
+      # @return [Array<Hash>]
+      def matching_sets(path, collection)
+        @matched_set_cache ||= {}
+        @matched_set_cache[path] ||= {}
+        @matched_set_cache[path][collection] ||= valid_sets.select do |set|
+          !set.key?("scope") || applies?(set["scope"], path, collection)
+        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
+      #
+      # @return [Array<Hash>]
+      def valid_sets
+        sets = site.config["defaults"]
+        return [] unless sets.is_a?(Array)
+
+        sets.filter_map do |set|
+          if valid?(set)
+            massage_scope!(set)
+            # TODO: is this trip really necessary?
+            ensure_time!(set)
+          else
+            Bridgetown.logger.warn "Defaults:", "An invalid front-matter default set was found:"
+            Bridgetown.logger.warn set.to_s
+            nil
+          end
+        end
+      end
+
+      # Set path to blank if not specified and alias older type to collection
+      def massage_scope!(set)
+        set["scope"] ||= {}
+        set["scope"]["path"] ||= ""
+        return unless set["scope"]["type"] && !set["scope"]["collection"]
+
+        set["scope"]["collection"] = set["scope"]["type"]
+      end
+
+      SANITIZATION_REGEX = %r!\A/|(?<=[^/])\z!
+
+      # 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(SANITIZATION_REGEX, "")
+        end
+      end
+    end
+  end
+end

data/lib/bridgetown-core/front_matter/importer.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module FrontMatter
+    module Importer
+      # Requires klass#content and klass#front_matter_line_count accessors
+      def self.included(klass)
+        klass.include Bridgetown::FrontMatter::RubyDSL
+      end
+
+      def read_front_matter(file_path)
+        file_contents = File.read(
+          file_path, **Bridgetown::Utils.merged_file_read_opts(Bridgetown::Current.site, {})
+        )
+        fm_result = nil
+        Loaders.for(self).each do |loader|
+          fm_result = loader.read(file_contents, file_path:) and break
+        end
+
+        if fm_result
+          self.content = fm_result.content
+          self.front_matter_line_count = fm_result.line_count
+          fm_result.front_matter
+        elsif is_a?(Layout)
+          self.content = file_contents
+          {}
+        else
+          yaml_data = YAMLParser.load_file(file_path)
+          (yaml_data.is_a?(Array) ? { rows: yaml_data } : yaml_data)
+        end
+      end
+    end
+  end
+end

data/lib/bridgetown-core/front_matter/loaders/base.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module FrontMatter
+    module Loaders
+      # An abstract base class for processing front matter
+      class Base
+        # @param origin_or_layout [Bridgetown::Model::RepoOrigin, Bridgetown::Layout]
+        def initialize(origin_or_layout)
+          @origin_or_layout = origin_or_layout
+        end
+
+        # Reads the contents of a file, returning a possible {Result}
+        #
+        # @param file_contents [String] the contents of the file being processed
+        # @param file_path [String] the path to the file being processed
+        # @return [Result, nil]
+        def read(file_contents, file_path:) # rubocop:disable Lint/UnusedMethodArgument
+          raise "Implement #read in a subclass of Bridgetown::FrontMatter::Loaders::Base"
+        end
+
+        private
+
+        # @return [Bridgetown::Model::RepoOrigin, Bridgetown::Layout]
+        attr_reader :origin_or_layout
+      end
+    end
+  end
+end

data/lib/bridgetown-core/front_matter/loaders/ruby.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module FrontMatter
+    module Loaders
+      # Reads Ruby front matter delineated by fenced code blocks or ERB/Serbea indicators.
+      #
+      # For example, all of these resources load the hash `{published: false,
+      # title: "My post"}` as their front matter.
+      #
+      # ~~~
+      # ```ruby
+      # {
+      #   published: false,
+      #   title: My post
+      # }
+      # ```
+      # ~~~
+      #
+      # ~~~~
+      # ~~~ruby
+      # {
+      #   published: false,
+      #   title: My post
+      # }
+      # ~~~
+      # ~~~~
+      #
+      # ~~~
+      # ###ruby
+      # {
+      #   published: false,
+      #   title: My post
+      # }
+      # ###
+      # ~~~
+      #
+      # ~~~
+      # ---ruby
+      # {
+      #   published: false,
+      #   title: My post
+      # }
+      # ---
+      # ~~~
+      #
+      # ~~~~
+      # ~~~<%
+      # {
+      #   published: false,
+      #   title: My post
+      # }
+      # %>~~~
+      # ~~~~
+      #
+      # ~~~~
+      # ~~~{%
+      # {
+      #   published: false,
+      #   title: My post
+      # }
+      # %}~~~
+      # ~~~~
+      class Ruby < Base
+        HEADER = %r!\A[~`#-]{3,}(?:ruby|<%|{%)[ \t]*\n!
+        BLOCK = %r!#{HEADER.source}(.*?\n?)^((?:%>|%})?[~`#-]{3,}[ \t]*$\n?)!m
+
+        # Determines whether a given file has Ruby front matter
+        #
+        # @param file [Pathname, String] the path to the file
+        # @return [Boolean] true if the file has Ruby front matter, false otherwise
+        def self.header?(file)
+          File.open(file, "rb", &:gets)&.match?(HEADER) || false
+        end
+
+        # @see {Base#read}
+        def read(file_contents, file_path:)
+          if (ruby_content = file_contents.match(BLOCK)) && should_execute_inline_ruby?
+            Result.new(
+              content: ruby_content.post_match.lstrip,
+              front_matter: process_ruby_data(ruby_content[1], file_path, 2),
+              line_count: ruby_content[1].lines.size - 1
+            )
+          elsif self.class.header?(file_path)
+            Result.new(
+              front_matter: process_ruby_data(
+                File.read(file_path).lines[1..].join("\n"),
+                file_path,
+                2
+              ),
+              line_count: 0
+            )
+          end
+        end
+
+        private
+
+        def process_ruby_data(rubycode, file_path, starting_line)
+          Bridgetown::Utils::RubyExec.process_ruby_data(
+            @origin_or_layout,
+            rubycode,
+            file_path,
+            starting_line
+          )
+        end
+
+        def should_execute_inline_ruby?
+          Bridgetown::Current.site.config.should_execute_inline_ruby?
+        end
+      end
+    end
+  end
+end

data/lib/bridgetown-core/front_matter/loaders/yaml.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module FrontMatter
+    module Loaders
+      # Reads YAML-formatted front matter delineated by triple hyphens
+      #
+      # As an example, this resource loads to the hash `{"published": false,
+      # "title": "My post"}`.
+      #
+      # ~~~
+      # ---
+      # published: false
+      # title: My post
+      # ---
+      # ~~~
+      class YAML < Base
+        HEADER = %r!\A---[ \t]*\n!
+        BLOCK = %r!#{HEADER.source}(.*?\n?)^((---|\.\.\.)[ \t]*$\n?)!m
+
+        # Determines whether a given file has YAML front matter
+        #
+        # @param file [String] the path to the file
+        # @return [Boolean] true if the file has YAML front matter, false otherwise
+        def self.header?(file)
+          File.open(file, "rb", &:gets)&.match?(HEADER) || false
+        end
+
+        # @see {Base#read}
+        def read(file_contents, **)
+          yaml_content = file_contents.match(BLOCK) or return
+
+          Result.new(
+            content: yaml_content.post_match.lstrip,
+            front_matter: YAMLParser.load(yaml_content[1]),
+            line_count: yaml_content[1].lines.size - 1
+          )
+        end
+      end
+    end
+  end
+end

data/lib/bridgetown-core/front_matter/loaders.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module FrontMatter
+    module Loaders
+      autoload :Base, "bridgetown-core/front_matter/loaders/base"
+      autoload :Ruby, "bridgetown-core/front_matter/loaders/ruby"
+      autoload :YAML, "bridgetown-core/front_matter/loaders/yaml"
+
+      Result = Struct.new(:content, :front_matter, :line_count, keyword_init: true)
+
+      # Constructs a list of possible loaders for a {Model::RepoOrigin} or {Layout}
+      #
+      # @param origin_or_layout [Bridgetown::Model::RepoOrigin, Bridgetown::Layout]
+      # @return [Array<Loaders::Base>]
+      def self.for(origin_or_layout)
+        registry.map { |loader_class| loader_class.new(origin_or_layout) }
+      end
+
+      # Determines whether a given file has front matter
+      #
+      # @param path [Pathname, String] the path to the file
+      # @return [Boolean] true if the file has front matter, false otherwise
+      def self.front_matter?(file)
+        registry.any? { |loader_class| loader_class.header?(file) }
+      end
+
+      # Registers a new type of front matter loader
+      #
+      # @param loader_class [Loader::Base]
+      # @return [void]
+      def self.register(loader_class)
+        registry.push(loader_class)
+      end
+
+      private_class_method def self.registry
+        @registry ||= []
+      end
+
+      register YAML
+      register Ruby
+    end
+  end
+end

data/lib/bridgetown-core/{utils/ruby_front_matter.rb → front_matter/ruby.rb}

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
 module Bridgetown
-  module Utils
-    module RubyFrontMatterDSL
+  module FrontMatter
+    module RubyDSL
       def front_matter(scope: nil, &block)
-        RubyFrontMatter.new(scope: scope).tap { |fm| fm.instance_exec(&block) }
+        RubyFrontMatter.new(scope:).tap { |fm| fm.instance_exec(&block) }
       end
     end
 
@@ -21,8 +21,8 @@ module Bridgetown
         set(key, value[0], &block)
       end
 
-      def each(&block)
-        @data.each(&block)
+      def each(&)
+        @data.each(&)
       end
 
       def get(key)

data/lib/bridgetown-core/front_matter.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module FrontMatter
+    autoload :Defaults, "bridgetown-core/front_matter/defaults"
+    autoload :Importer, "bridgetown-core/front_matter/importer"
+    autoload :Loaders, "bridgetown-core/front_matter/loaders"
+    autoload :RubyDSL, "bridgetown-core/front_matter/ruby"
+    autoload :RubyFrontMatter, "bridgetown-core/front_matter/ruby"
+  end
+end