bridgetown-core 0.13.0 → 0.14.0

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

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/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

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

@@ -4,6 +4,29 @@ module Bridgetown
   class PluginManager
     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 +36,25 @@ 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)
+        group_name = :bridgetown_plugins
+
+        required_gems = Bundler.require group_name
+        required_gems.select! do |dep|
+          (dep.groups & [group_name]).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
@@ -68,7 +94,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
 

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