bridgetown-core 1.0.0.alpha10 → 1.0.0.beta3

data/lib/bridgetown-core/hooks.rb

@@ -17,34 +17,59 @@ module Bridgetown
 
     DEFAULT_PRIORITY = 20
 
-    # compatibility layer for octopress-hooks users
     PRIORITY_MAP = {
       low: 10,
       normal: 20,
       high: 30,
     }.freeze
 
-    # initial empty hooks
     @registry = {}
 
     NotAvailable = Class.new(RuntimeError)
     Uncallable = Class.new(RuntimeError)
 
-    # Ensure the priority is a Fixnum
     def self.priority_value(priority)
       return priority if priority.is_a?(Integer)
 
       PRIORITY_MAP[priority] || DEFAULT_PRIORITY
     end
 
-    # register hook(s) to be called later
+    # Sort registered hooks according to priority and load order
+    #
+    # @param hooks [Array<HookRegistration>]
+    def self.prioritized_hooks(hooks)
+      grouped_hooks = hooks.group_by(&:priority)
+      grouped_hooks.keys.sort.reverse.map { |priority| grouped_hooks[priority] }.flatten
+    end
+
+    # Register one or more hooks which may be triggered later for a particular event
+    #
+    # @param owners [Symbol, Array<Symbol>] name of the owner (`:site`, `:resource`, etc.)
+    # @param event [Symbol] name of the event (`:pre_read`, `:post_render`, etc.)
+    # @param priority [Integer, Symbol] either `:low`, `:normal`, or `:high`, or an integer.
+    #   Default is normal (20)
+    # @param reloadable [Boolean] whether the hook should be removed prior to a site reload.
+    #   Default is true.
+    # @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
     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)
       end
     end
 
-    # register a single hook to be called later
+    # Register a hook which may be triggered later for a particular event
+    #
+    # @param owner [Symbol] name of the owner (`:site`, `:resource`, etc.)
+    # @param event [Symbol] name of the event (`:pre_read`, `:post_render`, etc.)
+    # @param priority [Integer, Symbol] either `:low`, `:normal`, or `:high`, or an integer.
+    #   Default is normal (20)
+    # @param reloadable [Boolean] whether the hook should be removed prior to a site reload.
+    #   Default is true.
+    # @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
     def self.register_one(owner, event, priority: DEFAULT_PRIORITY, reloadable: true, &block)
       @registry[owner] ||= []
 
@@ -68,10 +93,28 @@ module Bridgetown
       block
     end
 
-    def self.remove_hook(owner, _event, block)
+    # Delete a previously-registered hook
+    #
+    # @param owners [Symbol] name of the owner (`:site`, `:resource`, etc.)
+    # @param block [Proc] the exact block used originally to register the hook
+    def self.remove_hook(owner, block)
       @registry[owner].delete_if { |item| item.block == block }
     end
 
+    # Clear all hooks marked as reloadable from the registry
+    def self.clear_reloadable_hooks
+      Bridgetown.logger.debug("Clearing reloadable hooks")
+
+      @registry.each_value do |hooks|
+        hooks.delete_if(&:reloadable)
+      end
+    end
+
+    # Trigger all registered hooks for a particular owner and event.
+    # Any arguments after the initial two will be directly passed along to the hooks.
+    #
+    # @param owner [Symbol] name of the owner (`:site`, `:resource`, etc.)
+    # @param event [Symbol] name of the event (`:pre_read`, `:post_render`, etc.)
     def self.trigger(owner, event, *args) # rubocop:disable Metrics/CyclomaticComplexity
       # proceed only if there are hooks to call
       hooks = @registry[owner]&.select { |item| item.event == event }
@@ -79,25 +122,13 @@ module Bridgetown
 
       prioritized_hooks(hooks).each do |hook|
         if ENV["BRIDGETOWN_LOG_LEVEL"] == "debug"
-          hook_info = args[0].respond_to?(:url) ? args[0].relative_path : hook.block
+          hook_info = args[0].respond_to?(:relative_path) ? args[0].relative_path : hook.block
           Bridgetown.logger.debug("Triggering hook:", "#{owner}:#{event} for #{hook_info}")
         end
         hook.block.call(*args)
       end
-    end
-
-    def self.prioritized_hooks(hooks)
-      # sort hooks according to priority and load order
-      grouped_hooks = hooks.group_by(&:priority)
-      grouped_hooks.keys.sort.reverse.map { |priority| grouped_hooks[priority] }.flatten
-    end
 
-    def self.clear_reloadable_hooks
-      Bridgetown.logger.debug("Clearing reloadable hooks")
-
-      @registry.each_value do |hooks|
-        hooks.delete_if(&:reloadable)
-      end
+      true
     end
   end
 end

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

@@ -69,8 +69,23 @@ module Bridgetown
         attributes[:_origin_]
       end
 
+      def origin=(new_origin)
+        attributes[:_id_] = new_origin.id
+        attributes[:_origin_] = new_origin
+      end
+
       def persisted?
-        id && origin.exists?
+        (id && origin&.exists?) == true
+      end
+
+      def save
+        unless origin.respond_to?(:write)
+          raise "`#{origin.class}' doesn't allow writing of model objects"
+        end
+
+        run_callbacks :save do
+          origin.write(self)
+        end
       end
 
       # @return [Bridgetown::Resource::Base]
@@ -100,11 +115,19 @@ module Bridgetown
         attributes[:_collection_]
       end
 
+      def collection=(new_collection)
+        attributes[:_collection_] = new_collection
+      end
+
       # @return [String]
       def content
         attributes[:_content_]
       end
 
+      def content=(new_content)
+        attributes[:_content_] = new_content
+      end
+
       def attributes
         @attributes ||= HashWithDotAccess::Hash.new
       end

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

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-# See bottom of file for specific origin requires...
-
 module Bridgetown
   module Model
     # Abstract Superclass
     class Origin
       extend ActiveSupport::DescendantsTracker
 
+      EAGER_LOAD_DESCENDANTS = %i(BuilderOrigin RepoOrigin PluginOrigin).freeze
+
       # @return [String]
       attr_accessor :id
 
@@ -42,9 +42,7 @@ module Bridgetown
         raise "Implement #exists? in a subclass of Bridgetown::Model::Origin"
       end
     end
+
+    Origin::EAGER_LOAD_DESCENDANTS.each { const_get _1 }
   end
 end
-
-require "bridgetown-core/model/builder_origin"
-require "bridgetown-core/model/repo_origin"
-require "bridgetown-core/model/plugin_origin"

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

@@ -25,6 +25,18 @@ module Bridgetown
         def data_file_extensions
           %w(.yaml .yml .json .csv .tsv .rb).freeze
         end
+
+        # Initializes a new repo object using a collection and a relative source path.
+        # You'll need to use this when you want to create and save a model to the source.
+        #
+        # @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)
+          collection = collection.label if collection.is_a?(Bridgetown::Collection)
+
+          new("repo://#{collection}.collection/#{relative_path}")
+        end
       end
 
       def read
@@ -46,6 +58,23 @@ module Bridgetown
         @data
       end
 
+      def write(model)
+        if File.exist?(original_path) && !Bridgetown::Utils.has_yaml_header?(original_path)
+          raise Bridgetown::Errors::InvalidYAMLFrontMatterError,
+                "Only existing files containing YAML front matter can be overwritten by the model"
+        end
+
+        contents = "#{front_matter_to_yaml(model)}---\n\n#{model.content}"
+
+        # Create folders if necessary
+        dir = File.dirname(original_path)
+        FileUtils.mkdir_p(dir) unless File.directory?(dir)
+
+        File.write(original_path, contents)
+
+        true
+      end
+
       def url
         @url ||= URI.parse(id)
       end
@@ -121,6 +150,25 @@ module Bridgetown
           raise error
         end
       end
+
+      def front_matter_to_yaml(model)
+        data = model.data_attributes.to_h
+        data = data.deep_merge(data) do |_, _, v|
+          case v
+          when DateTime
+            v.to_time
+          when Symbol
+            v.to_s
+          else
+            v
+          end
+        end
+        data.each do |k, v|
+          data.delete(k) if v.nil?
+        end
+
+        data.to_yaml
+      end
     end
   end
 end

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

@@ -51,15 +51,11 @@ module Bridgetown
         loader.do_not_eager_load(File.join(server_folder, "roda_app.rb"))
 
         unless ENV["BRIDGETOWN_ENV"] == "production"
-          begin
-            Listen.to(server_folder) do |_modified, _added, _removed|
-              loader.reload
-              loader.eager_load
-              Bridgetown::Rack::Routes.reload_subclasses
-            end.start
-          # interrupt isn't handled well by the listener
-          rescue ThreadError # rubocop:disable Lint/SuppressedException
-          end
+          Listen.to(server_folder) do |_modified, _added, _removed|
+            loader.reload
+            loader.eager_load
+            Bridgetown::Rack::Routes.reload_subclasses
+          end.start
         end
       end
 

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

@@ -23,6 +23,7 @@ module Bridgetown
       plugin :json
       plugin :json_parser
       plugin :cookies
+      plugin :streaming
       plugin :public, root: Bridgetown::Current.preloaded_configuration.destination
       plugin :not_found do
         output_folder = Bridgetown::Current.preloaded_configuration.destination
@@ -39,7 +40,7 @@ module Bridgetown
         "500 Internal Server Error"
       end
 
-      def _roda_run_main_route(r) # rubocop:disable Naming/MethodParameterName
+      before do
         if self.class.opts[:bridgetown_site]
           # The site had previously been initialized via the bridgetown_ssr plugin
           Bridgetown::Current.site ||= self.class.opts[:bridgetown_site]
@@ -47,14 +48,12 @@ module Bridgetown
         Bridgetown::Current.preloaded_configuration ||=
           self.class.opts[:bridgetown_preloaded_config]
 
-        r.public
+        request.public
 
-        r.root do
+        request.root do
           output_folder = Bridgetown::Current.preloaded_configuration.destination
           File.read(File.join(output_folder, "index.html"))
         end
-
-        super
       end
 
       # Helper shorthand for Bridgetown::Current.site

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

@@ -2,6 +2,12 @@
 
 module Bridgetown
   module Rack
+    @interrupted = false
+
+    class << self
+      attr_accessor :interrupted
+    end
+
     class Routes
       class << self
         attr_accessor :tracked_subclasses, :router_block
@@ -37,7 +43,7 @@ module Bridgetown
         def start!(roda_app)
           if Bridgetown.env.development? &&
               !Bridgetown::Current.preloaded_configuration.skip_live_reload
-            setup_live_reload roda_app.request
+            setup_live_reload roda_app
           end
 
           Bridgetown::Rack::Routes.tracked_subclasses&.each_value do |klass|
@@ -51,15 +57,31 @@ module Bridgetown
           nil
         end
 
-        def setup_live_reload(request)
-          request.get "_bridgetown/live_reload" do
-            {
-              last_mod: File.stat(
-                File.join(Bridgetown::Current.preloaded_configuration.destination, "index.html")
-              ).mtime.to_i,
-            }
-          rescue StandardError => e
-            { last_mod: 0, error: e.message }
+        def setup_live_reload(app) # rubocop:disable Metrics/AbcSize
+          sleep_interval = 0.2
+          file_to_check = File.join(app.class.opts[:bridgetown_preloaded_config].destination,
+                                    "index.html")
+
+          app.request.get "_bridgetown/live_reload" do
+            app.response["Content-Type"] = "text/event-stream"
+
+            @_mod = File.exist?(file_to_check) ? File.stat(file_to_check).mtime.to_i : 0
+            app.stream async: true do |out|
+              # 5 second intervals so Puma's threads aren't all exausted
+              (5 / sleep_interval).to_i.times do
+                break if Bridgetown::Rack.interrupted
+
+                new_mod = File.exist?(file_to_check) ? File.stat(file_to_check).mtime.to_i : 0
+                if @_mod < new_mod
+                  out << "data: reloaded!\n\n"
+                  break
+                else
+                  out << "data: #{new_mod}\n\n"
+                end
+
+                sleep sleep_interval
+              end
+            end
           end
         end
       end
@@ -86,3 +108,15 @@ module Bridgetown
     end
   end
 end
+
+if Bridgetown.env.development? &&
+    !Bridgetown::Current.preloaded_configuration.skip_live_reload
+  Puma::Launcher.class_eval do
+    alias_method :_old_stop, :stop
+    def stop
+      Bridgetown::Rack.interrupted = true
+
+      _old_stop
+    end
+  end
+end

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

@@ -2,6 +2,8 @@
 
 require "roda/plugins/public"
 
+# NOTE: once this upstreamed PR is merged in we can remove this file.
+# https://github.com/jeremyevans/roda/pull/215
 Roda::RodaPlugins::Public::RequestMethods.module_eval do
   SPLIT = Regexp.union(*[File::SEPARATOR, File::ALT_SEPARATOR].compact) # rubocop:disable Lint/ConstantDefinitionInBlock
   def public_path_segments(path) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity

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

@@ -30,7 +30,7 @@ module Bridgetown
       def initialize(model:)
         @model = model
         @site = model.site
-        @data = front_matter_defaults
+        @data = collection.data? ? HashWithDotAccess::Hash.new : front_matter_defaults
 
         trigger_hooks :post_init
       end
@@ -284,12 +284,14 @@ module Bridgetown
         collection.resources[pos + 1] if pos && pos < collection.resources.length - 1
       end
       alias_method :next_doc, :next_resource
+      alias_method :next, :next_resource
 
       def previous_resource
         pos = collection.resources.index { |item| item.equal?(self) }
         collection.resources[pos - 1] if pos&.positive?
       end
       alias_method :previous_doc, :previous_resource
+      alias_method :previous, :previous_resource
 
       private
 

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

@@ -3,6 +3,8 @@
 module Bridgetown
   module Resource
     class Transformer
+      include Transformable
+
       # @return [Array<Hash>]
       attr_reader :conversions
 
@@ -30,10 +32,18 @@ module Bridgetown
         permalink_ext || output_ext
       end
 
-      def process!
+      def process! # rubocop:disable Metrics/AbcSize
         Bridgetown.logger.debug "Transforming:", resource.relative_path
         resource.around_hook :render do
-          run_conversions
+          resource.content = transform_content(resource) do |converter, index, output|
+            conversions[index] = {
+              type: :content,
+              converter: converter,
+              output: Bridgetown.env.production? ? nil : output,
+              output_ext: conversions[index]&.dig(:output_ext) ||
+                converter.output_ext(resource.extname),
+            }
+          end
           resource.place_in_layout? ? place_into_layouts : resource.output = resource.content.dup
         end
       end
@@ -85,95 +95,21 @@ module Bridgetown
           .fetch(:output_ext)
       end
 
-      # @return [Array<Bridgetown::Layout>]
-      def validated_layouts
-        layout = site.layouts[resource.data.layout]
-        warn_on_missing_layout layout, resource.data.layout
-
-        layout_list = Set.new([layout])
-        while layout
-          layout_name = layout.data.layout
-          layout = site.layouts[layout_name]
-          warn_on_missing_layout layout, layout_name
-
-          layout_list << layout
-        end
-
-        layout_list.to_a.compact
-      end
-
-      def warn_on_missing_layout(layout, layout_name)
-        return unless layout.nil? && layout_name
-
-        Bridgetown.logger.warn(
-          "Build Warning:",
-          "Layout '#{layout_name}' requested via #{resource.relative_path} does not exist."
-        )
-      end
-
-      ### Transformation Actions
-
-      def run_conversions # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-        input = resource.content.to_s
-
-        # @param content [String]
-        # @param converter [Bridgetown::Converter]
-        resource.content = converters.each_with_index.inject(input) do |content, (converter, index)|
-          output = if converter.method(:convert).arity == 1
-                     converter.convert content
-                   else
-                     converter.convert content, resource
-                   end
-          conversions[index] = {
-            type: :content,
-            converter: converter,
-            output: Bridgetown.env.production? ? nil : output,
-            output_ext: conversions[index]&.dig(:output_ext) ||
-              converter.output_ext(resource.extname),
-          }
-          output.html_safe
-        rescue StandardError => e
-          Bridgetown.logger.error "Conversion error:",
-                                  "#{converter.class} encountered an error while "\
-                                  "converting `#{resource.relative_path}'"
-          raise e
-        end
-      end
-
       def place_into_layouts
         Bridgetown.logger.debug "Placing in Layouts:", resource.relative_path
         output = resource.content.dup
-        validated_layouts.each do |layout|
-          output = run_layout_conversions layout, output
+        site.validated_layouts_for(resource, resource.data.layout).each do |layout|
+          output = transform_with_layout(layout, output, resource) do |converter, layout_output|
+            conversions << {
+              type: :layout,
+              layout: layout,
+              converter: converter,
+              output: Bridgetown.env.production? ? nil : layout_output,
+            }
+          end
         end
         resource.output = output
       end
-
-      def run_layout_conversions(layout, output)
-        layout_converters = site.matched_converters_for_convertible(layout)
-        layout_input = layout.content.dup
-
-        layout_converters.inject(layout_input) do |content, converter|
-          next(content) unless [2, -2].include?(converter.method(:convert).arity) # rubocop:disable Performance/CollectionLiteralInLoop
-
-          layout.current_document = resource
-          layout.current_document_output = output
-          layout_output = converter.convert content, layout
-
-          conversions << {
-            type: :layout,
-            layout: layout,
-            converter: converter,
-            output: Bridgetown.env.production? ? nil : layout_output,
-          }
-          layout_output
-        rescue StandardError => e
-          Bridgetown.logger.error "Conversion error:",
-                                  "#{converter.class} encountered an error while "\
-                                  "converting `#{resource.relative_path}'"
-          raise e
-        end
-      end
     end
   end
 end

data/lib/bridgetown-core/ruby_template_view.rb

@@ -73,6 +73,10 @@ 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
+
     private
 
     def _render_statement(component, options)
@@ -103,5 +107,12 @@ module Bridgetown
         strict_variables: site.config["liquid"]["strict_variables"],
       }
     end
+
+    def _partial_path(partial_name, ext)
+      partial_name = partial_name.split("/").tap { _1.last.prepend("_") }.join("/")
+
+      # TODO: see if there's a workaround for this to speed up performance
+      site.in_source_dir(site.config[:partials_dir], "#{partial_name}.#{ext}")
+    end
   end
 end

data/lib/bridgetown-core/site.rb

@@ -53,6 +53,7 @@ module Bridgetown
       @reader          = Reader.new(self)
       @liquid_renderer = LiquidRenderer.new(self)
 
+      Bridgetown::Cache.base_cache["site_tmp"] = {}.with_dot_access
       ensure_not_in_dest
 
       Bridgetown::Current.site = self
@@ -74,6 +75,10 @@ module Bridgetown
       end
     end
 
+    def tmp_cache
+      Bridgetown::Cache.base_cache["site_tmp"]
+    end
+
     def inspect
       "#<Bridgetown::Site #{metadata.inspect.delete_prefix("{").delete_suffix("}")}>"
     end

data/lib/bridgetown-core/tags/{webpack_path.rb → asset_path.rb}

@@ -2,9 +2,9 @@
 
 module Bridgetown
   module Tags
-    # A helper class to help find the path to webpack asset inside of a webpack
+    # A helper class to help find the path to assets inside of a webpack or esbuild
     # manifest file.
-    class WebpackPath < Liquid::Tag
+    class AssetPath < Liquid::Tag
       # @param tag_name [String] Name of the tag
       # @param asset_type [String] The type of asset to parse (js, css)
       # @param options [Hash] An options hash
@@ -17,23 +17,21 @@ module Bridgetown
         @asset_type = asset_type.strip
       end
 
-      # Render an asset path based on the Webpack manifest file
+      # Render an asset path based on the frontend manifest file
       # @param context [Liquid::Context] Context passed to the tag
       #
       # @return [String] Returns "MISSING_WEBPACK_MANIFEST" if the manifest
-      # file isn't found
+      #   file isn't found
       # @return [String] Returns a blank string if the asset isn't found
       # @return [String] Returns the path to the asset if no issues parsing
-      #
-      # @raise [WebpackAssetError] if unable to find css or js in the manifest
-      # file
       def render(context)
         @context = context
         site = context.registers[:site]
-        Bridgetown::Utils.parse_webpack_manifest_file(site, @asset_type) || ""
+        Bridgetown::Utils.parse_frontend_manifest_file(site, @asset_type) || ""
       end
     end
   end
 end
 
-Liquid::Template.register_tag("webpack_path", Bridgetown::Tags::WebpackPath)
+Liquid::Template.register_tag("asset_path", Bridgetown::Tags::AssetPath)
+Liquid::Template.register_tag("webpack_path", Bridgetown::Tags::AssetPath)

data/lib/bridgetown-core/tasks/bridgetown_tasks.rake

@@ -15,7 +15,8 @@ namespace :frontend do
       run_process "Frontend", :yellow, "bundle exec bridgetown frontend:dev"
     end
     if sidecar
-      sleep 4 # give Webpack time to boot before returning control to the start command
+      # give FE bundler time to boot before returning control to the start command
+      sleep Bridgetown::Utils.frontend_bundler_type == :esbuild ? 3 : 4
     else
       trap("INT") do
         Bridgetown::Utils::Aux.kill_processes

data/lib/bridgetown-core/utils/loaders_manager.rb

@@ -33,6 +33,12 @@ module Bridgetown
           return
         end
 
+        if defined?(ActiveSupport::RubyFeatures) && ActiveSupport::RubyFeatures::CLASS_SUBCLASSES
+          ActiveSupport::DescendantsTracker.clear([value.superclass])
+          return
+        end
+
+        # TODO: this could probably be refactored to work like the above
         ActiveSupport::DescendantsTracker.class_variable_get(
           :@@direct_descendants
         )[value.superclass]&.reject! { _1 == value }