bridgetown-core 0.13.0 → 0.15.0.beta3

data/lib/bridgetown-core/plugin.rb

@@ -10,6 +10,8 @@ module Bridgetown
       high: 10,
     }.freeze
 
+    SourceManifest = Struct.new(:origin, :components, :content, :layouts, keyword_init: true)
+
     #
 
     def self.inherited(const)

data/lib/bridgetown-core/plugin_manager.rb

@@ -2,8 +2,33 @@
 
 module Bridgetown
   class PluginManager
+    PLUGINS_GROUP = :bridgetown_plugins
+
     attr_reader :site
 
+    @source_manifests = Set.new
+    @registered_plugins = Set.new
+
+    def self.add_source_manifest(source_manifest)
+      unless source_manifest.is_a?(Bridgetown::Plugin::SourceManifest)
+        raise "You must add a SourceManifest instance"
+      end
+
+      @source_manifests << source_manifest
+    end
+
+    def self.new_source_manifest(*args)
+      add_source_manifest(Bridgetown::Plugin::SourceManifest.new(*args))
+    end
+
+    def self.add_registered_plugin(gem_or_plugin_file)
+      @registered_plugins << gem_or_plugin_file
+    end
+
+    class << self
+      attr_reader :source_manifests, :registered_plugins
+    end
+
     # Create an instance of this class.
     #
     # site - the instance of Bridgetown::Site we're concerned with
@@ -13,22 +38,23 @@ module Bridgetown
       @site = site
     end
 
-    # Require all the plugins which are allowed.
-    #
-    # Returns nothing
-    def conscientious_require
-      require_plugin_files
-    end
-
     def self.require_from_bundler
       if !ENV["BRIDGETOWN_NO_BUNDLER_REQUIRE"] && File.file?("Gemfile")
         require "bundler"
 
-        Bundler.setup
-        required_gems = Bundler.require(:bridgetown_plugins)
+        required_gems = Bundler.require PLUGINS_GROUP
+        required_gems.select! do |dep|
+          (dep.groups & [PLUGINS_GROUP]).any? && dep.should_include?
+        end
+
         install_yarn_dependencies(required_gems)
-        message = "Required #{required_gems.map(&:name).join(", ")}"
-        Bridgetown.logger.debug("PluginManager:", message)
+
+        required_gems.each do |installed_gem|
+          add_registered_plugin installed_gem
+        end
+
+        Bridgetown.logger.debug("PluginManager:",
+                                "Required #{required_gems.map(&:name).join(", ")}")
         ENV["BRIDGETOWN_NO_BUNDLER_REQUIRE"] = "true"
 
         true
@@ -47,28 +73,69 @@ module Bridgetown
       package_json = JSON.parse(File.read("package.json"))
 
       required_gems.each do |loaded_gem|
-        next unless loaded_gem.to_spec&.metadata&.dig("yarn-add")
-
-        yarn_add_dependency = loaded_gem.to_spec.metadata["yarn-add"].split("@")
-        next unless yarn_add_dependency.length == 2
-
-        # check matching version number is see if it's already installed
-        current_package = package_json["dependencies"].dig(yarn_add_dependency.first)
-        next unless current_package.nil? || current_package != yarn_add_dependency.last
+        yarn_dependency = find_yarn_dependency(loaded_gem)
+        next unless add_yarn_dependency?(yarn_dependency, package_json)
 
         # all right, time to install the package
-        cmd = "yarn add #{yarn_add_dependency.join("@")}"
+        cmd = "yarn add #{yarn_dependency.join("@")}"
         system cmd
       end
     end
 
+    def self.find_yarn_dependency(loaded_gem)
+      yarn_dependency = loaded_gem.to_spec&.metadata&.dig("yarn-add")&.split("@")
+      return nil if yarn_dependency&.length != 2
+
+      yarn_dependency
+    end
+
+    def self.add_yarn_dependency?(yarn_dependency, package_json)
+      return false if yarn_dependency.nil?
+
+      # check matching version number is see if it's already installed
+      if package_json["dependencies"]
+        current_version = package_json["dependencies"].dig(yarn_dependency.first)
+        package_requires_updating?(current_version, yarn_dependency.last)
+      else
+        true
+      end
+    end
+
+    def self.package_requires_updating?(current_version, dep_version)
+      current_version.nil? || current_version != dep_version && !current_version.include?("/")
+    end
+
     # Require all .rb files
     #
     # Returns nothing.
     def require_plugin_files
       plugins_path.each do |plugin_search_path|
         plugin_files = Utils.safe_glob(plugin_search_path, File.join("**", "*.rb"))
-        Bridgetown::External.require_with_graceful_fail(plugin_files)
+
+        # Require "site_builder.rb" first if present so subclasses can all
+        # inherit from SiteBuilder without needing explicit require statements
+        sorted_plugin_files = plugin_files.select do |path|
+          path.include?("site_builder.rb")
+        end + plugin_files.reject do |path|
+          path.include?("site_builder.rb")
+        end
+
+        sorted_plugin_files.each do |plugin_file|
+          self.class.add_registered_plugin plugin_file
+        end
+        Bridgetown::External.require_with_graceful_fail(sorted_plugin_files)
+      end
+    end
+
+    # Reload .rb plugin files via the watcher
+    def reload_plugin_files
+      plugins_path.each do |plugin_search_path|
+        plugin_files = Utils.safe_glob(plugin_search_path, File.join("**", "*.rb"))
+        Array(plugin_files).each do |name|
+          Bridgetown.logger.debug "Reloading:", name.to_s
+          self.class.add_registered_plugin name
+          load name
+        end
       end
     end
 

data/lib/bridgetown-core/reader.rb

@@ -11,6 +11,7 @@ module Bridgetown
     # Read Site data from disk and load it into internal data structures.
     #
     # Returns nothing.
+    # rubocop:disable Metrics/AbcSize
     def read
       @site.layouts = LayoutReader.new(site).read
       read_directories
@@ -18,7 +19,11 @@ module Bridgetown
       sort_files!
       @site.data = DataReader.new(site).read(site.config["data_dir"])
       CollectionReader.new(site).read
+      Bridgetown::PluginManager.source_manifests.map(&:content).compact.each do |plugin_content_dir|
+        PluginContentReader.new(site, plugin_content_dir).read
+      end
     end
+    # rubocop:enable Metrics/AbcSize
 
     # Sorts posts, pages, and static files.
     def sort_files!

data/lib/bridgetown-core/readers/data_reader.rb

@@ -5,7 +5,7 @@ module Bridgetown
     attr_reader :site, :content
     def initialize(site)
       @site = site
-      @content = {}
+      @content = ActiveSupport::HashWithIndifferentAccess.new
       @entry_filter = EntryFilter.new(site)
     end
 
@@ -41,7 +41,10 @@ module Bridgetown
         next if @entry_filter.symlink?(path)
 
         if File.directory?(path)
-          read_data_to(path, data[sanitize_filename(entry)] = {})
+          read_data_to(
+            path,
+            data[sanitize_filename(entry)] = ActiveSupport::HashWithIndifferentAccess.new
+          )
         else
           key = sanitize_filename(File.basename(entry, ".*"))
           data[key] = read_data_file(path)

data/lib/bridgetown-core/readers/layout_reader.rb

@@ -14,6 +14,13 @@ module Bridgetown
           Layout.new(site, layout_directory, layout_file)
       end
 
+      Bridgetown::PluginManager.source_manifests.map(&:layouts).compact.each do |plugin_layouts|
+        layout_entries(plugin_layouts).each do |layout_file|
+          @layouts[layout_name(layout_file)] ||= \
+            Layout.new(site, plugin_layouts, layout_file, from_plugin: true)
+        end
+      end
+
       @layouts
     end
 
@@ -23,8 +30,8 @@ module Bridgetown
 
     private
 
-    def layout_entries
-      entries_in layout_directory
+    def layout_entries(dir = layout_directory)
+      entries_in dir
     end
 
     def entries_in(dir)

data/lib/bridgetown-core/readers/plugin_content_reader.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  class PluginContentReader
+    attr_reader :site, :content_dir
+
+    def initialize(site, plugin_content_dir)
+      @site = site
+      @content_dir = plugin_content_dir
+      @content_files = Set.new
+    end
+
+    def read
+      return unless content_dir
+
+      Find.find(content_dir) do |path|
+        next if File.directory?(path)
+
+        if File.symlink?(path)
+          Bridgetown.logger.warn "Plugin content reader:", "Ignored symlinked asset: #{path}"
+        else
+          read_content_file(path)
+        end
+      end
+    end
+
+    def read_content_file(path)
+      dir = File.dirname(path.sub("#{content_dir}/", ""))
+      name = File.basename(path)
+
+      @content_files << if Utils.has_yaml_header?(path)
+                          Bridgetown::Page.new(site, content_dir, dir, name, from_plugin: true)
+                        else
+                          Bridgetown::StaticFile.new(site, content_dir, "/#{dir}", name)
+                        end
+
+      add_to(site.pages, Bridgetown::Page)
+      add_to(site.static_files, Bridgetown::StaticFile)
+    end
+
+    def add_to(content_type, klass)
+      existing_paths = content_type.map(&:relative_path).compact
+      @content_files.select { |item| item.is_a?(klass) }.each do |item|
+        content_type << item unless existing_paths.include?(item.relative_path)
+      end
+    end
+  end
+end

data/lib/bridgetown-core/renderer.rb

@@ -5,11 +5,16 @@ module Bridgetown
     attr_reader :document, :site
     attr_writer :layouts, :payload
 
+    class << self
+      attr_accessor :cached_partials
+    end
+
     def initialize(site, document, site_payload = nil)
       @site     = site
       @document = document
       @payload  = site_payload
       @layouts  = nil
+      self.class.cached_partials ||= {}
     end
 
     # Fetches the payload used in Liquid rendering.
@@ -48,7 +53,7 @@ module Bridgetown
 
     # Prepare payload and render the document
     #
-    # Returns String rendered document output
+    # Returns nothing
     def run
       Bridgetown.logger.debug "Rendering:", document.relative_path
 
@@ -57,10 +62,9 @@ module Bridgetown
       assign_highlighter_options!
       assign_layout_data!
 
-      Bridgetown.logger.debug "Pre-Render Hooks:", document.relative_path
       document.trigger_hooks(:pre_render, payload)
-
-      render_document
+      document.output = render_document
+      document.trigger_hooks(:post_render)
     end
 
     # Render the document.
@@ -68,18 +72,14 @@ module Bridgetown
     # Returns String rendered document output
     # rubocop: disable Metrics/AbcSize
     def render_document
-      info = {
-        registers: { site: site, page: payload["page"] },
-        strict_filters: liquid_options["strict_filters"],
-        strict_variables: liquid_options["strict_variables"],
-      }
+      liquid_context = provide_liquid_context
 
       execute_inline_ruby!
 
       output = document.content
       if document.render_with_liquid?
         Bridgetown.logger.debug "Rendering Liquid:", document.relative_path
-        output = render_liquid(output, payload, info, document.path)
+        output = render_liquid(output, payload, liquid_context, document.path)
       end
 
       Bridgetown.logger.debug "Rendering Markup:", document.relative_path
@@ -88,12 +88,24 @@ module Bridgetown
 
       if document.place_in_layout?
         Bridgetown.logger.debug "Rendering Layout:", document.relative_path
-        output = place_in_layouts(output, payload, info)
+        output = place_in_layouts(output, payload, liquid_context)
       end
 
       output
     end
 
+    def provide_liquid_context
+      {
+        registers: {
+          site: site,
+          page: payload["page"],
+          cached_partials: self.class.cached_partials,
+        },
+        strict_filters: liquid_options["strict_filters"],
+        strict_variables: liquid_options["strict_variables"],
+      }
+    end
+
     def execute_inline_ruby!
       return unless site.config.should_execute_inline_ruby?
 
@@ -102,21 +114,21 @@ module Bridgetown
 
     # rubocop: enable Metrics/AbcSize
 
-    # Render the given content with the payload and info
+    # Render the given content with the payload and context
     #
     # content -
     # payload -
-    # info    -
+    # context    -
     # path    - (optional) the path to the file, for use in ex
     #
     # Returns String the content, rendered by Liquid.
-    def render_liquid(content, payload, info, path = nil)
+    def render_liquid(content, payload, liquid_context, path = nil)
       template = site.liquid_renderer.file(path).parse(content)
       template.warnings.each do |e|
         Bridgetown.logger.warn "Liquid Warning:",
                                LiquidRenderer.format_error(e, path || document.relative_path)
       end
-      template.render!(payload, info)
+      template.render!(payload, liquid_context)
     # rubocop: disable Lint/RescueException
     rescue Exception => e
       Bridgetown.logger.error "Liquid Exception:",
@@ -130,15 +142,13 @@ module Bridgetown
     # Returns String the converted content.
     def convert(content)
       converters.reduce(content) do |output, converter|
-        begin
-          converter.convert output
-        rescue StandardError => e
-          Bridgetown.logger.error "Conversion error:",
-                                  "#{converter.class} encountered an error while "\
-                                  "converting '#{document.relative_path}':"
-          Bridgetown.logger.error("", e.to_s)
-          raise e
-        end
+        converter.convert output
+      rescue StandardError => e
+        Bridgetown.logger.error "Conversion error:",
+                                "#{converter.class} encountered an error while "\
+                                "converting '#{document.relative_path}':"
+        Bridgetown.logger.error("", e.to_s)
+        raise e
       end
     end
 
@@ -154,7 +164,7 @@ module Bridgetown
     # Render layouts and place document content inside.
     #
     # Returns String rendered content
-    def place_in_layouts(content, payload, info)
+    def place_in_layouts(content, payload, liquid_context)
       output = content.dup
       layout = layouts[document.data["layout"].to_s]
       validate_layout(layout)
@@ -165,7 +175,7 @@ module Bridgetown
       payload["layout"] = nil
 
       while layout
-        output = render_layout(output, layout, info)
+        output = render_layout(output, layout, liquid_context)
         add_regenerator_dependencies(layout)
 
         next unless (layout = site.layouts[layout.data["layout"]])
@@ -192,14 +202,14 @@ module Bridgetown
     # Render layout content into document.output
     #
     # Returns String rendered content
-    def render_layout(output, layout, info)
+    def render_layout(output, layout, liquid_context)
       payload["content"] = output
       payload["layout"]  = Utils.deep_merge_hashes(layout.data, payload["layout"] || {})
 
       render_liquid(
         layout.content,
         payload,
-        info,
+        liquid_context,
         layout.path
       )
     end

data/lib/bridgetown-core/site.rb

@@ -2,125 +2,43 @@
 
 module Bridgetown
   class Site
-    attr_reader   :root_dir, :source, :dest, :cache_dir, :config
+    require_all "bridgetown-core/concerns/site"
+
+    include Configurable
+    include Content
+    include Extensible
+    include Processable
+    include Renderable
+    include Writable
+
+    attr_reader   :root_dir, :source, :dest, :cache_dir, :config,
+                  :regenerator, :liquid_renderer, :components_load_paths,
+                  :includes_load_paths
     attr_accessor :layouts, :pages, :static_files,
                   :exclude, :include, :lsi, :highlighter, :permalink_style,
-                  :time, :future, :unpublished, :plugins, :limit_posts,
+                  :time, :future, :unpublished, :limit_posts,
                   :keep_files, :baseurl, :data, :file_read_opts,
-                  :plugin_manager
-
-    attr_accessor :converters, :generators, :reader
-    attr_reader   :regenerator, :liquid_renderer, :components_load_paths,
-                  :includes_load_paths
+                  :plugin_manager, :converters, :generators, :reader
 
     # Public: Initialize a new Site.
     #
     # config - A Hash containing site configuration details.
     def initialize(config)
-      # Source and destination may not be changed after the site has been created.
-      @root_dir        = File.expand_path(config["root_dir"]).freeze
-      @source          = File.expand_path(config["source"]).freeze
-      @dest            = File.expand_path(config["destination"]).freeze
-
       self.config = config
 
-      @cache_dir       = in_root_dir(config["cache_dir"])
+      @plugin_manager  = PluginManager.new(self)
+      @cleaner         = Cleaner.new(self)
       @reader          = Reader.new(self)
       @regenerator     = Regenerator.new(self)
       @liquid_renderer = LiquidRenderer.new(self)
 
-      Bridgetown.sites << self
-
-      reset
-      setup
-
-      Bridgetown::Hooks.trigger :site, :after_init, self
-    end
-
-    # Public: Set the site's configuration. This handles side-effects caused by
-    # changing values in the configuration.
-    #
-    # config - a Bridgetown::Configuration, containing the new configuration.
-    #
-    # Returns the new configuration.
-    def config=(config)
-      @config = config.clone
-
-      %w(lsi highlighter baseurl exclude include future unpublished
-         limit_posts keep_files).each do |opt|
-        send("#{opt}=", config[opt])
-      end
-
-      configure_cache
-      configure_plugins
-      configure_component_paths
-      configure_include_paths
-      configure_file_read_opts
-
-      self.permalink_style = config["permalink"].to_sym
-
-      @config
-    end
-
-    # Public: Read, process, and write this Site to output.
-    #
-    # Returns nothing.
-    def process
-      reset
-      read
-      generate
-      render
-      cleanup
-      write
-      print_stats if config["profile"]
-    end
-
-    def print_stats
-      Bridgetown.logger.info @liquid_renderer.stats_table
-    end
-
-    # rubocop:disable Metrics/MethodLength
-    #
-    # Reset Site details.
-    #
-    # Returns nothing
-    def reset
-      self.time = if config["time"]
-                    Utils.parse_date(config["time"].to_s, "Invalid time in bridgetown.config.yml.")
-                  else
-                    Time.now
-                  end
-      self.layouts = {}
-      self.pages = []
-      self.static_files = []
-      self.data = {}
-      @post_attr_hash = {}
-      @site_data = nil
-      @collections = nil
-      @documents = nil
-      @docs_to_write = nil
-      @regenerator.clear_cache
-      @liquid_renderer.reset
-      @site_cleaner = nil
-      frontmatter_defaults.reset
-
-      raise ArgumentError, "limit_posts must be a non-negative number" if limit_posts.negative?
-
-      Bridgetown::Cache.clear_if_config_changed config
-      Bridgetown::Hooks.trigger :site, :after_reset, self
-    end
-    # rubocop:enable Metrics/MethodLength
-
-    # Load necessary libraries, plugins, converters, and generators.
-    #
-    # Returns nothing.
-    def setup
       ensure_not_in_dest
 
-      plugin_manager.conscientious_require
+      Bridgetown.sites << self
+      Bridgetown::Hooks.trigger :site, :after_init, self
 
-      self.converters = instantiate_subclasses(Bridgetown::Converter)
-      self.generators = instantiate_subclasses(Bridgetown::Generator)
+      reset   # Processable
+      setup   # Extensible
     end
 
     # Check that the destination dir isn't the source dir or a directory
@@ -134,366 +52,5 @@ module Bridgetown
         end
       end
     end
-
-    # The list of collections and their corresponding Bridgetown::Collection instances.
-    # If config['collections'] is set, a new instance is created
-    # for each item in the collection, a new hash is returned otherwise.
-    #
-    # Returns a Hash containing collection name-to-instance pairs.
-    def collections
-      @collections ||= collection_names.each_with_object({}) do |name, hsh|
-        hsh[name] = Bridgetown::Collection.new(self, name)
-      end
-    end
-
-    # The list of collection names.
-    #
-    # Returns an array of collection names from the configuration,
-    #   or an empty array if the `collections` key is not set.
-    def collection_names
-      case config["collections"]
-      when Hash
-        config["collections"].keys
-      when Array
-        config["collections"]
-      when nil
-        []
-      else
-        raise ArgumentError, "Your `collections` key must be a hash or an array."
-      end
-    end
-
-    # Read Site data from disk and load it into internal data structures.
-    #
-    # Returns nothing.
-    def read
-      reader.read
-      limit_posts!
-      Bridgetown::Hooks.trigger :site, :post_read, self
-    end
-
-    # Run each of the Generators.
-    #
-    # Returns nothing.
-    def generate
-      generators.each do |generator|
-        start = Time.now
-        generator.generate(self)
-        Bridgetown.logger.debug "Generating:",
-                                "#{generator.class} finished in #{Time.now - start} seconds."
-      end
-    end
-
-    # Render the site to the destination.
-    #
-    # Returns nothing.
-    def render
-      payload = site_payload
-
-      Bridgetown::Hooks.trigger :site, :pre_render, self, payload
-
-      execute_inline_ruby_for_layouts!
-
-      render_docs(payload)
-      render_pages(payload)
-
-      Bridgetown::Hooks.trigger :site, :post_render, self, payload
-    end
-
-    # Remove orphaned files and empty directories in destination.
-    #
-    # Returns nothing.
-    def cleanup
-      site_cleaner.cleanup!
-    end
-
-    # Write static files, pages, and posts.
-    #
-    # Returns nothing.
-    def write
-      each_site_file do |item|
-        item.write(dest) if regenerator.regenerate?(item)
-      end
-      regenerator.write_metadata
-      Bridgetown::Hooks.trigger :site, :post_write, self
-    end
-
-    def posts
-      collections["posts"] ||= Collection.new(self, "posts")
-    end
-
-    # Construct a Hash of Posts indexed by the specified Post attribute.
-    #
-    # post_attr - The String name of the Post attribute.
-    #
-    # Examples
-    #
-    #   post_attr_hash('categories')
-    #   # => { 'tech' => [<Post A>, <Post B>],
-    #   #      'ruby' => [<Post B>] }
-    #
-    # Returns the Hash: { attr => posts } where
-    #   attr  - One of the values for the requested attribute.
-    #   posts - The Array of Posts with the given attr value.
-    def post_attr_hash(post_attr)
-      # Build a hash map based on the specified post attribute ( post attr =>
-      # array of posts ) then sort each array in reverse order.
-      @post_attr_hash[post_attr] ||= begin
-        hash = Hash.new { |h, key| h[key] = [] }
-        posts.docs.each do |p|
-          p.data[post_attr]&.each { |t| hash[t] << p }
-        end
-        hash.each_value { |posts| posts.sort!.reverse! }
-        hash
-      end
-    end
-
-    def tags
-      post_attr_hash("tags")
-    end
-
-    def categories
-      post_attr_hash("categories")
-    end
-
-    # Prepare site data for site payload. The method maintains backward compatibility
-    # if the key 'data' is already used in bridgetown.config.yml.
-    #
-    # Returns the Hash to be hooked to site.data.
-    def site_data
-      @site_data ||= (config["data"] || data)
-    end
-
-    def metadata
-      data["site_metadata"] || {}
-    end
-
-    # The Hash payload containing site-wide data.
-    #
-    # Returns the Hash: { "site" => data } where data is a Hash with keys:
-    #   "time"       - The Time as specified in the configuration or the
-    #                  current time if none was specified.
-    #   "posts"      - The Array of Posts, sorted chronologically by post date
-    #                  and then title.
-    #   "pages"      - The Array of all Pages.
-    #   "html_pages" - The Array of HTML Pages.
-    #   "categories" - The Hash of category values and Posts.
-    #                  See Site#post_attr_hash for type info.
-    #   "tags"       - The Hash of tag values and Posts.
-    #                  See Site#post_attr_hash for type info.
-    def site_payload
-      Drops::UnifiedPayloadDrop.new self
-    end
-    alias_method :to_liquid, :site_payload
-
-    # Get the implementation class for the given Converter.
-    # Returns the Converter instance implementing the given Converter.
-    # klass - The Class of the Converter to fetch.
-    def find_converter_instance(klass)
-      @find_converter_instance ||= {}
-      @find_converter_instance[klass] ||= begin
-        converters.find { |converter| converter.instance_of?(klass) } || \
-          raise("No Converters found for #{klass}")
-      end
-    end
-
-    # klass - class or module containing the subclasses.
-    # Returns array of instances of subclasses of parameter.
-    # Create array of instances of the subclasses of the class or module
-    # passed in as argument.
-
-    def instantiate_subclasses(klass)
-      klass.descendants.sort.map do |c|
-        c.new(config)
-      end
-    end
-
-    # Get the to be written documents
-    #
-    # Returns an Array of Documents which should be written
-    def docs_to_write
-      documents.select(&:write?)
-    end
-
-    # Get all the documents
-    #
-    # Returns an Array of all Documents
-    def documents
-      collections.each_with_object(Set.new) do |(_, collection), set|
-        set.merge(collection.docs).merge(collection.files)
-      end.to_a
-    end
-
-    def each_site_file
-      %w(pages static_files docs_to_write).each do |type|
-        send(type).each do |item|
-          yield item
-        end
-      end
-    end
-
-    # Returns the FrontmatterDefaults or creates a new FrontmatterDefaults
-    # if it doesn't already exist.
-    #
-    # Returns The FrontmatterDefaults
-    def frontmatter_defaults
-      @frontmatter_defaults ||= FrontmatterDefaults.new(self)
-    end
-
-    # Whether to perform a full rebuild without incremental regeneration
-    #
-    # Returns a Boolean: true for a full rebuild, false for normal build
-    def incremental?(override = {})
-      override["incremental"] || config["incremental"]
-    end
-
-    # Returns the publisher or creates a new publisher if it doesn't
-    # already exist.
-    #
-    # Returns The Publisher
-    def publisher
-      @publisher ||= Publisher.new(self)
-    end
-
-    # Public: Prefix a given path with the root directory.
-    #
-    # paths - (optional) path elements to a file or directory within the
-    #         root directory
-    #
-    # Returns a path which is prefixed with the root_dir directory.
-    def in_root_dir(*paths)
-      paths.reduce(root_dir) do |base, path|
-        Bridgetown.sanitized_path(base, path)
-      end
-    end
-
-    # Public: Prefix a given path with the source directory.
-    #
-    # paths - (optional) path elements to a file or directory within the
-    #         source directory
-    #
-    # Returns a path which is prefixed with the source directory.
-    def in_source_dir(*paths)
-      paths.reduce(source) do |base, path|
-        Bridgetown.sanitized_path(base, path)
-      end
-    end
-
-    # Public: Prefix a given path with the destination directory.
-    #
-    # paths - (optional) path elements to a file or directory within the
-    #         destination directory
-    #
-    # Returns a path which is prefixed with the destination directory.
-    def in_dest_dir(*paths)
-      paths.reduce(dest) do |base, path|
-        Bridgetown.sanitized_path(base, path)
-      end
-    end
-
-    # Public: Prefix a given path with the cache directory.
-    #
-    # paths - (optional) path elements to a file or directory within the
-    #         cache directory
-    #
-    # Returns a path which is prefixed with the cache directory.
-    def in_cache_dir(*paths)
-      paths.reduce(cache_dir) do |base, path|
-        Bridgetown.sanitized_path(base, path)
-      end
-    end
-
-    # Public: The full path to the directory that houses all the collections registered
-    # with the current site.
-    #
-    # Returns the source directory or the absolute path to the custom collections_dir
-    def collections_path
-      dir_str = config["collections_dir"]
-      @collections_path ||= dir_str.empty? ? source : in_source_dir(dir_str)
-    end
-
-    private
-
-    # Limits the current posts; removes the posts which exceed the limit_posts
-    #
-    # Returns nothing
-    def limit_posts!
-      if limit_posts.positive?
-        limit = posts.docs.length < limit_posts ? posts.docs.length : limit_posts
-        posts.docs = posts.docs[-limit, limit]
-      end
-    end
-
-    # Returns the Cleaner or creates a new Cleaner if it doesn't
-    # already exist.
-    #
-    # Returns The Cleaner
-    def site_cleaner
-      @site_cleaner ||= Cleaner.new(self)
-    end
-
-    # Disable Marshaling cache to disk in Safe Mode
-    def configure_cache
-      Bridgetown::Cache.cache_dir = in_root_dir(config["cache_dir"], "Bridgetown/Cache")
-      Bridgetown::Cache.disable_disk_cache! if config["disable_disk_cache"]
-    end
-
-    def configure_plugins
-      self.plugin_manager = Bridgetown::PluginManager.new(self)
-      self.plugins        = plugin_manager.plugins_path
-    end
-
-    def configure_component_paths
-      @components_load_paths = config["components_dir"].then do |dir|
-        dir.is_a?(Array) ? dir : [dir]
-      end
-      @components_load_paths.map! do |dir|
-        if !!(dir =~ %r!^\.\.?\/!)
-          # allow ./dir or ../../dir type options
-          File.expand_path(dir.to_s, root_dir)
-        else
-          in_source_dir(dir.to_s)
-        end
-      end
-    end
-
-    def configure_include_paths
-      @includes_load_paths = Array(in_source_dir(config["includes_dir"].to_s))
-    end
-
-    def configure_file_read_opts
-      self.file_read_opts = {}
-      file_read_opts[:encoding] = config["encoding"] if config["encoding"]
-      self.file_read_opts = Bridgetown::Utils.merged_file_read_opts(self, {})
-    end
-
-    def execute_inline_ruby_for_layouts!
-      return unless config.should_execute_inline_ruby?
-
-      layouts.each_value do |layout|
-        Bridgetown::Utils::RubyExec.search_data_for_ruby_code(layout, self)
-      end
-    end
-
-    def render_docs(payload)
-      collections.each_value do |collection|
-        collection.docs.each do |document|
-          render_regenerated(document, payload)
-        end
-      end
-    end
-
-    def render_pages(payload)
-      pages.each do |page|
-        render_regenerated(page, payload)
-      end
-    end
-
-    def render_regenerated(document, payload)
-      return unless regenerator.regenerate?(document)
-
-      document.output = Bridgetown::Renderer.new(self, document, payload).run
-      document.trigger_hooks(:post_render)
-    end
   end
 end