bridgetown-core 1.3.4 → 2.0.0.beta1

data/lib/bridgetown-core/generated_page.rb

@@ -3,13 +3,16 @@
 module Bridgetown
   class GeneratedPage
     include LayoutPlaceable
-    include LiquidRenderable
     include Localizable
     include Publishable
     include Transformable
 
     attr_writer :dir
-    attr_accessor :site, :paginator, :name, :ext, :basename, :data, :content, :output
+    attr_accessor :site, :paginator, :name, :ext, :basename,
+                  :data, :content, :output, :original_resource
+
+    # @return [Boolean]
+    attr_reader :fast_refresh_order
 
     alias_method :extname, :ext
 
@@ -37,11 +40,7 @@ module Bridgetown
       @name = name
       @ext = File.extname(name)
       @basename = File.basename(name, ".*")
-      @path = if from_plugin
-                File.join(base, dir, name)
-              else
-                site.in_source_dir(base, dir, name)
-              end
+      @path = from_plugin ? File.join(base, dir, name) : site.in_source_dir(base, dir, name)
 
       process
 
@@ -97,16 +96,30 @@ module Bridgetown
       data&.permalink
     end
 
+    def add_permalink_suffix(template, permalink_style)
+      template = template.dup
+
+      case permalink_style
+      when :pretty, :simple
+        template << "/"
+      else
+        template << "/" if permalink_style.to_s.end_with?("/")
+        template << ":output_ext" if permalink_style.to_s.end_with?(".*")
+      end
+
+      template
+    end
+
     # The template of the permalink.
     #
     # @return [String]
     def template
       if !html?
-        "/:path/:basename:output_ext"
+        "/:dir/:basename:output_ext"
       elsif index?
-        "/:path/"
+        "/:dir/"
       else
-        Utils.add_permalink_suffix("/:path/:basename", site.permalink_style)
+        add_permalink_suffix("/:dir/:basename", site.permalink_style)
       end
     end
 
@@ -114,23 +127,25 @@ module Bridgetown
     #
     # @return [String]
     def url
-      @url ||= URL.new(
-        template: template,
-        placeholders: url_placeholders,
-        permalink: permalink
-      ).to_s
-    end
-    alias_method :relative_url, :url
+      return @url if @url
+
+      tmpl = permalink || template
+      placeholders = { dir: @dir, basename:, output_ext: }
+
+      results = placeholders.inject(tmpl) do |result, token|
+        break result if result.index(":").nil?
 
-    # Returns a hash of URL placeholder names (as symbols) mapping to the
-    # desired placeholder replacements. For details see "url.rb"
-    def url_placeholders
-      {
-        path: @dir,
-        basename: @basename,
-        output_ext: output_ext,
-      }
+        if token.last.nil?
+          # Remove leading "/" to avoid generating urls with `//`
+          result.gsub("/:#{token.first}", "")
+        else
+          result.gsub(":#{token.first}", token.last)
+        end
+      end.then { Addressable::URI.normalize_component _1 }
+
+      @url = "/#{results.sub("#", "%23")}".gsub("..", "/").gsub("./", "").squeeze("/")
     end
+    alias_method :relative_url, :url
 
     # Layout associated with this resource
     # This will output a warning if the layout can't be found.
@@ -199,13 +214,27 @@ module Bridgetown
       @converters ||= site.matched_converters_for_convertible(self)
     end
 
-    def transform!
+    def transform! # rubocop:todo Metrics
       Bridgetown.logger.debug "Transforming:", relative_path
 
-      trigger_hooks :pre_render
-      self.content = transform_content(self)
-      place_in_layout? ? place_into_layouts : self.output = content.dup
-      trigger_hooks :post_render
+      internal_error = nil
+      Signalize.effect do
+        if !@fast_refresh_order && @previously_transformed_content
+          self.content = @previously_transformed_content
+          mark_for_fast_refresh! if site.config.fast_refresh && write?
+          next
+        end
+
+        trigger_hooks :pre_render
+        @previously_transformed_content ||= content
+        self.content = transform_content(self)
+        place_in_layout? ? place_into_layouts : self.output = content.dup
+        trigger_hooks :post_render
+      rescue StandardError, SyntaxError => e
+        internal_error = e
+      end
+
+      raise internal_error if internal_error
 
       self
     end
@@ -227,7 +256,7 @@ module Bridgetown
     #
     # @return [String]
     def destination(dest)
-      path = site.in_dest_dir(dest, URL.unescape_path(url))
+      path = site.in_dest_dir(dest, Utils.unencode_uri(url))
       path = File.join(path, "index") if url.end_with?("/")
       path << output_ext unless path.end_with? output_ext
       path
@@ -241,6 +270,7 @@ module Bridgetown
       FileUtils.mkdir_p(File.dirname(path))
       Bridgetown.logger.debug "Writing:", path
       File.write(path, output, mode: "wb")
+      unmark_for_fast_refresh!
       Bridgetown::Hooks.trigger :generated_pages, :post_write, self
     end
 
@@ -270,5 +300,15 @@ module Bridgetown
     def write?
       true
     end
+
+    def mark_for_fast_refresh!
+      @fast_refresh_order = site.fast_refresh_ordering
+      site.fast_refresh_ordering += 1
+    end
+
+    def unmark_for_fast_refresh!
+      @fast_refresh_order = nil
+      original_resource&.unmark_for_fast_refresh!
+    end
   end
 end

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

@@ -1,12 +1,5 @@
 # frozen_string_literal: true
 
-# Handles Generated Pages
-Bridgetown::Hooks.register_one :generated_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
-end
-
 # Handles Resources
 Bridgetown::Hooks.register_one :resources, :post_read, reloadable: false do |resource|
   if resource.data["prototype"].is_a?(Hash)
@@ -14,6 +7,13 @@ Bridgetown::Hooks.register_one :resources, :post_read, reloadable: false do |res
   end
 end
 
+# For data file updates, establish subscription for fast refresh
+Bridgetown::Hooks.register_one :generated_pages, :pre_render, reloadable: false do |page|
+  if page.class != Bridgetown::PrototypePage && page.data["prototype"].is_a?(Hash)
+    page.data.data_signal&.value
+  end
+end
+
 # Ensure sites clear out templates before rebuild
 Bridgetown::Hooks.register_one :site, :after_reset, reloadable: false do |_site|
   Bridgetown::PrototypeGenerator.matching_templates.clear
@@ -36,7 +36,7 @@ module Bridgetown
     end
 
     # @param site [Bridgetown::Site]
-    def generate(site)
+    def generate(site) # rubocop:todo Metrics/CyclomaticComplexity
       @site = site
       page_list = site.collections.pages.resources
 
@@ -49,7 +49,9 @@ module Bridgetown
       ensure_pagination_enabled
 
       page_list.reject! do |page|
-        prototype_pages.include? page
+        prototype_pages.include?(page).tap do |answer|
+          page.unmark_for_fast_refresh! if answer
+        end
       end
 
       prototype_pages.each do |prototype_page|
@@ -118,15 +120,14 @@ module Bridgetown
   end
 
   class PrototypePage < GeneratedPage
-    # @return [Bridgetown::GeneratedPage, Bridgetown::Resource::Base]
-    attr_reader :prototyped_page
+    alias_method :prototyped_page, :original_resource
 
     # @param prototyped_page [Bridgetown::Page, Bridgetown::Resource::Base]
     # @param collection [Bridgetown::Collection]
     # @param search_term [String]
     # @param term [String]
     def initialize(prototyped_page, collection, search_term, term) # rubocop:disable Lint/MissingSuper
-      @prototyped_page = prototyped_page
+      self.original_resource = prototyped_page
       @site = prototyped_page.site
       @url = ""
       @name = "index.html"
@@ -134,15 +135,22 @@ module Bridgetown
       @basename = "index"
       @dir = Pathname.new(prototyped_page.relative_path).dirname.to_s.sub(%r{^_pages}, "")
       @path = site.in_source_dir(@dir, @name)
+      @collection = collection
+      @search_term = search_term
+      @term = term
 
-      self.data = Bridgetown::Utils.deep_merge_hashes prototyped_page.data, {}
-      self.content = prototyped_page.content
-
-      process_prototype_page_data(collection, search_term, term)
+      fast_refresh!
 
       Bridgetown::Hooks.trigger :generated_pages, :post_init, self
     end
 
+    def fast_refresh!
+      self.data = Bridgetown::Utils.deep_merge_hashes prototyped_page.data, {}
+      self.content = prototyped_page.content
+      @original_title = data["title"]
+      process_prototype_page_data(@collection, @search_term, @term)
+    end
+
     def process_prototype_page_data(collection, search_term, term)
       pagination_key = prototyped_page.data.key?("paginate") ? "paginate" : "pagination"
       # Fill in pagination details to be handled later by Bridgetown::Paginate
@@ -163,16 +171,20 @@ module Bridgetown
 
     def process_title_data_placeholder(search_term, term) # rubocop:todo Metrics/AbcSize
       unless prototyped_page.data["prototype"]["data"] &&
-          data["title"]&.include?(":prototype-data-label")
+          @original_title&.include?(":prototype-data-label")
         return
       end
 
       related_data = site.data[prototyped_page.data["prototype"]["data"]][term]
       return unless related_data
 
+      data["data_signal"] = site.signals.send(
+        :"#{prototyped_page.data["prototype"]["data"]}_signal"
+      )
+      data["#{search_term}_term"] = term
       data["#{search_term}_data"] = related_data
       data_label = related_data[prototyped_page.data["prototype"]["data_label"]]
-      data["title"] = data["title"].gsub(
+      data["title"] = @original_title.gsub(
         ":prototype-data-label", data_label
       )
     end

data/lib/bridgetown-core/helpers.rb

@@ -1,12 +1,15 @@
 # frozen_string_literal: true
 
-require "active_support/html_safe_translation"
+require "streamlined/helpers"
 
 module Bridgetown
   class RubyTemplateView
     class Helpers
+      using Bridgetown::Refinements
       include Bridgetown::Filters
       include Bridgetown::Filters::FromLiquid
+      include ::Streamlined::Helpers
+      include Inclusive
 
       # @return [Bridgetown::RubyTemplateView]
       attr_reader :view
@@ -16,20 +19,30 @@ module Bridgetown
 
       Context = Struct.new(:registers)
 
+      # @return [Bridgetown::Foundation::SafeTranslations]
+      packages def translate_package = [Bridgetown::Foundation::Packages::SafeTranslations]
+
       # @param view [Bridgetown::RubyTemplateView]
       # @param site [Bridgetown::Site]
-      def initialize(view, site)
+      def initialize(view = nil, site = nil)
         @view = view
-        @site = site
+        @site = site || Bridgetown::Current.site
 
         # duck typing for Liquid context
-        @context = Context.new({ site: site })
+        @context = Context.new({ site: })
       end
 
       def asset_path(asset_type)
         Bridgetown::Utils.parse_frontend_manifest_file(site, asset_type.to_s)
       end
-      alias_method :webpack_path, :asset_path
+
+      def webpack_path(*)
+        source_file = caller_locations.find { _1.path.start_with?(site.source) }.path
+        raise(
+          Bridgetown::Errors::FatalException,
+          "🚨 Oops, you'll need to change `webpack_path' to `asset_path' in:\n#{source_file}\n"
+        )
+      end
 
       def live_reload_dev_js
         Bridgetown::Utils.live_reload_js(site)
@@ -107,28 +120,13 @@ module Bridgetown
         elsif relative_path.nil?
           raise ArgumentError, "You must provide a relative path"
         end
-        segments = attributes_from_options({ href: url_for(relative_path) }.merge(options))
+        segments = html_attributes({ 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 = []
-        options.each do |attr, 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
-        safe(segments.join(" "))
-      end
+      # Provide backwards compatibility via Streamlined helper
+      alias_method :attributes_from_options, :html_attributes
 
       # Delegates to <tt>I18n#translate</tt> but also performs two additional
       # functions.
@@ -161,10 +159,17 @@ module Bridgetown
           key = "#{view_path.tr("/", ".")}#{key}" if view_path.present?
         end
 
-        ActiveSupport::HtmlSafeTranslation.translate(key, **options)
+        return I18n.translate(key, **options) unless %r{(?:_|\b)html\z}.match?(key)
+
+        translate_with_html(key, **options)
       end
       alias_method :t, :translate
 
+      def translate_with_html(key, **options)
+        escaper = ->(input) { input.to_s.encode(xml: :attr).gsub(%r{\A"|"\Z}, "") }
+        translate_package.translate(key, escaper, **options)
+      end
+
       # Delegates to <tt>I18n.localize</tt> with no additional functionality.
       #
       # @return [String] the localized string
@@ -209,10 +214,10 @@ module Bridgetown
         name = name.to_s
         resource.slots.reject! { _1.name == name } if replace
         resource.slots << Slot.new(
-          name: name,
-          content: content,
+          name:,
+          content:,
           context: resource,
-          transform: transform
+          transform:
         )
 
         nil
@@ -260,12 +265,14 @@ module Bridgetown
         end
       end
 
+      # TODO: docu
       def dsd(input = nil, &block)
         tmpl_content = block.nil? ? input.to_s : view.capture(&block)
 
         Bridgetown::Utils.dsd_tag(tmpl_content)
       end
 
+      # TODO: docu
       def dsd_style
         tmpl_path = caller_locations(1, 2).find do |loc|
                       loc.label.include?("method_missing").!
@@ -286,26 +293,8 @@ module Bridgetown
         style_tag.html_safe
       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
+      # TODO: docu
+      def bypass_tracking(...) = Signalize.untracked(...)
     end
   end
 end

data/lib/bridgetown-core/hooks.rb

@@ -55,7 +55,7 @@ module Bridgetown
     # @yieldparam obj the object which triggered the event hook
     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)
+        register_one(owner, event, priority:, reloadable:, &block)
       end
     end
 
@@ -77,11 +77,11 @@ module Bridgetown
       raise Uncallable, "Hooks must respond to :call" unless block.respond_to? :call
 
       @registry[owner] << HookRegistration.new(
-        owner: owner,
-        event: event,
+        owner:,
+        event:,
         priority: priority_value(priority),
-        reloadable: reloadable,
-        block: block
+        reloadable:,
+        block:
       )
       if ENV["BRIDGETOWN_LOG_LEVEL"] == "debug"
         if Bridgetown.respond_to?(:logger)

data/lib/bridgetown-core/inflector.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "dry/inflector"
+
+module Bridgetown
+  class Inflector < Dry::Inflector
+    def initialize(&) # rubocop:disable Lint/MissingSuper
+      @inflections = Dry::Inflector::Inflections.build do |inflections|
+        inflections.acronym "HTML"
+        inflections.acronym "CSS"
+        inflections.acronym "JS"
+      end
+      configure(&) if block_given?
+    end
+
+    def configure
+      yield inflections
+    end
+
+    # for compatibility with Zeitwerk
+    def camelize(basename, *)
+      super(basename)
+    end
+
+    def to_s
+      "#<Bridgetown::Inflector>"
+    end
+    alias_method :inspect, :to_s
+
+    def ==(other)
+      return super unless other.is_a?(Bridgetown::Inflector)
+
+      # NOTE: strictly speaking, this might be wrong if two inflector instances have different
+      # rule sets…but as this equality check is mainly done within the automated test suite, we
+      # just assume two instances are equal. No production apps will need multiple,
+      # differently-configured inflectors running at once ;)
+      true
+    end
+  end
+end

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

@@ -5,8 +5,8 @@ require "kramdown-parser-gfm"
 module Kramdown
   module Parser
     class GFM
-      MARK_DELIMITER = %r{(==|::)+}.freeze
-      MARK_MATCH = %r{#{MARK_DELIMITER}(?!\s|=|:).*?[^\s=:]#{MARK_DELIMITER}}m.freeze
+      MARK_DELIMITER = %r{(==|::)+}
+      MARK_MATCH = %r{#{MARK_DELIMITER}(?!\s|=|:).*?[^\s=:]#{MARK_DELIMITER}}m
 
       # Monkey-patch GFM initializer to add our new mark parser
       alias_method :_old_initialize, :initialize

data/lib/bridgetown-core/layout.rb

@@ -2,8 +2,8 @@
 
 module Bridgetown
   class Layout
-    include FrontMatterImporter
-    include LiquidRenderable
+    using Bridgetown::Refinements
+    include FrontMatter::Importer
 
     # Gets the Site object.
     attr_reader :site
@@ -67,7 +67,7 @@ module Bridgetown
       @relative_path = @path.sub(@base_dir, "")
       @ext = File.extname(name)
 
-      @data = read_front_matter(@path)&.with_dot_access
+      @data = read_front_matter(@path)&.as_dots
     rescue SyntaxError => e
       Bridgetown.logger.error "Error:",
                               "Ruby Exception in #{e.message}"

data/lib/bridgetown-core/log_adapter.rb

@@ -43,7 +43,6 @@ module Bridgetown
         self.log_level = :debug
       end
       debug "Logging at level:", LOG_LEVELS.key(writer.level).to_s
-      debug "Bridgetown Version:", Bridgetown::VERSION
     end
 
     # Public: Print a debug message
@@ -52,8 +51,8 @@ module Bridgetown
     # message - the message detail
     #
     # Returns nothing
-    def debug(topic, message = nil, &block)
-      write(:debug, topic, message, &block)
+    def debug(topic, message = nil, &)
+      write(:debug, topic, message, &)
     end
 
     # Public: Print a message
@@ -62,8 +61,8 @@ module Bridgetown
     # message - the message detail
     #
     # Returns nothing
-    def info(topic, message = nil, &block)
-      write(:info, topic, message, &block)
+    def info(topic, message = nil, &)
+      write(:info, topic, message, &)
     end
 
     # Public: Print a message
@@ -72,8 +71,8 @@ module Bridgetown
     # message - the message detail
     #
     # Returns nothing
-    def warn(topic, message = nil, &block)
-      write(:warn, topic, message, &block)
+    def warn(topic, message = nil, &)
+      write(:warn, topic, message, &)
     end
 
     # Public: Print an error message
@@ -82,8 +81,8 @@ module Bridgetown
     # message - the message detail
     #
     # Returns nothing
-    def error(topic, message = nil, &block)
-      write(:error, topic, message, &block)
+    def error(topic, message = nil, &)
+      write(:error, topic, message, &)
     end
 
     # Public: Print an error message and immediately abort the process
@@ -92,8 +91,8 @@ module Bridgetown
     # message - the message detail (can be omitted)
     #
     # Returns nothing
-    def abort_with(topic, message = nil, &block)
-      error(topic, message, &block)
+    def abort_with(topic, message = nil, &)
+      error(topic, message, &)
       abort
     end
 
@@ -142,10 +141,10 @@ module Bridgetown
     #
     # Returns false if the message was not written, otherwise returns the value of calling
     # the appropriate writer method, e.g. writer.info.
-    def write(level_of_message, topic, message = nil, &block)
+    def write(level_of_message, topic, message = nil, &)
       return false unless write_message?(level_of_message)
 
-      writer.public_send(level_of_message, message(topic, message, &block))
+      writer.public_send(level_of_message, message(topic, message, &))
     end
   end
 end

data/lib/bridgetown-core/log_writer.rb

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