bridgetown-core 0.16.0 → 0.18.2

data/lib/bridgetown-core/frontmatter_defaults.rb

@@ -54,6 +54,10 @@ module Bridgetown
     #
     # Returns the default value or nil if none was found
     def find(path, type, setting)
+      merged_data = {}
+      merge_data_cascade_for_path(path, merged_data)
+      return merged_data[setting] if merged_data.key?(setting)
+
       value = nil
       old_scope = nil
 
@@ -74,6 +78,9 @@ module Bridgetown
     # Returns a hash with all default values (an empty hash if there are none)
     def all(path, type)
       defaults = {}
+
+      merge_data_cascade_for_path(path, defaults)
+
       old_scope = nil
       matching_sets(path, type).each do |set|
         if has_precedence?(old_scope, set["scope"])
@@ -88,6 +95,16 @@ module Bridgetown
 
     private
 
+    def merge_data_cascade_for_path(path, merged_data)
+      absolute_path = @site.in_source_dir(path)
+      @site.defaults_reader.path_defaults
+        .select { |k, _v| absolute_path.include? k }
+        .sort_by { |k, _v| k.length }
+        .each do |defaults|
+          merged_data.merge!(defaults[1])
+        end
+    end
+
     # Checks if a given default setting scope matches the given path and type
     #
     # scope - the hash indicating the scope, as defined in bridgetown.config.yml

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

@@ -10,6 +10,9 @@ module Bridgetown
   class PrototypeGenerator < Generator
     priority :low
 
+    # @return [Bridgetown::Site]
+    attr_reader :site
+
     @matching_templates = []
 
     def self.add_matching_template(template)
@@ -17,6 +20,7 @@ module Bridgetown
     end
 
     class << self
+      # @return [Array<Page>]
       attr_reader :matching_templates
     end
 
@@ -44,7 +48,13 @@ module Bridgetown
       end
     end
 
+    # Check incoming prototype configuration and normalize options.
+    #
+    # @param prototype_page [PrototypePage]
+    #
+    # @return [String, nil]
     def validate_search_term(prototype_page)
+      # @type [String]
       search_term = prototype_page.data["prototype"]["term"]
       return nil unless search_term.is_a?(String)
 
@@ -52,6 +62,8 @@ module Bridgetown
         @configured_collection = prototype_page.data["prototype"]["collection"]
       end
 
+      return nil unless site.collections[@configured_collection]
+
       # Categories and Tags are unique in that singular and plural front matter
       # can be present for each
       search_term.sub(%r!^category$!, "categories").sub(%r!^tag$!, "tags")
@@ -59,71 +71,75 @@ module Bridgetown
 
     def generate_new_page_from_prototype(prototype_page, search_term, term)
       new_page = PrototypePage.new(prototype_page, @configured_collection, search_term, term)
-      @site.pages << new_page
+      site.pages << new_page
       new_page
     end
 
-    # TODO: this would be a great use of .try
-    # document.try(:collection).try(:label) == @configured_collection
+    # Provide a list of all relevent indexed values for the given term.
+    #
+    # @param search_term [String]
+    #
+    # @return [Array<String>]
     def terms_matching_pages(search_term)
-      selected_docs = @site.documents.select do |document|
-        document.respond_to?(:collection) && document.collection.label == @configured_collection
-      end
-
       Bridgetown::Paginate::PaginationIndexer.index_documents_by(
-        selected_docs, search_term
+        site.collections[@configured_collection].docs, search_term
       ).keys
     end
   end
 
   class PrototypePage < Page
-    def initialize(prototype_page, collection, search_term, term)
-      @site = prototype_page.site
+    # @return [Page]
+    attr_reader :prototyped_page
+
+    def initialize(prototyped_page, collection, search_term, term)
+      @prototyped_page = prototyped_page
+      @site = prototyped_page.site
       @url = ""
       @name = "index.html"
-      @path = prototype_page.path
+      @path = prototyped_page.path
 
       process(@name)
 
-      self.data = Bridgetown::Utils.deep_merge_hashes prototype_page.data, {}
-      self.content = prototype_page.content
+      self.data = Bridgetown::Utils.deep_merge_hashes prototyped_page.data, {}
+      self.content = prototyped_page.content
 
       # Perform some validation that is also performed in Bridgetown::Page
-      validate_data! prototype_page.path
-      validate_permalink! prototype_page.path
+      validate_data! prototyped_page.path
+      validate_permalink! prototyped_page.path
 
-      @dir = Pathname.new(prototype_page.relative_path).dirname.to_s
+      @dir = Pathname.new(prototyped_page.relative_path).dirname.to_s
       @path = site.in_source_dir(@dir, @name)
 
-      process_prototype_page_data(prototype_page, collection, search_term, term)
+      process_prototype_page_data(collection, search_term, term)
 
       Bridgetown::Hooks.trigger :pages, :post_init, self
     end
 
-    def process_prototype_page_data(prototype_page, collection, search_term, term)
+    def process_prototype_page_data(collection, search_term, term)
       # Fill in pagination details to be handled later by Bridgetown::Paginate
       data["pagination"] = Bridgetown::Utils.deep_merge_hashes(
-        prototype_page.data["pagination"].to_h, {
+        prototyped_page.data["pagination"].to_h, {
           "enabled"     => true,
           "collection"  => collection,
           "where_query" => [search_term, term],
         }
       )
       # Use the original prototype page term so we get "tag" back, not "tags":
-      data[prototype_page.data["prototype"]["term"]] = term
+      data[prototyped_page.data["prototype"]["term"]] = term
       # Process title and slugs/URLs:
-      process_title_data_placeholder(prototype_page, search_term, term)
+      process_title_data_placeholder(search_term, term)
       process_title_simple_placeholders(term)
       slugify_term(term)
     end
 
-    def process_title_data_placeholder(prototype_page, search_term, term)
-      if prototype_page["prototype"]["data"]
+    # rubocop:disable Metrics/AbcSize
+    def process_title_data_placeholder(search_term, term)
+      if prototyped_page.data["prototype"]["data"]
         if data["title"]&.include?(":prototype-data-label")
-          related_data = @site.data[prototype_page["prototype"]["data"]].dig(term)
+          related_data = site.data[prototyped_page.data["prototype"]["data"]].dig(term)
           if related_data
             data["#{search_term}_data"] = related_data
-            data_label = related_data[prototype_page["prototype"]["data_label"]]
+            data_label = related_data[prototyped_page.data["prototype"]["data_label"]]
             data["title"] = data["title"].gsub(
               ":prototype-data-label", data_label
             )
@@ -131,6 +147,7 @@ module Bridgetown
         end
       end
     end
+    # rubocop:enable Metrics/AbcSize
 
     def process_title_simple_placeholders(term)
       if data["title"]&.include?(":prototype-term-titleize")

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/page.rb

@@ -9,7 +9,7 @@ module Bridgetown
     include Validatable
 
     attr_writer :dir
-    attr_accessor :site, :pager
+    attr_accessor :site, :paginator, :pager
     attr_accessor :name, :ext, :basename
     attr_accessor :data, :content, :output
 
@@ -121,12 +121,18 @@ module Bridgetown
     # desired placeholder replacements. For details see "url.rb"
     def url_placeholders
       {
-        path: @dir,
+        path: qualified_pages_path_for_url,
         basename: basename,
         output_ext: output_ext,
       }
     end
 
+    # Strips _pages prefix off if needed for the url/destination generation
+    # @return [String]
+    def qualified_pages_path_for_url
+      @dir.sub(%r!^/_pages!, "")
+    end
+
     # Extract information from the page filename.
     #
     # name - The String filename of the page file.

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

@@ -13,6 +13,7 @@ module Bridgetown
     # Returns nothing.
     # rubocop:disable Metrics/AbcSize
     def read
+      @site.defaults_reader.read
       @site.layouts = LayoutReader.new(site).read
       read_directories
       read_included_excludes
@@ -75,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/collection_reader.rb

@@ -5,6 +5,7 @@ module Bridgetown
     SPECIAL_COLLECTIONS = %w(posts data).freeze
 
     attr_reader :site, :content
+
     def initialize(site)
       @site = site
       @content = {}

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

@@ -3,9 +3,10 @@
 module Bridgetown
   class DataReader
     attr_reader :site, :content
+
     def initialize(site)
       @site = site
-      @content = ActiveSupport::HashWithIndifferentAccess.new
+      @content = {}
       @entry_filter = EntryFilter.new(site)
     end
 
@@ -19,7 +20,7 @@ module Bridgetown
       base = site.in_source_dir(dir)
       read_data_to(base, @content)
       merge_environment_specific_metadata!
-      @content
+      @content = @content.with_dot_access
     end
 
     # Read and parse all .yaml, .yml, .json, .csv and .tsv
@@ -43,7 +44,7 @@ module Bridgetown
         if File.directory?(path)
           read_data_to(
             path,
-            data[sanitize_filename(entry)] = ActiveSupport::HashWithIndifferentAccess.new
+            data[sanitize_filename(entry)] = {}
           )
         else
           key = sanitize_filename(File.basename(entry, ".*"))

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  class DefaultsReader
+    attr_reader :site, :path_defaults
+
+    def initialize(site)
+      @site = site
+      @path_defaults = HashWithDotAccess::Hash.new
+    end
+
+    def read
+      return unless File.directory?(site.source)
+
+      entries = Dir.chdir(site.source) do
+        Dir["**/_defaults.{yaml,yml,json}"]
+      end
+
+      entries.each do |entry|
+        path = @site.in_source_dir(entry)
+        @path_defaults[File.dirname(path) + File::SEPARATOR] = SafeYAML.load_file(path)
+      end
+
+      @path_defaults
+    end
+  end
+end