bridgetown-core 0.17.1 → 0.18.0

data/lib/bridgetown-core/helpers.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  class RubyTemplateView
+    class Helpers
+      include Bridgetown::Filters
+
+      attr_reader :view, :site
+
+      Context = Struct.new(:registers)
+
+      def initialize(view, site)
+        @view = view
+        @site = site
+
+        # duck typing for Liquid context
+        @context = Context.new({ site: site })
+      end
+
+      def webpack_path(asset_type)
+        Bridgetown::Utils.parse_webpack_manifest_file(site, asset_type.to_s)
+      end
+
+      # @param pairs [Hash] A hash of key/value pairs.
+      #
+      # @return [String] Space-separated keys where the values are truthy.
+      def class_map(pairs = {})
+        pairs.select { |_key, truthy| truthy }.keys.join(" ")
+      end
+
+      # This helper will generate the correct permalink URL for the file path.
+      #
+      # @param relative_path [String, Object] source file path, e.g.
+      #   "_posts/2020-10-20-my-post.md", or object that responds to `url`
+      # @return [String] the permalink URL for the file
+      # @raise [ArgumentError] if the file cannot be found
+      def url_for(relative_path)
+        path_string = !relative_path.is_a?(String) ? relative_path.url : relative_path
+
+        return path_string if path_string.start_with?("/", "http")
+
+        site.each_site_file do |item|
+          if item.relative_path == path_string || item.relative_path == "/#{path_string}"
+            return relative_url(item)
+          end
+        end
+
+        raise ArgumentError, <<~MSG
+          Could not find document '#{relative_path}' in 'url_for' helper.
+
+          Make sure the document exists and the path is correct.
+        MSG
+      end
+      alias_method :link, :url_for
+
+      # This helper will generate the correct permalink URL for the file path.
+      #
+      # @param text [String] the content inside the anchor tag
+      # @param relative_path [String, Object] source file path, e.g.
+      #   "_posts/2020-10-20-my-post.md", or object that responds to `url`
+      # @param options [Hash] key-value pairs of HTML attributes to add to the tag
+      # @return [String] the anchor tag HTML
+      # @raise [ArgumentError] if the file cannot be found
+      def link_to(text, relative_path, 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)}\""
+        end
+        "<#{segments.join(" ")}>#{text}</a>"
+      end
+
+      # Forward all arguments to I18n.t method
+      #
+      # @return [String] the translated string
+      # @see I18n
+      def t(*args)
+        I18n.send :t, *args
+      end
+    end
+  end
+end

data/lib/bridgetown-core/liquid_renderer.rb

@@ -26,7 +26,7 @@ module Bridgetown
     def reset
       @stats = {}
       @cache = {}
-      Renderer.cached_partials = {}
+      Bridgetown::Converters::LiquidTemplates.cached_partials = {}
     end
 
     def file(filename)

data/lib/bridgetown-core/log_writer.rb

@@ -33,12 +33,12 @@ module Bridgetown
       true
     end
 
-    # Log a +WARN+ message
+    # Log a `WARN` message
     def warn(progname = nil, &block)
       add(WARN, nil, progname.yellow, &block)
     end
 
-    # Log an +ERROR+ message
+    # Log an `ERROR` message
     def error(progname = nil, &block)
       add(ERROR, nil, progname.red, &block)
     end

data/lib/bridgetown-core/plugin_manager.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
+require "zeitwerk"
+
 module Bridgetown
   class PluginManager
     PLUGINS_GROUP = :bridgetown_plugins
     YARN_DEPENDENCY_REGEXP = %r!(.+)@([^@]*)$!.freeze
 
-    attr_reader :site
+    attr_reader :site, :component_loaders
 
     @source_manifests = Set.new
     @registered_plugins = Set.new
@@ -37,6 +39,7 @@ module Bridgetown
     # Returns nothing
     def initialize(site)
       @site = site
+      @component_loaders = {}
     end
 
     def self.require_from_bundler
@@ -158,5 +161,35 @@ module Bridgetown
         Array(site.config["plugins_dir"]).map { |d| File.expand_path(d) }
       end
     end
+
+    # rubocop:disable Metrics/AbcSize
+    def setup_component_loaders
+      unless @component_loaders.keys.empty?
+        @component_loaders.each do |_path, loader|
+          loader.unload
+        end
+        @component_loaders = {}
+      end
+
+      # Because "first constant wins" in Zeitwerk, we need to load the local
+      # source components _before_ we load any from plugins
+      site.components_load_paths.reverse_each do |load_path|
+        next unless Dir.exist? load_path
+        next if Zeitwerk::Registry.loaders.find { |loader| loader.manages?(load_path) }
+
+        @component_loaders[load_path] = Zeitwerk::Loader.new
+        @component_loaders[load_path].push_dir(load_path)
+        @component_loaders[load_path].enable_reloading if load_path.start_with?(site.root_dir)
+        @component_loaders[load_path].ignore(File.join(load_path, "**", "*.js.rb"))
+        @component_loaders[load_path].setup
+      end
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def reload_component_loaders
+      @component_loaders.each do |path, loader|
+        loader.reload if path.start_with?(site.root_dir)
+      end
+    end
   end
 end

data/lib/bridgetown-core/reader.rb

@@ -76,10 +76,7 @@ module Bridgetown
     def retrieve_posts(dir)
       return if outside_configured_directory?(dir)
 
-      post_reader.read_posts(dir).tap do |entries|
-        site.posts.docs.concat(entries.select { |entry| entry.is_a?(Document) })
-        site.posts.files.concat(entries.select { |entry| entry.is_a?(StaticFile) })
-      end
+      post_reader.read_posts(dir)
     end
 
     # Recursively traverse directories with the read_directories function.

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

@@ -21,13 +21,13 @@ module Bridgetown
     # Read all the files in <source>/<dir>/<magic_dir> and create a new
     # Document object with each one insofar as it matches the regexp matcher.
     #
-    # dir - The String relative path of the directory to read.
+    # @param dir [String] relative path of the directory to read.
     #
-    # Returns nothing.
+    # @return [Array<Document, StaticFile>]
     def read_publishable(dir, magic_dir, matcher)
       read_content(dir, magic_dir, matcher)
-        .tap { |entries| entries.select { |entry| entry.respond_to?(:read) }.each(&:read) }
-        .select { |entry| processable?(entry) }
+        .tap { |items| items.select { |item| item.respond_to?(:read) }.each(&:read) }
+        .select { |item| item_added_to_site?(item) }
     end
 
     # Read all the content files from <source>/<dir>/magic_dir
@@ -70,26 +70,39 @@ module Bridgetown
       )
     end
 
-    def processable?(doc)
-      return true if doc.is_a?(StaticFile)
+    def processable?(item)
+      return true if item.is_a?(StaticFile)
 
-      if doc.content.nil?
-        Bridgetown.logger.debug "Skipping:", "Content in #{doc.relative_path} is nil"
+      if item.content.nil?
+        Bridgetown.logger.debug "Skipping:", "Content in #{item.relative_path} is nil"
         false
-      elsif !doc.content.valid_encoding?
-        Bridgetown.logger.debug "Skipping:", "#{doc.relative_path} is not valid UTF-8"
+      elsif !item.content.valid_encoding?
+        Bridgetown.logger.debug "Skipping:", "#{item.relative_path} is not valid UTF-8"
         false
       else
-        publishable?(doc)
+        publishable?(item)
       end
     end
 
-    def publishable?(doc)
-      site.publisher.publish?(doc).tap do |will_publish|
-        if !will_publish && site.publisher.hidden_in_the_future?(doc)
-          Bridgetown.logger.warn "Skipping:", "#{doc.relative_path} has a future date"
+    def publishable?(item)
+      site.publisher.publish?(item).tap do |will_publish|
+        if !will_publish && site.publisher.hidden_in_the_future?(item)
+          Bridgetown.logger.warn "Skipping:", "#{item.relative_path} has a future date"
         end
       end
     end
+
+    def item_added_to_site?(item)
+      return false unless processable?(item)
+
+      if item.is_a?(Document)
+        site.posts.docs << item
+      elsif item.is_a?(StaticFile)
+        site.posts.files << item
+        site.static_files << item
+      end
+
+      true
+    end
   end
 end

data/lib/bridgetown-core/renderer.rb

@@ -3,37 +3,10 @@
 module Bridgetown
   class Renderer
     attr_reader :document, :site
-    attr_writer :layouts, :payload
 
-    class << self
-      attr_accessor :cached_partials
-    end
-
-    def initialize(site, document, site_payload = nil)
+    def initialize(site, document)
       @site     = site
       @document = document
-      @payload  = site_payload
-      @layouts  = nil
-      self.class.cached_partials ||= {}
-    end
-
-    # Fetches the payload used in Liquid rendering.
-    # It can be written with #payload=(new_payload)
-    # Falls back to site.site_payload if no payload is set.
-    #
-    # Returns a Bridgetown::Drops::UnifiedPayloadDrop
-    def payload
-      @payload ||= site.site_payload
-    end
-
-    # The list of layouts registered for this Renderer.
-    # It can be written with #layouts=(new_layouts)
-    # Falls back to site.layouts if no layouts are registered.
-    #
-    # Returns a Hash of String => Bridgetown::Layout identified
-    # as basename without the extension name.
-    def layouts
-      @layouts || site.layouts
     end
 
     # Determine which converters to use based on this document's
@@ -41,7 +14,13 @@ module Bridgetown
     #
     # Returns Array of Converter instances.
     def converters
-      @converters ||= site.converters.select { |c| c.matches(document.extname) }.sort
+      @converters ||= site.converters.select do |converter|
+        if converter.method(:matches).arity == 1
+          converter.matches(document.extname)
+        else
+          converter.matches(document.extname, document)
+        end
+      end.sort
     end
 
     # Determine the extname the outputted file should have
@@ -51,93 +30,42 @@ module Bridgetown
       @output_ext ||= (permalink_ext || converter_output_ext)
     end
 
-    # Prepare payload and render the document
+    # Run hooks and render the document
     #
     # Returns nothing
     def run
       Bridgetown.logger.debug "Rendering:", document.relative_path
 
-      assign_pages!
-      # TODO: this can be eliminated I think:
-      assign_current_document!
-      assign_highlighter_options!
-      assign_layout_data!
-
-      document.trigger_hooks(:pre_render, payload)
+      document.trigger_hooks :pre_render
       document.output = render_document
-      document.trigger_hooks(:post_render)
+      document.trigger_hooks :post_render
     end
 
     # Render the document.
     #
     # Returns String rendered document output
-    # rubocop: disable Metrics/AbcSize
     def render_document
-      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, liquid_context, document.path)
-      end
-
       Bridgetown.logger.debug "Rendering Markup:", document.relative_path
       output = convert(output.to_s, document)
       document.content = output
 
       if document.place_in_layout?
         Bridgetown.logger.debug "Rendering Layout:", document.relative_path
-        output = place_in_layouts(output, payload, liquid_context)
+        output = place_in_layouts(output)
       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?
 
       Bridgetown::Utils::RubyExec.search_data_for_ruby_code(document, self)
     end
 
-    # rubocop: enable Metrics/AbcSize
-
-    # Render the given content with the payload and context
-    #
-    # content -
-    # payload -
-    # context    -
-    # path    - (optional) the path to the file, for use in ex
-    #
-    # Returns String the content, rendered by Liquid.
-    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, liquid_context)
-    # rubocop: disable Lint/RescueException
-    rescue Exception => e
-      Bridgetown.logger.error "Liquid Exception:",
-                              LiquidRenderer.format_error(e, path || document.relative_path)
-      raise e
-    end
-    # rubocop: enable Lint/RescueException
-
     # Convert the document using the converters which match this renderer's document.
     #
     # Returns String the converted content.
@@ -157,30 +85,18 @@ module Bridgetown
       end
     end
 
-    # Checks if the layout specified in the document actually exists
-    #
-    # layout - the layout to check
-    #
-    # Returns Boolean true if the layout is invalid, false if otherwise
-    def invalid_layout?(layout)
-      !document.data["layout"].nil? && layout.nil? && !(document.is_a? Bridgetown::Excerpt)
-    end
-
     # Render layouts and place document content inside.
     #
     # Returns String rendered content
-    def place_in_layouts(content, payload, liquid_context)
+    def place_in_layouts(content)
       output = content.dup
-      layout = layouts[document.data["layout"].to_s]
+      layout = site.layouts[document.data["layout"]]
       validate_layout(layout)
 
       used = Set.new([layout])
 
-      # Reset the payload layout data to ensure it starts fresh for each page.
-      payload["layout"] = nil
-
       while layout
-        output = render_layout(output, layout, liquid_context)
+        output = render_layout(output, layout)
         add_regenerator_dependencies(layout)
 
         next unless (layout = site.layouts[layout.data["layout"]])
@@ -198,47 +114,45 @@ module Bridgetown
     # layout - the layout to check
     # Returns nothing
     def validate_layout(layout)
-      return unless invalid_layout?(layout)
+      return unless document.data["layout"].present? &&
+        layout.nil? &&
+        !(document.is_a? Bridgetown::Excerpt)
 
       Bridgetown.logger.warn "Build Warning:", "Layout '#{document.data["layout"]}' requested " \
         "in #{document.relative_path} does not exist."
     end
 
+    def converters_for_layout(layout)
+      site.converters.select do |converter|
+        if converter.method(:matches).arity == 1
+          converter.matches(layout.ext)
+        else
+          converter.matches(layout.ext, layout)
+        end
+      end.sort
+    end
+
     # Render layout content into document.output
     #
     # Returns String rendered content
-    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-    def render_layout(output, layout, liquid_context)
-      if layout.render_with_liquid?
-        payload["content"] = output
-        payload["layout"]  = Utils.deep_merge_hashes(layout.data, payload["layout"] || {})
+    def render_layout(output, layout)
+      layout_converters = converters_for_layout(layout)
 
-        render_liquid(
-          layout.content,
-          payload,
-          liquid_context,
-          layout.path
-        )
-      else
-        layout_converters ||= site.converters.select { |c| c.matches(layout.ext) }.sort
-
-        layout_content = layout.content.dup
-        layout_converters.reduce(layout_content) do |layout_output, converter|
-          next(layout_output) unless converter.method(:convert).arity == 2
+      layout_content = layout.content.dup
+      layout_converters.reduce(layout_content) do |layout_output, converter|
+        next(layout_output) unless converter.method(:convert).arity == 2
 
-          layout.current_document = document
-          layout.current_document_output = output
-          converter.convert layout_output, layout
-        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
+        layout.current_document = document
+        layout.current_document_output = output
+        converter.convert layout_output, layout
       end
+    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
-    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
     def add_regenerator_dependencies(layout)
       return unless document.write?
@@ -249,34 +163,6 @@ module Bridgetown
       )
     end
 
-    # Set page content to payload and assign paginator if document has one.
-    #
-    # Returns nothing
-    def assign_pages!
-      payload["page"] = document.to_liquid
-      payload["paginator"] = document.paginator.to_liquid if document.respond_to?(:paginator)
-    end
-
-    # Set related posts to payload if document is a post.
-    #
-    # Returns nothing
-    def assign_current_document!
-      payload["site"].current_document = document
-    end
-
-    # Set highlighter prefix and suffix
-    #
-    # Returns nothing
-    def assign_highlighter_options!
-      payload["highlighter_prefix"] = converters.first.highlighter_prefix
-      payload["highlighter_suffix"] = converters.first.highlighter_suffix
-    end
-
-    def assign_layout_data!
-      layout = layouts[document.data["layout"]]
-      payload["layout"] = Utils.deep_merge_hashes(layout.data, payload["layout"] || {}) if layout
-    end
-
     def permalink_ext
       document_permalink = document.permalink
       if document_permalink && !document_permalink.end_with?("/")
@@ -298,9 +184,5 @@ module Bridgetown
         c.output_ext(document.extname)
       end.compact
     end
-
-    def liquid_options
-      @liquid_options ||= site.config["liquid"]
-    end
   end
 end