bridgetown-core 0.12.1 → 0.15.0.beta2

data/lib/bridgetown-core/filters.rb

@@ -63,6 +63,16 @@ module Bridgetown
       Utils.slugify(input, mode: mode)
     end
 
+    # Titleize a slug or identifier string.
+    #
+    # input - The string to titleize.
+    #
+    # Returns a transformed string with spaces and capitalized words.
+    # See Utils.titleize_slug for more detail.
+    def titleize(input)
+      Utils.titleize_slug(input)
+    end
+
     # XML escape a string for use. Replaces any special characters with
     # appropriate HTML entity replacements.
     #

data/lib/bridgetown-core/generators/prototype_generator.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-Bridgetown::Hooks.register :pages, :post_init do |page|
+Bridgetown::Hooks.register :pages, :post_init, reloadable: false do |page|
   if page.class != Bridgetown::PrototypePage && page.data["prototype"].is_a?(Hash)
     Bridgetown::PrototypeGenerator.add_matching_template(page)
   end
@@ -63,6 +63,8 @@ module Bridgetown
       new_page
     end
 
+    # TODO: this would be a great use of .try
+    # document.try(:collection).try(:label) == @configured_collection
     def terms_matching_pages(search_term)
       selected_docs = @site.documents.select do |document|
         document.respond_to?(:collection) && document.collection.label == @configured_collection

data/lib/bridgetown-core/hooks.rb

@@ -2,6 +2,19 @@
 
 module Bridgetown
   module Hooks
+    HookRegistration = Struct.new(
+      :owner,
+      :event,
+      :priority,
+      :reloadable,
+      :block,
+      keyword_init: true
+    ) do
+      def to_s
+        "#{owner}:#{event} for #{block}"
+      end
+    end
+
     DEFAULT_PRIORITY = 20
 
     # compatibility layer for octopress-hooks users
@@ -12,51 +25,11 @@ module Bridgetown
     }.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: [],
-      },
-      clean: {
-        on_obsolete: [],
-      },
-    }
-
-    # map of all hooks and their priorities
-    @hook_priority = {}
+    @registry = {}
 
     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)
@@ -64,39 +37,66 @@ module Bridgetown
       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}"
+    # register hook(s) to be called later
+    def self.register(owners, event, priority: DEFAULT_PRIORITY, reloadable: true, &block)
+      Array(owners).each do |owner|
+        register_one(owner, event, priority: priority, reloadable: reloadable, &block)
       end
+    end
+
+    # register a single hook to be called later
+    def self.register_one(owner, event, priority: DEFAULT_PRIORITY, reloadable: true, &block)
+      @registry[owner] ||= []
 
       raise Uncallable, "Hooks must respond to :call" unless block.respond_to? :call
 
-      insert_hook owner, event, priority, &block
+      @registry[owner] << HookRegistration.new(
+        owner: owner,
+        event: event,
+        priority: priority_value(priority),
+        reloadable: reloadable,
+        block: block
+      )
+      if ENV["BRIDGETOWN_LOG_LEVEL"] == "debug"
+        if Bridgetown.respond_to?(:logger)
+          Bridgetown.logger.debug("Registering hook:", @registry[owner].last.to_s)
+        else
+          p "Registering hook:", @registry[owner].last.to_s
+        end
+      end
+
+      block
     end
 
-    def self.insert_hook(owner, event, priority, &block)
-      @hook_priority[block] = [-priority, @hook_priority.size]
-      @registry[owner][event] << block
+    def self.remove_hook(owner, _event, block)
+      @registry[owner].delete_if { |item| item.block == block }
     end
 
-    # interface for Bridgetown core components to trigger hooks
     def self.trigger(owner, event, *args)
       # proceed only if there are hooks to call
-      hooks = @registry.dig(owner, event)
+      hooks = @registry[owner]&.select { |item| item.event == event }
       return if hooks.nil? || hooks.empty?
 
-      # sort and call hooks according to priority and load order
-      hooks.sort_by { |h| @hook_priority[h] }.each do |hook|
-        hook.call(*args)
+      prioritized_hooks(hooks).each do |hook|
+        if ENV["BRIDGETOWN_LOG_LEVEL"] == "debug"
+          hook_info = args[0]&.respond_to?(:url) ? args[0].relative_path : hook.block
+          Bridgetown.logger.debug("Triggering hook:", "#{owner}:#{event} for #{hook_info}")
+        end
+        hook.block.call(*args)
+      end
+    end
+
+    def self.prioritized_hooks(hooks)
+      # sort hooks according to priority and load order
+      grouped_hooks = hooks.group_by(&:priority)
+      grouped_hooks.keys.sort.reverse.map { |priority| grouped_hooks[priority] }.flatten
+    end
+
+    def self.clear_reloadable_hooks
+      Bridgetown.logger.debug("Clearing reloadable hooks")
+
+      @registry.each_value do |hooks|
+        hooks.delete_if(&:reloadable)
       end
     end
   end

data/lib/bridgetown-core/layout.rb

@@ -29,14 +29,20 @@ module Bridgetown
     #
     # site - The Site.
     # base - The String path to the source.
-    # name - The String filename of the post file.
-    def initialize(site, base, name)
+    # name - The String filename of the layout file.
+    # from_plugin - true if the layout comes from a Gem-based plugin folder.
+    def initialize(site, base, name, from_plugin: false)
       @site = site
       @base = base
       @name = name
 
-      @base_dir = site.source
-      @path = site.in_source_dir(base, name)
+      if from_plugin
+        @base_dir = base.sub("/layouts", "")
+        @path = File.join(base, name)
+      else
+        @base_dir = site.source
+        @path = site.in_source_dir(base, name)
+      end
       @relative_path = @path.sub(@base_dir, "")
 
       self.data = {}

data/lib/bridgetown-core/liquid_renderer.rb

@@ -17,6 +17,7 @@ module Bridgetown
       Liquid::Template.file_system = LiquidRenderer::FileSystem.new(
         @site.components_load_paths, "%s.liquid"
       )
+      Liquid::Template.file_system.site = site
 
       Liquid::Template.error_mode = @site.config["liquid"]["error_mode"].to_sym
       reset
@@ -25,6 +26,7 @@ module Bridgetown
     def reset
       @stats = {}
       @cache = {}
+      Renderer.cached_partials = {}
     end
 
     def file(filename)

data/lib/bridgetown-core/liquid_renderer/file_system.rb

@@ -3,6 +3,8 @@
 module Bridgetown
   class LiquidRenderer
     class FileSystem < Liquid::LocalFileSystem
+      attr_accessor :site
+
       def read_template_file(template_path)
         load_paths = root
         found_paths = []
@@ -29,7 +31,9 @@ module Bridgetown
         raise Liquid::FileSystemError, "No such template '#{template_path}'" if found_paths.empty?
 
         # Last path in the list wins
-        ::File.read(found_paths.last)
+        LiquidComponent.parse(
+          ::File.read(found_paths.last, site.file_read_opts)
+        ).content
       end
     end
   end

data/lib/bridgetown-core/page.rb

@@ -35,12 +35,18 @@ module Bridgetown
     # base - The String path to the source.
     # dir  - The String path between the source and the file.
     # name - The String filename of the file.
-    def initialize(site, base, dir, name)
+    # from_plugin - true if the Page file is located in a Gem-based plugin folder
+    # rubocop:disable Metrics/ParameterLists
+    def initialize(site, base, dir, name, from_plugin: false)
       @site = site
       @base = base
       @dir  = dir
       @name = name
-      @path = site.in_source_dir(base, dir, name)
+      @path = if from_plugin
+                File.join(base, dir, name)
+              else
+                site.in_source_dir(base, dir, name)
+              end
 
       process(name)
       read_yaml(PathManager.join(base, dir), name)
@@ -51,6 +57,7 @@ module Bridgetown
 
       Bridgetown::Hooks.trigger :pages, :post_init, self
     end
+    # rubocop:enable Metrics/ParameterLists
 
     # The generated directory into which the page will be placed
     # upon generation. This is derived from the permalink or, if
@@ -66,18 +73,6 @@ module Bridgetown
       end
     end
 
-    # For backwards-compatibility in subclasses that do not redefine
-    # the `:to_liquid` method, stash existing definition under a new name
-    #
-    # TODO: Remove in Bridgetown 5.0
-    alias_method :legacy_to_liquid, :to_liquid
-    private :legacy_to_liquid
-
-    # Private
-    # Subclasses can choose to optimize their `:to_liquid` method by wrapping
-    # it around this definition.
-    #
-    # TODO: Remove in Bridgetown 5.0
     def liquid_drop
       @liquid_drop ||= begin
         defaults = site.frontmatter_defaults.all(relative_path, type)
@@ -87,15 +82,12 @@ module Bridgetown
         Drops::PageDrop.new(self)
       end
     end
-    private :liquid_drop
 
     # Public
     #
     # Liquid representation of current page
-    #
-    # TODO: Remove optional parameter in Bridgetown 5.0
-    def to_liquid(attrs = nil)
-      self.class == Bridgetown::Page ? liquid_drop : legacy_to_liquid(attrs)
+    def to_liquid
+      liquid_drop
     end
 
     # The full path and filename of the post. Defined in the YAML of the post

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
@@ -41,6 +67,7 @@ module Bridgetown
     # If that exact package hasn't been installed, execute yarn add
     #
     # Returns nothing.
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
     def self.install_yarn_dependencies(required_gems)
       return unless File.exist?("package.json")
 
@@ -53,14 +80,17 @@ module Bridgetown
         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
+        if package_json["dependencies"]
+          current_package = package_json["dependencies"].dig(yarn_add_dependency.first)
+          next unless current_package.nil? || current_package != yarn_add_dependency.last
+        end
 
         # all right, time to install the package
         cmd = "yarn add #{yarn_add_dependency.join("@")}"
         system cmd
       end
     end
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
 
     # Require all .rb files
     #
@@ -68,7 +98,31 @@ module Bridgetown
     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