bridgetown-core 1.0.0.alpha10 → 1.0.0.alpha11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b529c24ff76bbed44607ecbef4d5dd66414bded0cb8d1640cfb6945d1ae7e9c
-  data.tar.gz: 2522b693b676608de3546183310970d7def3e05c6bbdf5561699fc434e4b3f6d
+  metadata.gz: '09c13a3ec4bb37595ede90e5536eca3159812d06c482397d971d1130eab3ceab'
+  data.tar.gz: 48cd4b6488ba57a185e510f00e6986b8514ad33887b7710431c40d9efcae4f45
 SHA512:
-  metadata.gz: a628d623d424930d62deebff57273a72899b6399fc6ce2114410d0b1fa31293d427df9066238646d208c2878d20686a69bce6c80db5e548bee30e1b7c0ed45e3
-  data.tar.gz: 53b3202f0f8858de9ae4ac123750ebe29c873c989f73a1e1a63defd96ebc20c2e7e935c3f88e2c00685fff7e4eec33190b892788331181bf5e2780869b1684dc
+  metadata.gz: '008f32b43e009a8349bc69fe01277c9a7ebdef2c7062d8c0dc331826d0eac394491a75b48892629d5a835eeef12e435c573d4c811ec33441555ec820870157d6'
+  data.tar.gz: b6cf7933d50093c1332b1b39f5764768a3d8cdc3ff91b115e3d31790afa350826815f30e7d3e8c3891ddffea236f40b8e5b52268ec8eb019b4e20f319f1171ef

data/lib/bridgetown-core/collection.rb

@@ -297,12 +297,6 @@ module Bridgetown
       resources << resource if site.config.unpublished || resource.published?
     end
 
-    private
-
-    def container
-      @container ||= site.config["collections_dir"]
-    end
-
     def sort_resources!
       if metadata["sort_by"].is_a?(String)
         sort_resources_by_key!
@@ -312,6 +306,12 @@ module Bridgetown
       resources.reverse! if metadata.sort_direction == "descending"
     end
 
+    private
+
+    def container
+      @container ||= site.config["collections_dir"]
+    end
+
     # A custom sort function based on Schwartzian transform
     # Refer https://byparker.com/blog/2017/schwartzian-transform-faster-sorting/ for details
     def sort_resources_by_key!

data/lib/bridgetown-core/commands/console.rb

@@ -18,6 +18,7 @@ module Bridgetown
       Bridgetown::Hooks.clear_reloadable_hooks
       site.plugin_manager.reload_plugin_files
       site.loaders_manager.reload_loaders
+      Bridgetown::Hooks.trigger :site, :post_reload, site
 
       ConsoleMethods.site_reset(site)
     end

data/lib/bridgetown-core/concerns/site/extensible.rb

@@ -56,5 +56,13 @@ class Bridgetown::Site
         c.new(config)
       end
     end
+
+    # Shorthand for registering a site hook via {Bridgetown::Hooks}
+    # @param event [Symbol] name of the event (`:pre_read`, `:post_render`, etc.)
+    # @yield the block will be called when the event is triggered
+    # @yieldparam site the site which triggered the event hook
+    def on(event, reloadable: false, &block)
+      Bridgetown::Hooks.register_one :site, event, reloadable: reloadable, &block
+    end
   end
 end

data/lib/bridgetown-core/concerns/site/processable.rb

@@ -23,9 +23,9 @@ class Bridgetown::Site
 
     # Reset all in-memory data and content.
     #
-
+    # @param soft [Boolean] if true, persist some state and do a light refresh of layouts and data
     # @return [void]
-    def reset(soft: false)
+    def reset(soft: false) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
       self.time = Time.now
       if config["time"]
         self.time = Bridgetown::Utils.parse_date(
@@ -41,12 +41,30 @@ class Bridgetown::Site
       @documents = nil
       @docs_to_write = nil
       @liquid_renderer.reset
-      frontmatter_defaults.reset unless soft
 
-      Bridgetown::Cache.clear_if_config_changed config unless soft
+      if soft
+        refresh_layouts_and_data
+      else
+        frontmatter_defaults.reset
+        Bridgetown::Cache.clear_if_config_changed config
+      end
+
       Bridgetown::Hooks.trigger :site, (soft ? :after_soft_reset : :after_reset), self
     end
 
+    # Read layouts and merge any new data collection contents into the site data
+    def refresh_layouts_and_data
+      reader.read_layouts
+
+      collections.data.tap do |coll|
+        coll.resources.clear
+        coll.read
+        coll.merge_data_resources.each do |k, v|
+          data[k] = v # refresh site data
+        end
+      end
+    end
+
     # Read data from disk and load it into internal memory.
     # @return [void]
     def read

data/lib/bridgetown-core/concerns/site/ssr.rb

@@ -32,7 +32,7 @@ class Bridgetown::Site
       @ssr_enabled = true
     end
 
-    def ssr_setup(&block) # rubocop:disable Metrics/AbcSize
+    def ssr_setup
       config.serving = true
       Bridgetown::Hooks.trigger :site, :pre_read, self
       defaults_reader.tap do |d|
@@ -46,27 +46,12 @@ class Bridgetown::Site
       end
       Bridgetown::Hooks.trigger :site, :post_read, self
 
-      hook = block&.(self) # provide additional setup hook
+      yield self if block_given? # provide additional setup hook
       return if Bridgetown.env.production?
 
-      @ssr_reload_hook = hook if hook.is_a?(Proc) && hook.lambda?
       Bridgetown::Watcher.watch(self, config)
     end
 
-    def ssr_reload
-      reset soft: true
-      reader.read_layouts
-
-      collections.data.tap do |coll|
-        coll.resources.clear
-        coll.read
-        coll.merge_data_resources.each do |k, v|
-          data[k] = v
-        end
-      end
-      @ssr_reload_hook.() if @ssr_reload_hook.is_a?(Proc)
-    end
-
     def disable_ssr
       Bridgetown.logger.info "SSR:", "now disabled."
       @ssr_enabled = false

data/lib/bridgetown-core/configurations/minitesting.rb

@@ -82,7 +82,7 @@ create_file "plugins/test_output.rb" do
   <<~RUBY
     module TestOutput
       unless Bridgetown.env.development?
-        Bridgetown::Hooks.register :site, :post_write do
+        Bridgetown::Hooks.register_one :site, :post_write do
           # Load test suite to run on exit
           require "nokogiri"
           Dir["test/**/*.rb"].each { |file| require_relative("../\#{file}") }

data/lib/bridgetown-core/configurations/render/render.yaml.erb

@@ -5,6 +5,9 @@ services:
     buildCommand: bin/bridgetown deploy
     staticPublishPath: ./output
     pullRequestPreviewsEnabled: true
+    envVars:
+      - key: BRIDGETOWN_ENV
+        value: production
     headers:
       - path: /*
         name: X-Frame-Options

data/lib/bridgetown-core/drops/drop.rb

@@ -110,7 +110,7 @@ module Bridgetown
       # underlying data hashes and performs a set union to ensure a list
       # of unique keys for the Drop.
       #
-      # Returns an Array of unique keys for content for the Drop.
+      # @return [Array<String>]
       def keys
         (content_methods |
           mutations.keys |

data/lib/bridgetown-core/drops/resource_drop.rb

@@ -6,7 +6,7 @@ module Bridgetown
       extend Forwardable
 
       NESTED_OBJECT_FIELD_BLACKLIST = %w(
-        content output excerpt next previous
+        content output excerpt next previous next_resource previous_resource
       ).freeze
 
       mutable false
@@ -44,13 +44,15 @@ module Bridgetown
         cmp
       end
 
-      def previous
-        @previous ||= @obj.previous_resource.to_liquid
+      def next_resource
+        @next ||= @obj.next_resource.to_liquid
       end
+      alias_method :next, :next_resource
 
-      def next
-        @next ||= @obj.next_resource.to_liquid
+      def previous_resource
+        @previous ||= @obj.previous_resource.to_liquid
       end
+      alias_method :previous, :previous_resource
 
       # Generate a Hash for use in generating JSON.
       # This is useful if fields need to be cleared before the JSON can generate.
@@ -79,6 +81,27 @@ module Bridgetown
           result[key] = doc[key] unless NESTED_OBJECT_FIELD_BLACKLIST.include?(key)
         end
       end
+
+      # Generates a list of keys with user content as their values.
+      # This gathers up the Drop methods and keys of the mutations and
+      # underlying data hashes and performs a set union to ensure a list
+      # of unique keys for the Drop.
+      #
+      # @return [Array<String>]
+      def keys
+        keys_to_remove = %w[next_resource previous_resource]
+        (content_methods |
+          mutations.keys |
+          fallback_data.keys).flatten.reject do |key|
+          keys_to_remove.include?(key)
+        end
+      end
+
+      # Inspect the drop's keys and values through a JSON representation
+      # of its keys and values.
+      def inspect
+        JSON.pretty_generate hash_for_json
+      end
     end
   end
 end

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

@@ -1,21 +1,21 @@
 # frozen_string_literal: true
 
 # Handles Generated Pages
-Bridgetown::Hooks.register :generated_pages, :post_init, reloadable: false do |page|
+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 :resources, :post_read, reloadable: false do |resource|
+Bridgetown::Hooks.register_one :resources, :post_read, reloadable: false do |resource|
   if resource.data["prototype"].is_a?(Hash)
     Bridgetown::PrototypeGenerator.add_matching_template(resource)
   end
 end
 
 # Ensure sites clear out templates before rebuild
-Bridgetown::Hooks.register :site, :after_reset, reloadable: false do |_site|
+Bridgetown::Hooks.register_one :site, :after_reset, reloadable: false do |_site|
   Bridgetown::PrototypeGenerator.matching_templates.clear
 end
 

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/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/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

@@ -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/utils.rb

@@ -401,30 +401,34 @@ module Bridgetown
       return "" unless Bridgetown.env.development? && !site.config.skip_live_reload
 
       code = <<~JAVASCRIPT
-        let first_mod = 0
-        let connection_errors = 0
-        const checkForReload = () => {
-          fetch("/_bridgetown/live_reload").then(response => {
-            if (response.ok) {
-              response.json().then(data => {
-                const last_mod = data.last_mod
-                if (first_mod === 0) {
-                  first_mod = last_mod
-                } else if (last_mod > first_mod) {
-                  location.reload()
-                }
-                setTimeout(() => checkForReload(), 700)
-              })
+        let lastmod = 0
+        function startReloadConnection() {
+          const evtSource = new EventSource("/_bridgetown/live_reload")
+          evtSource.onmessage = event => {
+            if (event.data == "reloaded!") {
+              location.reload()
             } else {
-              if (connection_errors < 20) setTimeout(() => checkForReload(), 6000)
-              connection_errors++
+              const newmod = Number(event.data)
+              if (lastmod > 0 && newmod > 0 && lastmod < newmod) {
+                location.reload()
+              } else {
+                lastmod = newmod
+              }
             }
-          }).catch((err) => {
-            if (connection_errors < 20) setTimeout(() => checkForReload(), 6000)
-            connection_errors++
-          })
+          }
+          evtSource.onerror = event => {
+            if (evtSource.readyState === 2) {
+              // reconnect with new object
+              evtSource.close()
+              console.warn("Live reload: attempting to reconnect in 3 seconds...")
+
+              setTimeout(() => startReloadConnection(), 3000)
+            }
+          }
         }
-        checkForReload()
+        setTimeout(() => {
+          startReloadConnection()
+        }, 500)
       JAVASCRIPT
 
       %(<script type="module">#{code}</script>).html_safe

data/lib/bridgetown-core/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Bridgetown
-  VERSION = "1.0.0.alpha10"
+  VERSION = "1.0.0.alpha11"
   CODE_NAME = "Pearl"
 end

data/lib/bridgetown-core/watcher.rb

@@ -4,71 +4,102 @@ module Bridgetown
   module Watcher
     extend self
 
-    # Public: Continuously watch for file changes and rebuild the site
-    # whenever a change is detected.
+    # Continuously watch for file changes and rebuild the site whenever a change is detected.
     #
-    # site    - The current site instance
-    # options - A Hash containing the site configuration
-    #
-    # Returns nothing.
+    # @param site [Bridgetown::Site] the current site instance
+    # @param options [Bridgetown::Configuration] the site configuration
     def watch(site, options)
       ENV["LISTEN_GEM_DEBUGGING"] ||= "1" if options["verbose"]
 
-      listener = build_listener(site, options)
-      listener.start
+      listen(site, options)
 
-      Bridgetown.logger.info "Auto-regeneration:", "enabled." unless options[:using_puma]
+      Bridgetown.logger.info "Watcher:", "enabled." unless options[:using_puma]
 
       unless options[:serving]
         trap("INT") do
-          listener.stop
-          Bridgetown.logger.info "", "Halting auto-regeneration."
           exit 0
         end
 
         sleep_forever
       end
     rescue ThreadError
-      # You pressed Ctrl-C, oh my!
+      # NOTE: not sure if this is needed any longer
     end
 
-    private
+    # Return a list of load paths which should be watched for changes
+    #
+    # @param (see #watch)
+    def load_paths_to_watch(site, options)
+      site.plugin_manager.plugins_path.select { |path| Dir.exist?(path) }
+        .then do |paths|
+          (paths + options.autoload_paths).uniq
+        end
+    end
 
-    def build_listener(site, options)
+    # Start a listener to watch for changes and call {#reload_site}
+    #
+    # @param (see #watch)
+    def listen(site, options)
       webpack_path = site.in_root_dir(".bridgetown-webpack")
       FileUtils.mkdir(webpack_path) unless Dir.exist?(webpack_path)
-      plugin_paths_to_watch = site.plugin_manager.plugins_path.select do |path|
-        Dir.exist?(path)
-      end
-
-      paths_to_watch = (plugin_paths_to_watch + options.autoload_paths).uniq
-
       Listen.to(
         options["source"],
         webpack_path,
-        *paths_to_watch,
+        *load_paths_to_watch(site, options),
         ignore: listen_ignore_paths(options),
-        force_polling: options["force_polling"],
-        &listen_handler(site, options)
-      )
-    end
-
-    def listen_handler(site, options)
-      proc do |modified, added, removed|
-        t = Time.now
+        force_polling: options["force_polling"]
+      ) do |modified, added, removed|
         c = modified + added + removed
         n = c.length
 
         unless site.ssr?
-          Bridgetown.logger.info "Regenerating…"
-          Bridgetown.logger.info "", "#{n} file(s) changed at #{t.strftime("%Y-%m-%d %H:%M:%S")}"
-          c.each { |path| Bridgetown.logger.info "", path["#{site.root_dir}/".length..] }
+          Bridgetown.logger.info(
+            "Reloading…",
+            "#{n} file#{"s" if c.length > 1} changed at #{Time.now.strftime("%Y-%m-%d %H:%M:%S")}"
+          )
+          c.each { |path| Bridgetown.logger.info "", "- #{path["#{site.root_dir}/".length..]}" }
         end
 
-        process(site, t, options)
+        reload_site(site, options)
+      end.start
+    end
+
+    # Reload the site including plugins and Zeitwerk autoloaders and process it (unless SSR)
+    #
+    # @param (see #watch)
+    def reload_site(site, options) # rubocop:todo Metrics/MethodLength
+      begin
+        time = Time.now
+        I18n.reload! # make sure any locale files get read again
+        Bridgetown::Current.site = site # needed in SSR mode apparently
+        Bridgetown::Hooks.trigger :site, :pre_reload, site
+        Bridgetown::Hooks.clear_reloadable_hooks
+        site.plugin_manager.reload_plugin_files
+        site.loaders_manager.reload_loaders
+        Bridgetown::Hooks.trigger :site, :post_reload, site
+
+        if site.ssr?
+          site.reset(soft: true)
+          return
+        end
+
+        site.process
+        Bridgetown.logger.info "Done! 🎉", "#{"Completed".green} in less than" \
+                                          " #{(Time.now - time).ceil(2)} seconds."
+      rescue Exception => e
+        Bridgetown.logger.error "Error:", e.message
+
+        if options[:trace]
+          Bridgetown.logger.info e.backtrace.join("\n")
+        else
+          Bridgetown.logger.warn "Backtrace:", "Use the --trace option for more information."
+        end
       end
+      Bridgetown.logger.info ""
     end
 
+    private
+
     def normalize_encoding(obj, desired_encoding)
       case obj
       when Array
@@ -126,32 +157,5 @@ module Bridgetown
     def sleep_forever
       loop { sleep 1000 }
     end
-
-    # @param site [Bridgetown::Site]
-    def process(site, time, options)
-      begin
-        I18n.reload! # make sure any locale files get read again
-        Bridgetown::Current.site = site # needed in SSR mode apparently
-        Bridgetown::Hooks.trigger :site, :pre_reload, site
-        Bridgetown::Hooks.clear_reloadable_hooks
-        site.plugin_manager.reload_plugin_files
-        site.loaders_manager.reload_loaders
-
-        return site.ssr_reload if site.ssr?
-
-        site.process
-        Bridgetown.logger.info "Done! 🎉", "#{"Completed".green} in less than" \
-                                          " #{(Time.now - time).ceil(2)} seconds."
-      rescue Exception => e
-        Bridgetown.logger.error "Error:", e.message
-
-        if options[:trace]
-          Bridgetown.logger.info e.backtrace.join("\n")
-        else
-          Bridgetown.logger.warn "Backtrace:", "Use the --trace option for more information."
-        end
-      end
-      Bridgetown.logger.info ""
-    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bridgetown-core
 version: !ruby/object:Gem::Version
-  version: 1.0.0.alpha10
+  version: 1.0.0.alpha11
 platform: ruby
 authors:
 - Bridgetown Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-11-16 00:00:00.000000000 Z
+date: 2021-11-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel