bridgetown-core 1.3.4 → 2.0.0.beta2

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

@@ -47,10 +47,10 @@ module Bridgetown
       Layout.label_for_file(file)
     end
 
-    def within(directory, &block)
+    def within(directory, &)
       return unless File.exist?(directory)
 
-      Dir.chdir(directory, &block)
+      Dir.chdir(directory, &)
     end
   end
 end

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

@@ -31,8 +31,8 @@ module Bridgetown
       dir = File.dirname(path.sub("#{content_dir}/", ""))
       name = File.basename(path)
 
-      @content_files << if Utils.has_yaml_header?(path) || Utils.has_rbfm_header?(path)
-                          site.collections.pages.read_resource(path, manifest: manifest)
+      @content_files << if FrontMatter::Loaders.front_matter?(path)
+                          site.collections.pages.read_resource(path, manifest:)
                         else
                           Bridgetown::StaticFile.new(site, content_dir, "/#{dir}", name)
                         end

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

@@ -3,15 +3,13 @@
 module Bridgetown
   module Resource
     class Base # rubocop:todo Metrics/ClassLength
+      using Bridgetown::Refinements
       include Comparable
+      include Bridgetown::RodaCallable
       include Bridgetown::Publishable
       include Bridgetown::LayoutPlaceable
-      include Bridgetown::LiquidRenderable
       include Bridgetown::Localizable
 
-      # @return [HashWithDotAccess::Hash]
-      attr_reader :data
-
       # @return [Destination]
       attr_reader :destination
 
@@ -24,17 +22,29 @@ module Bridgetown
       # @return [Array<Bridgetown::Slot>]
       attr_reader :slots
 
+      # @return [Boolean]
+      attr_reader :fast_refresh_order
+
       # @return [String]
-      attr_accessor :content, :untransformed_content, :output
+      attr_accessor :untransformed_content
 
-      DATE_FILENAME_MATCHER = %r!^(?>.+/)*?(\d{2,4}-\d{1,2}-\d{1,2})-([^/]*)(\.[^.]+)$!.freeze
+      attr_writer :content
+
+      # @return [String]
+      attr_accessor :output
+
+      DATE_FILENAME_MATCHER = %r!^(?>.+/)*?(\d{2,4}-\d{1,2}-\d{1,2})-([^/]*)(\.[^.]+)$!
 
       # @param site [Bridgetown::Site]
       # @param origin [Bridgetown::Resource::Origin]
       def initialize(model:)
         @model = model
         @site = model.site
-        @data = collection.data? ? HashWithDotAccess::Hash.new : front_matter_defaults
+        @data = Signalize.signal(
+          collection.data? ? HashWithDotAccess::Hash.new : front_matter_defaults
+        )
+        # we track content subscriptions under the hood numerically…cleans up internal issues
+        @content_signal = Signalize.signal(0)
         @slots = []
 
         trigger_hooks :post_init
@@ -84,17 +94,35 @@ module Bridgetown
       #
       # @return [HashWithDotAccess::Hash]
       def front_matter_defaults
-        site.frontmatter_defaults.all(
-          relative_path.to_s,
-          collection.label.to_sym
-        ).with_dot_access
+        site.frontmatter_defaults.all(relative_path.to_s, collection.label.to_sym).as_dots
+      end
+
+      # @return [HashWithDotAccess::Hash]
+      def data
+        @data.value
       end
 
       # Merges new data into the existing data hash.
       #
       # @param new_data [HashWithDotAccess::Hash]
       def data=(new_data)
-        @data = @data.merge(new_data)
+        if site.config.fast_refresh && write?
+          # TODO: investigate if this would be better:
+          # @data.value = front_matter_defaults
+          mark_for_fast_refresh!
+        end
+
+        Signalize.batch do
+          @content_signal.value += 1
+          @data.value = @data.value.merge(new_data)
+        end
+        @data.peek
+      end
+
+      # @return [String] the resource content minus its layout
+      def content
+        @content_signal.value # subscribe for Fast Refresh
+        @content
       end
 
       # @return [Bridgetown::Resource::Base]
@@ -119,12 +147,33 @@ module Bridgetown
       end
       alias_method :read, :read! # TODO: eventually use the bang version only
 
-      def transform!
-        transformer.process! unless collection.data?
+      def transform! # rubocop:todo Metrics/CyclomaticComplexity
+        internal_error = nil
+        @transform_effect_disposal = Signalize.effect do
+          if !@fast_refresh_order && @previously_transformed
+            self.content = untransformed_content
+            @transformer = nil
+            mark_for_fast_refresh! if site.config.fast_refresh && write?
+            next
+          end
+
+          transformer.process! unless collection.data?
+          slots.clear
+          @previously_transformed = true
+        rescue StandardError, SyntaxError => e
+          internal_error = e
+        end
+
+        raise internal_error if internal_error
 
         self
       end
 
+      # Transforms the resource and returns the full output
+      #
+      # @return [String]
+      def call(*) = transform!.output
+
       def trigger_hooks(hook_name, *args)
         Bridgetown::Hooks.trigger collection.label.to_sym, hook_name, self, *args if collection
         Bridgetown::Hooks.trigger :resources, hook_name, self, *args
@@ -222,13 +271,10 @@ module Bridgetown
       end
       alias_method :write?, :requires_destination?
 
-      # Write the generated Document file to the destination directory.
-      #
-      # dest - The String path to the destination dir.
-      #
-      # Returns nothing.
+      # Write the generated resource file to the destination directory.
       def write(_dest = nil)
         destination.write(output)
+        unmark_for_fast_refresh!
         trigger_hooks(:post_write)
       end
 
@@ -245,16 +291,16 @@ module Bridgetown
 
       def to_h
         {
-          id: id,
-          absolute_url: absolute_url,
-          relative_path: relative_path,
-          relative_url: relative_url,
-          date: date,
-          data: data,
-          taxonomies: taxonomies,
-          untransformed_content: untransformed_content,
-          content: content,
-          output: output,
+          id:,
+          absolute_url:,
+          relative_path:,
+          relative_url:,
+          date:,
+          data:,
+          taxonomies:,
+          untransformed_content:,
+          content:,
+          output:,
         }
       end
 
@@ -300,6 +346,42 @@ module Bridgetown
       alias_method :previous_doc, :previous_resource
       alias_method :previous, :previous_resource
 
+      def deconstruct_keys(...)
+        @data.value.deconstruct_keys(...)
+      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
+      end
+
+      def prepare_for_fast_refresh! # rubocop:todo Metrics
+        dispose_of_transform_effect
+        FileUtils.rm(destination.output_path, force: true) if requires_destination?
+        past_values = @data.peek.select do |key|
+          key == "categories" || key == "tags" || site.taxonomy_types.keys.any?(key)
+        end
+        model.attributes = model.origin.read
+        read!
+        tax_diff = past_values.any? { |k, v| @data.peek[k] != v }
+
+        if tax_diff && !collection.data?
+          # If the taxonomy values are different, we should just abort the fast refresh process.
+          unmark_for_fast_refresh!
+          false
+        else
+          true
+        end
+      end
+
+      def dispose_of_transform_effect
+        @transform_effect_disposal&.()
+      end
+
       private
 
       def ensure_default_data
@@ -350,6 +432,7 @@ module Bridgetown
 
       def import_taxonomies_from_data
         taxonomies.each_value do |metadata|
+          metadata.terms.reject! { _1.resource == self } # clear out for Fash Refresh
           Array(data[metadata.type.key]).each do |term|
             metadata.terms << TaxonomyTerm.new(
               resource: self, label: term, type: metadata.type

data/lib/bridgetown-core/resource/destination.rb

@@ -32,7 +32,7 @@ module Bridgetown
       end
 
       def output_path
-        path = URL.unescape_path(relative_url)
+        path = Utils.unencode_uri(relative_url)
         if resource.site.base_path.present?
           path = path.delete_prefix resource.site.base_path(strip_slash_only: true)
         end

data/lib/bridgetown-core/resource/relations.rb

@@ -3,6 +3,8 @@
 module Bridgetown
   module Resource
     class Relations
+      using Bridgetown::Refinements
+
       # @return [Bridgetown::Resource::Base]
       attr_reader :resource
 
@@ -13,6 +15,7 @@ module Bridgetown
       def initialize(resource)
         @resource = resource
         @site = resource.site
+        @inflector = site.config.inflector
       end
 
       # @return [HashWithDotAccess::Hash]
@@ -26,7 +29,7 @@ module Bridgetown
           types = []
           relation_schema&.each_value do |collections|
             types << collections
-            types << Array(collections).map { |item| ActiveSupport::Inflector.pluralize(item) }
+            types << Array(collections).map { |item| @inflector.pluralize(item) }
           end
           types.flatten.uniq
         end
@@ -49,13 +52,13 @@ module Bridgetown
       end
 
       def method_missing(type, *args)
-        return super unless type.to_s.in?(relation_types)
+        return super unless type.to_s.within?(relation_types)
 
         resources_for_type(type)
       end
 
       def respond_to_missing?(type, *_args)
-        type.to_s.in?(relation_types)
+        type.to_s.within?(relation_types)
       end
 
       def to_liquid
@@ -70,7 +73,7 @@ module Bridgetown
         relation_schema&.each do |relation_type, collections|
           collections = Array(collections).then do |collections_arr|
             collections_arr +
-              collections_arr.map { |item| ActiveSupport::Inflector.pluralize(item) }
+              collections_arr.map { |item| @inflector.pluralize(item) }
           end.flatten.uniq
           return relation_type if collections.include?(type.to_s)
         end
@@ -79,14 +82,14 @@ module Bridgetown
       # @param type [Symbol]
       # @return [Bridgetown::Collection]
       def other_collection_for_type(type)
-        site.collections[type] || site.collections[ActiveSupport::Inflector.pluralize(type)]
+        site.collections[type] || site.collections[@inflector.pluralize(type)]
       end
 
       # @return [Array<String>]
       def collection_labels
         [
           resource.collection.label,
-          ActiveSupport::Inflector.singularize(resource.collection.label),
+          @inflector.singularize(resource.collection.label),
         ]
       end
 
@@ -109,7 +112,7 @@ module Bridgetown
         label, singular_label = collection_labels
 
         other_collection_for_type(type).resources.select do |other_resource|
-          resource.data.slug.in?(
+          resource.data.slug.within?(
             Array(other_resource.data[label] || other_resource.data[singular_label])
           )
         end
@@ -121,7 +124,7 @@ module Bridgetown
         label, singular_label = collection_labels
 
         other_collection_for_type(type).resources.find do |other_resource|
-          resource.data.slug.in?(
+          resource.data.slug.within?(
             Array(other_resource.data[label] || other_resource.data[singular_label])
           )
         end

data/lib/bridgetown-core/resource/taxonomy_type.rb

@@ -3,6 +3,8 @@
 module Bridgetown
   module Resource
     class TaxonomyType
+      using Bridgetown::Refinements
+
       # @return [Bridgetown::Site]
       attr_reader :site
 
@@ -28,7 +30,7 @@ module Bridgetown
       def terms
         site.resources.map do |resource|
           resource.taxonomies[label].terms
-        end.flatten.group_by(&:label).with_dot_access
+        end.flatten.group_by(&:label).as_dots
       end
 
       def inspect

data/lib/bridgetown-core/resource/transformer.rb

@@ -38,7 +38,7 @@ module Bridgetown
           resource.content = transform_content(resource) do |converter, index, output|
             conversions[index] = {
               type: :content,
-              converter: converter,
+              converter:,
               output: Bridgetown.env.production? ? nil : output,
               output_ext: conversions[index]&.dig(:output_ext) ||
                 converter.output_ext(resource.extname),
@@ -81,7 +81,7 @@ module Bridgetown
       def output_ext_from_converters
         @conversions = converters.map do |converter|
           {
-            converter: converter,
+            converter:,
             output_ext: converter.output_ext(resource.extname),
           }
         end
@@ -102,8 +102,8 @@ module Bridgetown
           output = transform_with_layout(layout, output, resource) do |converter, layout_output|
             conversions << {
               type: :layout,
-              layout: layout,
-              converter: converter,
+              layout:,
+              converter:,
               output: Bridgetown.env.production? ? nil : layout_output,
             }
           end

data/lib/bridgetown-core/ruby_template_view.rb

@@ -1,11 +1,30 @@
 # frozen_string_literal: true
 
 require "digest"
+require "serbea/pipeline"
+require "streamlined/helpers"
+require "streamlined/renderable"
 
 module Bridgetown
+  module Streamlined
+    include ::Streamlined::Renderable
+    include Serbea::Pipeline::Helper
+    include ERBCapture
+
+    def helper(name, &helper_block)
+      self.class.define_method(name) do |*args, **kwargs, &block|
+        helper_block.call(*args, **kwargs, &block)
+      end
+    end
+    alias_method :macro, :helper
+  end
+
   class RubyTemplateView
     require "bridgetown-core/helpers"
 
+    using Bridgetown::Refinements
+    include Bridgetown::Streamlined
+
     attr_reader :layout, :resource, :paginator, :site, :content
     alias_method :page, :resource
 
@@ -20,33 +39,26 @@ module Bridgetown
       end
       @paginator = resource.paginator if resource.respond_to?(:paginator)
       @site = resource.site
+      @support_data_as_view_methods = @site.config.support_data_as_view_methods
     end
 
-    def data
-      resource.data
-    end
+    def data = resource.data
 
-    def partial(_partial_name = nil, **_options)
-      raise "Must be implemented in a subclass"
-    end
+    def collections = site.collections
+
+    def site_drop = site.site_payload.site
+
+    def partial(_partial_name = nil, **_options) = raise("Must be implemented in a subclass")
 
-    def render(item, **options, &block)
+    def render(item, **options, &)
       if item.respond_to?(:render_in)
-        result = item.render_in(self, &block)
+        result = item.render_in(self, &)
         result&.html_safe
       else
-        partial(item, **options, &block)&.html_safe
+        partial(item, **options, &)&.html_safe
       end
     end
 
-    def collections
-      site.collections
-    end
-
-    def site_drop
-      site.site_payload.site
-    end
-
     def liquid_render(component, options = {}, &block)
       options[:_block_content] = capture(&block) if block && respond_to?(:capture)
       render_statement = _render_statement(component, options)
@@ -58,16 +70,24 @@ module Bridgetown
         Bridgetown.logger.warn "Liquid Warning:",
                                LiquidRenderer.format_error(e, path || document.relative_path)
       end
-      template.render!(options.deep_stringify_keys, _liquid_context).html_safe
+      template.render!(options.as_dots, _liquid_context).html_safe
     end
 
     def helpers
       @helpers ||= Helpers.new(self, site)
     end
 
-    def method_missing(method_name, *args, **kwargs, &block)
+    def data_key?(key, *args, **kwargs)
+      return false unless @support_data_as_view_methods
+
+      args.empty? && kwargs.empty? && !block_given? && data.key?(key)
+    end
+
+    def method_missing(method_name, ...)
       if helpers.respond_to?(method_name.to_sym)
-        helpers.send method_name.to_sym, *args, **kwargs, &block
+        helpers.send(method_name.to_sym, ...)
+      elsif data_key?(method_name, ...)
+        data[method_name]
       else
         super
       end
@@ -77,18 +97,14 @@ module Bridgetown
       helpers.respond_to?(method_name.to_sym, include_private) || super
     end
 
-    def inspect
-      "#<#{self.class} layout=#{layout&.label} resource=#{resource.relative_path}>"
-    end
+    def inspect = "#<#{self.class} layout=#{layout&.label} resource=#{resource.relative_path}>"
 
     private
 
     def _render_statement(component, options)
-      render_statement = if options[:_block_content]
-                           ["{% rendercontent \"#{component}\""]
-                         else
+      render_statement = options[:_block_content] ?
+                           ["{% rendercontent \"#{component}\""] :
                            ["{% render \"#{component}\""]
-                         end
       unless options.empty?
         render_statement << ", #{options.keys.map { |k| "#{k}: #{k}" }.join(", ")}"
       end
@@ -103,7 +119,7 @@ module Bridgetown
     def _liquid_context
       {
         registers: {
-          site: site,
+          site:,
           page: resource.to_liquid,
           cached_partials: Bridgetown::Converters::LiquidTemplates.cached_partials,
         },

data/lib/bridgetown-core/signals.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "signalize/struct"
+
+class Bridgetown::Signals < Signalize::Struct
+  alias_method :__prev_to_h, :to_h
+  include Enumerable
+  alias_method :to_h, :__prev_to_h
+
+  def self.signal_accessor(...)
+    super
+
+    return unless members.include?(:members)
+
+    # So…we need to support site data that could have a `members` key. This is how we do it:
+    # by conditionally providing the value the gem class expects when it's gem code, otherwise we
+    # provide the `members` signal value.
+    define_method :members do
+      if caller_locations(1..1).first.path.end_with?("/lib/signalize/struct.rb")
+        self.class.members
+      else
+        members_signal.value
+      end
+    end
+  end
+
+  def each(...)
+    to_h.each(...)
+  end
+
+  def key?(key)
+    self.class.members.include?(key.to_sym)
+  end
+
+  def [](key)
+    return unless key?(key)
+
+    send(key)
+  end
+
+  def []=(key, value)
+    unless key?(key)
+      if instance_of?(Bridgetown::Signals)
+        raise Bridgetown::Errors::FatalException,
+              "You must use a unique subclass of `Bridgetown::Signals' before adding new members"
+      end
+
+      self.class.signal_accessor(key)
+    end
+
+    send(:"#{key}=", value)
+  end
+
+  def method_missing(key, *value, &block) # rubocop:disable Style/MissingRespondToMissing
+    return nil if value.empty? && block.nil?
+
+    key = key.to_s
+    if key.end_with?("=")
+      key.chop!
+      return self[key] = value[0]
+    end
+
+    super(key.to_sym)
+  end
+
+  # You can access signals and mutate objects (aka push to an array, change a hash value), and by
+  # making those changes with a block, this method will track which signals were accessed and resave
+  # them with duplicated objects thereby triggering new dependent effects or subscriptions.
+  def batch_mutations
+    ef = Signalize.effect { yield self }
+    node = ef.receiver._sources
+    deps = []
+    while node
+      deps << node._source
+      node = node._next_source
+    end
+
+    ef.() # dispose
+
+    Signalize.batch do
+      self.class.members.each do |member_name|
+        matching_dep = deps.find { _1 == send(:"#{member_name}_signal") }
+        next unless matching_dep
+
+        Signalize.batch do
+          new_value = matching_dep.value.dup
+          matching_dep.value = nil
+          matching_dep.value = new_value
+        end
+      end
+    end
+
+    nil
+  end
+end

data/lib/bridgetown-core/site.rb

@@ -7,6 +7,7 @@ module Bridgetown
     include Configurable
     include Content
     include Extensible
+    include FastRefreshable
     include Localizable
     include Processable
     include Renderable
@@ -22,7 +23,7 @@ module Bridgetown
     # @return [Bridgetown::Utils::LoadersManager]
     attr_reader :loaders_manager
 
-    attr_reader :cache_dir, :liquid_renderer
+    attr_reader :cache_dir, :liquid_renderer, :data, :signals
 
     # All files not pages/documents or structured data in the source folder
     # @return [Array<StaticFile>]
@@ -34,9 +35,9 @@ module Bridgetown
     # @return [Array<GeneratedPage>]
     attr_accessor :generated_pages
 
-    attr_accessor :permalink_style, :time, :data,
+    attr_accessor :permalink_style, :time,
                   :file_read_opts, :plugin_manager, :converters,
-                  :generators, :reader
+                  :generators, :reader, :fast_refresh_ordering
 
     # Initialize a new Site.
     #
@@ -60,7 +61,7 @@ module Bridgetown
       @reader          = Reader.new(self)
       @liquid_renderer = LiquidRenderer.new(self)
 
-      Bridgetown::Cache.base_cache["site_tmp"] = {}.with_dot_access
+      Bridgetown::Cache.base_cache["site_tmp"] = HashWithDotAccess::Hash.new
       ensure_not_in_dest
 
       Bridgetown::Current.sites[@label] = self
@@ -70,6 +71,23 @@ module Bridgetown
       setup   # Extensible
     end
 
+    def data=(new_data)
+      @data = new_data
+      data_hash = @data.to_dot_h.transform_keys(&:to_sym)
+      @signals = Bridgetown::Signals.define(*data_hash.keys) do
+        def inspect # rubocop:disable Lint/NestedMethodDefinition
+          var_peeks = instance_variables.filter_map do |var_name|
+            var = instance_variable_get(var_name)
+            if var.is_a?(Signalize::Signal)
+              "#{var_name.to_s.delete_prefix("@")}=#{var.peek.inspect}"
+            end
+          end.join(", ")
+
+          "#<Bridgetown::Site::Signals#{object_id}>#{var_peeks.empty? ? nil : " #{var_peeks}"}>"
+        end
+      end.new(**data_hash)
+    end
+
     # Check that the destination dir isn't the source dir or a directory
     # parent to the source dir.
     def ensure_not_in_dest