bridgetown-core 1.1.0.beta3 → 1.2.0.beta1

data/lib/bridgetown-core/generated_page.rb

@@ -65,6 +65,11 @@ module Bridgetown
       data[property]
     end
 
+    # @return [Array<Bridgetown::Slot>]
+    def slots
+      @slots ||= []
+    end
+
     # The generated directory into which the page will be placed
     # upon generation. This is derived from the permalink or, if
     # permalink is absent, will be '/'

data/lib/bridgetown-core/helpers.rb

@@ -14,6 +14,8 @@ module Bridgetown
 
       Context = Struct.new(:registers)
 
+      # @param view [Bridgetown::RubyTemplateView]
+      # @param site [Bridgetown::Site]
       def initialize(view, site)
         @view = view
         @site = site
@@ -96,23 +98,35 @@ module Bridgetown
       # @return [String] the anchor tag HTML
       # @raise [ArgumentError] if the file cannot be found
       def link_to(text, relative_path, options = {})
+        segments = attributes_from_options({ href: url_for(relative_path) }.merge(options))
+
+        safe("<a #{segments}>#{text}</a>")
+      end
+
+      # Create a set of attributes from a hash.
+      #
+      # @param options [Hash] key-value pairs of HTML attributes
+      # @return [String]
+      def attributes_from_options(options)
         segments = []
-        segments << "a"
-        segments << "href=\"#{url_for(relative_path)}\""
         options.each do |attr, option|
-          attr = attr.to_s.tr("_", "-")
-          segments << "#{attr}=\"#{Utils.xml_escape(option)}\""
+          attr = dashed(attr)
+          if option.is_a?(Hash)
+            option = option.transform_keys { |key| "#{attr}-#{dashed(key)}" }
+            segments << attributes_from_options(option)
+          else
+            segments << attribute_segment(attr, option)
+          end
         end
-        # TODO: this might leak an XSS string into text, need to check
-        safe("<#{segments.join(" ")}>#{text}</a>")
+        safe(segments.join(" "))
       end
 
       # Forward all arguments to I18n.t method
       #
       # @return [String] the translated string
       # @see I18n
-      def t(*args)
-        I18n.send :t, *args
+      def t(*args, **kwargs)
+        I18n.send :t, *args, **kwargs
       end
 
       # For template contexts where ActiveSupport's output safety is loaded, we
@@ -124,6 +138,103 @@ module Bridgetown
         input.to_s.html_safe
       end
       alias_method :raw, :safe
+
+      # Define a new content slot
+      #
+      # @param name [String, Symbol] name of the slot
+      # @param input [String] content if not supplying a block
+      # @param replace [Boolean] set to true to replace any previously defined slot with same name
+      # @param transform [Boolean] set to false to avoid template-based transforms (Markdown, etc.)
+      # @return [void]
+      def slot(name, input = nil, replace: false, transform: true, &block)
+        content = Bridgetown::Utils.reindent_for_markdown(
+          block.nil? ? input.to_s : view.capture(&block)
+        )
+
+        resource = if view.respond_to?(:resource)
+                     # We're in a resource rendering context
+                     view.resource
+                   elsif view.respond_to?(:view_context)
+                     # We're in a component rendering context, although it's
+                     # likely the component's own `slot` method will be called
+                     # in this context
+                     view.view_context.resource
+                   end
+
+        name = name.to_s
+        resource.slots.reject! { _1.name == name } if replace
+        resource.slots << Slot.new(
+          name: name,
+          content: content,
+          context: resource,
+          transform: transform
+        )
+
+        nil
+      end
+
+      # Render out a content slot
+      #
+      # @param name [String, Symbol] name of the slot
+      # @param input [String] default content if slot isn't defined and no block provided
+      # @return [String]
+      def slotted(name, default_input = nil, &default_block) # rubocop:todo Metrics
+        resource = if view.respond_to?(:resource)
+                     view.resource
+                   elsif view.respond_to?(:view_context)
+                     view.view_context.resource
+                   end
+
+        return unless resource
+
+        name = name.to_s
+        filtered_slots = resource.slots.select do |slot|
+          slot.name == name
+        end
+
+        return filtered_slots.map(&:content).join.html_safe if filtered_slots.length.positive?
+
+        default_block.nil? ? default_input.to_s : view.capture(&default_block)
+      end
+
+      # Check if a content slot has been defined
+      #
+      # @return [Boolean]
+      def slotted?(name)
+        resource = if view.respond_to?(:resource)
+                     view.resource
+                   elsif view.respond_to?(:view_context)
+                     view.view_context.resource
+                   end
+
+        return unless resource
+
+        name = name.to_s
+        resource.slots.any? do |slot|
+          slot.name == name
+        end
+      end
+
+      private
+
+      # Covert an underscored value into a dashed string.
+      #
+      # @example "foo_bar_baz" => "foo-bar-baz"
+      #
+      # @param value [String|Symbol]
+      # @return [String]
+      def dashed(value)
+        value.to_s.tr("_", "-")
+      end
+
+      # Create an attribute segment for a tag.
+      #
+      # @param attr [String] the HTML attribute name
+      # @param value [String] the attribute value
+      # @return [String]
+      def attribute_segment(attr, value)
+        "#{attr}=\"#{Utils.xml_escape(value)}\""
+      end
     end
   end
 end

data/lib/bridgetown-core/hooks.rb

@@ -70,6 +70,7 @@ module Bridgetown
     # @yield the block will be called when the event is triggered. Typically it receives at
     #   least one argument.
     # @yieldparam obj the object which triggered the event hook
+    # @return [Proc] the block that was pased in
     def self.register_one(owner, event, priority: DEFAULT_PRIORITY, reloadable: true, &block)
       @registry[owner] ||= []
 

data/lib/bridgetown-core/kramdown/parser/gfm.rb

@@ -1,4 +1,4 @@
-# Frozen-string-literal: true
+# frozen_string_literal: true
 
 require "kramdown-parser-gfm"
 

data/lib/bridgetown-core/layout.rb

@@ -92,7 +92,7 @@ module Bridgetown
 
     # Returns the contents as a String.
     def to_s
-      output || content || ""
+      content || ""
     end
 
     # Accessor for data properties by Liquid.

data/lib/bridgetown-core/model/base.rb

@@ -10,16 +10,14 @@ module Bridgetown
       define_model_callbacks :load, :save, :destroy
 
       class << self
-        def find(id)
-          unless Bridgetown::Current.site
-            raise "A Bridgetown site must be initialized and added to Current"
-          end
+        def find(id, site: Bridgetown::Current.site)
+          raise "A Bridgetown site must be initialized and added to Current" unless site
 
-          origin = origin_for_id(id)
+          origin = origin_for_id(id, site: site)
           klass_for_id(id, origin: origin).new(origin.read)
         end
 
-        def origin_for_id(id)
+        def origin_for_id(id, site: Bridgetown::Current.site)
           scheme = URI.parse(id).scheme
           origin_klass = Origin.descendants.find do |klass|
             klass.handle_scheme?(scheme)
@@ -27,7 +25,7 @@ module Bridgetown
 
           raise "No origin could be found for #{id}" unless origin_klass
 
-          origin_klass.new(id)
+          origin_klass.new(id, site: site)
         end
 
         def klass_for_id(id, origin: nil)
@@ -40,14 +38,15 @@ module Bridgetown
           origin ||= origin_for_id(id)
           origin.verify_model?(self)
         end
-      end
 
-      class << self
+        # @param builder [Bridgetown::Builder]
         def build(builder, collection_name, path, data)
+          site = builder.site
           data = Bridgetown::Model::BuilderOrigin.new(
-            Bridgetown::Model::BuilderOrigin.id_for_builder_path(builder, path)
+            Bridgetown::Model::BuilderOrigin.id_for_builder_path(builder, path),
+            site: site
           ).read do
-            data[:_collection_] = Bridgetown::Current.site.collections[collection_name]
+            data[:_collection_] = site.collections[collection_name]
             data
           end
           new(data)
@@ -106,7 +105,7 @@ module Bridgetown
       # override if need be
       # @return [Bridgetown::Site]
       def site
-        Bridgetown::Current.site
+        origin.site
       end
 
       # @return [Bridgetown::Collection]

data/lib/bridgetown-core/model/builder_origin.rb

@@ -16,7 +16,7 @@ module Bridgetown
         end
       end
 
-      def initialize(id)
+      def initialize(id, site: Bridgetown::Current.site)
         super
         @relative_path = Pathname.new(url.path.delete_prefix("/"))
       end

data/lib/bridgetown-core/model/origin.rb

@@ -11,13 +11,17 @@ module Bridgetown
       # @return [String]
       attr_accessor :id
 
+      # @return [Bridgetown::Site]
+      attr_accessor :site
+
       # You must implement in subclasses
       def self.handle_scheme?(_scheme)
         false
       end
 
-      def initialize(id)
+      def initialize(id, site: Bridgetown::Current.site)
         self.id = id
+        self.site = site
       end
 
       # You can override in subclass

data/lib/bridgetown-core/model/plugin_origin.rb

@@ -12,7 +12,7 @@ module Bridgetown
       def manifest
         @manifest ||= begin
           manifest_origin = Addressable::URI.unescape(url.path.delete_prefix("/")).split("/").first
-          Bridgetown::PluginManager.source_manifests.find do |manifest|
+          site.config.source_manifests.find do |manifest|
             manifest.origin.to_s == manifest_origin
           end.tap do |manifest|
             raise "Unable to locate a source manifest for #{manifest_origin}" unless manifest

data/lib/bridgetown-core/model/repo_origin.rb

@@ -32,10 +32,10 @@ module Bridgetown
         # @param collection [Bridgetown::Collection, String, Symbol] either a collection
         #   label or Collection object
         # @param relative_path [Pathname, String] the source path of the file to save
-        def new_with_collection_path(collection, relative_path)
+        def new_with_collection_path(collection, relative_path, site: Bridgetown::Current.site)
           collection = collection.label if collection.is_a?(Bridgetown::Collection)
 
-          new("repo://#{collection}.collection/#{relative_path}")
+          new("repo://#{collection}.collection/#{relative_path}", site: site)
         end
       end
 
@@ -93,11 +93,11 @@ module Bridgetown
                           else
                             "pages"
                           end
-        @collection = Bridgetown::Current.site.collections[collection_name]
+        @collection = site.collections[collection_name]
       end
 
       def original_path
-        @original_path ||= relative_path.expand_path(Bridgetown::Current.site.source)
+        @original_path ||= relative_path.expand_path(site.source)
       end
 
       def exists?
@@ -118,7 +118,7 @@ module Bridgetown
             rows:
               CSV.read(original_path,
                        headers: true,
-                       encoding: Bridgetown::Current.site.config["encoding"]).map(&:to_hash),
+                       encoding: site.config["encoding"]).map(&:to_hash),
           }
         when ".tsv"
           {
@@ -126,7 +126,7 @@ module Bridgetown
               CSV.read(original_path,
                        col_sep: "\t",
                        headers: true,
-                       encoding: Bridgetown::Current.site.config["encoding"]).map(&:to_hash),
+                       encoding: site.config["encoding"]).map(&:to_hash),
           }
         when ".rb"
           process_ruby_data(File.read(original_path), original_path, 1)
@@ -145,7 +145,7 @@ module Bridgetown
                                   "could not read file #{original_path}: #{error.message}"
         end
 
-        if Bridgetown::Current.site.config["strict_front_matter"] ||
+        if site.config["strict_front_matter"] ||
             error.is_a?(Bridgetown::Errors::FatalException)
           raise error
         end

data/lib/bridgetown-core/plugin.rb

@@ -13,13 +13,9 @@ module Bridgetown
       lowest: -100,
     }.freeze
 
-    SourceManifest = Struct.new(:origin, :components, :content, :layouts, keyword_init: true)
-
-    # Initialize a new plugin. This should be overridden by the subclass.
-    #
-    # config - The Hash of configuration options.
+    # Initialize a new plugin. This should be overridden by the subclass (generator or converter)
     #
-    # Returns a new instance.
+    # @param config [Bridgetown::Configuration] the configuration for the site
     def initialize(config = {}) # rubocop:disable Style/RedundantInitialize
       # no-op for default
     end

data/lib/bridgetown-core/plugin_manager.rb

@@ -2,24 +2,42 @@
 
 module Bridgetown
   class PluginManager
-    PLUGINS_GROUP = :bridgetown_plugins
+    LEGACY_PLUGINS_GROUP = :bridgetown_plugins
     YARN_DEPENDENCY_REGEXP = %r!(.+)@([^@]*)$!.freeze
 
     attr_reader :site, :loaders_manager
 
-    @source_manifests = Set.new
     @registered_plugins = Set.new
 
+    # @param source_manifest [Bridgetown::Configuration::SourceManifest]
     def self.add_source_manifest(source_manifest)
-      unless source_manifest.is_a?(Bridgetown::Plugin::SourceManifest)
+      unless source_manifest.is_a?(Bridgetown::Configuration::SourceManifest)
         raise "You must add a SourceManifest instance"
       end
 
-      @source_manifests << source_manifest
+      unless Bridgetown::Current.preloaded_configuration
+        raise "A preloaded configuration must be present before adding source manifests"
+      end
+
+      Bridgetown::Deprecator.deprecation_message(
+        "The #{source_manifest.origin} plugin should switch from using `add_source_manifest' to " \
+        "the `source_manifest` initializer method"
+      )
+
+      Bridgetown::Current.preloaded_configuration.source_manifests << source_manifest
     end
 
-    def self.new_source_manifest(*args, **kwargs)
-      add_source_manifest(Bridgetown::Plugin::SourceManifest.new(*args, **kwargs))
+    def self.new_source_manifest(*_args, **kwargs)
+      unless Bridgetown::Current.preloaded_configuration
+        raise "A preloaded configuration must be present before adding source manifests"
+      end
+
+      Bridgetown::Deprecator.deprecation_message(
+        "The #{kwargs[:origin]} plugin should switch from using `new_source_manifest' to the " \
+        "`source_manifest` initializer method"
+      )
+
+      add_source_manifest(Bridgetown::Configuration::SourceManifest.new(**kwargs))
     end
 
     def self.add_registered_plugin(gem_or_plugin_file)
@@ -27,56 +45,101 @@ module Bridgetown
     end
 
     class << self
-      attr_reader :source_manifests, :registered_plugins
-    end
+      attr_reader :registered_plugins
 
-    # Create an instance of this class.
-    #
-    # site - the instance of Bridgetown::Site we're concerned with
-    #
-    # Returns nothing
-    def initialize(site)
-      @site = site
-      @loaders_manager = Bridgetown::Utils::LoadersManager.new(site.config)
+      def bundler_specs
+        @bundler_specs ||= Bundler.load.requested_specs
+      end
+
+      def source_manifests
+        Bridgetown::Deprecator.deprecation_message(
+          "Use the configuration's `source_manifests` method instead of the plugin manager"
+        )
+
+        Bridgetown::Current.preloaded_configuration.source_manifests
+      end
     end
 
-    def self.require_from_bundler(skip_yarn: false) # rubocop:todo Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-      # NOTE: investigate why this ENV var is really necessary
+    def self.setup_bundler(skip_yarn: false)
       if !ENV["BRIDGETOWN_NO_BUNDLER_REQUIRE"] && File.file?("Gemfile")
         require "bundler"
 
-        required_gems = Bundler.require(PLUGINS_GROUP).select do |dep|
-          (dep.groups & [PLUGINS_GROUP]).any? && dep.should_include?
-        end
-
-        install_yarn_dependencies(required_gems) unless skip_yarn
+        require_relative "utils/initializers"
+        load_determined_bundler_environment(skip_yarn: skip_yarn)
 
-        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
       else
         false
       end
     end
+    class << self
+      alias_method :require_from_bundler, :setup_bundler
+    end
 
-    # Iterates through loaded plugins and finds yard-add gemspec metadata.
+    def self.load_determined_bundler_environment(skip_yarn: false)
+      boot_file = File.join("config", "boot.rb")
+
+      if File.file?(boot_file)
+        # We'll let config/boot.rb take care of Bundler setup
+        require File.expand_path(boot_file)
+      elsif File.file?(File.join("config", "initializers.rb"))
+        # We'll just make sure the default and environmental gems are available.
+        # Note: the default Bundler config will set up all gem groups,
+        #   see: https://bundler.io/guides/groups.html
+        Bundler.setup(:default, Bridgetown.env)
+      else
+        # Only setup and require :bridgetown_plugins
+        legacy_yarn_and_register(legacy_require, skip_yarn: skip_yarn)
+      end
+    end
+
+    def self.require_gem(name)
+      Bridgetown::Utils::RequireGems.require_with_graceful_fail(name)
+      plugins = Bridgetown::PluginManager.install_yarn_dependencies(name: name)
+
+      plugin_to_register = if plugins.length == 1
+                             plugins.first
+                           else
+                             bundler_specs.find do |loaded_gem|
+                               loaded_gem.to_spec&.name == name.to_s
+                             end
+                           end
+      add_registered_plugin plugin_to_register
+
+      Bridgetown.logger.debug("PluginManager:",
+                              "Registered #{plugin_to_register.name}")
+    end
+
+    def self.legacy_require
+      Bundler.require(LEGACY_PLUGINS_GROUP).select do |dep|
+        (dep.groups & [LEGACY_PLUGINS_GROUP]).any? && dep.should_include?
+      end
+    end
+
+    def self.legacy_yarn_and_register(required_gems, skip_yarn: false)
+      install_yarn_dependencies(required_gems) unless skip_yarn
+
+      required_gems.each do |installed_gem|
+        add_registered_plugin installed_gem
+      end
+
+      Bridgetown.logger.debug("PluginManager:",
+                              "Required #{required_gems.map(&:name).join(", ")}")
+    end
+
+    # Iterates through loaded gems and finds yard-add gemspec metadata.
     # If that exact package hasn't been installed, execute yarn add
     #
-    # Returns nothing.
-    def self.install_yarn_dependencies(required_gems, single_gemname = nil)
-      return unless File.exist?("package.json")
+    # @return [Bundler::SpecSet]
+    def self.install_yarn_dependencies(required_gems = bundler_specs, name: nil)
+      return required_gems unless File.exist?("package.json")
 
       package_json = JSON.parse(File.read("package.json"))
 
-      gems_to_search = if single_gemname
+      gems_to_search = if name
                          required_gems.select do |loaded_gem|
-                           loaded_gem.to_spec&.name == single_gemname.to_s
+                           loaded_gem.to_spec&.name == name.to_s
                          end
                        else
                          required_gems
@@ -90,6 +153,8 @@ module Bridgetown
         cmd = "yarn add #{yarn_dependency.join("@")}"
         system cmd
       end
+
+      gems_to_search
     end
 
     def self.find_yarn_dependency(loaded_gem)
@@ -115,9 +180,16 @@ module Bridgetown
       current_version.nil? || (current_version != dep_version && !current_version.include?("/"))
     end
 
-    # Require all .rb files
+    # Provides a plugin manager for the site
+    #
+    # @param site [Bridgetown::Site]
+    def initialize(site)
+      @site = site
+    end
+
+    # Finds and registers plugins in the local folder(s)
     #
-    # Returns nothing.
+    # @return [void]
     def require_plugin_files
       plugins_path.each do |plugin_search_path|
         plugin_files = Utils.safe_glob(plugin_search_path, File.join("**", "*.rb"))
@@ -135,11 +207,18 @@ module Bridgetown
         end
         next if site.config[:plugins_use_zeitwerk]
 
+        Deprecator.deprecation_message(
+          "The `plugins_use_zeitwerk' configuration option will be removed in the next version " \
+          "of Bridgetown (aka will be permanently set to \"true\")"
+        )
         Bridgetown::Utils::RequireGems.require_with_graceful_fail(sorted_plugin_files)
       end
     end
 
-    # Reload .rb plugin files via the watcher
+    # Reloads .rb plugin files via the watcher
+    # DEPRECATED (not necessary with Zeitwerk)
+    #
+    # @return [void]
     def reload_plugin_files
       return if site.config[:plugins_use_zeitwerk]
 
@@ -153,9 +232,9 @@ module Bridgetown
       end
     end
 
-    # Public: Setup the plugin search path
+    # Expands the path(s) of the plugins_dir config value
     #
-    # Returns an Array of plugin search paths
+    # @return [Array<String>] one or more plugin search paths
     def plugins_path
       if site.config["plugins_dir"].eql? Bridgetown::Configuration::DEFAULTS["plugins_dir"]
         [site.in_root_dir(site.config["plugins_dir"])]

data/lib/bridgetown-core/rack/boot.rb

@@ -22,19 +22,16 @@ module Bridgetown
     # Start up the Roda Rack application and the Zeitwerk autoloaders. Ensure the
     # Roda app is provided the preloaded Bridgetown site configuration. Handle
     # any uncaught Roda errors.
-    #
-    # @param [Bridgetown::Rack::Roda] optional, defaults to the `RodaApp` constant
-    def self.boot(roda_app = nil)
+    def self.boot(*)
       self.loaders_manager =
         Bridgetown::Utils::LoadersManager.new(Bridgetown::Current.preloaded_configuration)
+      Bridgetown::Current.preloaded_configuration.run_initializers! context: :server
       autoload_server_folder
-      (roda_app || RodaApp).opts[:bridgetown_preloaded_config] =
-        Bridgetown::Current.preloaded_configuration
     rescue Roda::RodaError => e
       if e.message.include?("sessions plugin :secret option")
         raise Bridgetown::Errors::InvalidConfigurationError,
               "The Roda sessions plugin can't find a valid secret. Run `bin/bridgetown secret' " \
-              "and put the key in a ENV var you can use to configure the session in `roda_app.rb'"
+              "and put the key in a ENV var you can use to configure the session in the Roda app"
       end
 
       raise e
@@ -45,7 +42,6 @@ module Bridgetown
       root: Bridgetown::Current.preloaded_configuration.root_dir
     )
       server_folder = File.join(root, "server")
-      #      Bridgetown::Current.preloaded_configuration.autoload_paths << server_folder
 
       Bridgetown::Hooks.register_one(
         :loader, :post_setup, reloadable: false

data/lib/bridgetown-core/rack/logger.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "logger"
+require "bridgetown-core/log_writer"
 
 module Bridgetown
   module Rack