bridgetown-core 1.3.4 → 2.0.0.beta1

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

@@ -1,103 +1,119 @@
 # frozen_string_literal: true
 
+require "rackup/server"
+
 module Bridgetown
+  class Server < Rackup::Server
+    def start(after_stop_callback = nil)
+      trap(:INT) { exit }
+      super()
+    ensure
+      after_stop_callback&.call
+    end
+
+    def name
+      server.to_s.split("::").last
+    end
+
+    def using_puma?
+      name == "Puma"
+    end
+
+    def serveable?
+      server
+      true
+    rescue LoadError, NameError
+      false
+    end
+  end
+
   module Commands
     class Start < Thor::Group
       extend BuildOptions
       extend Summarizable
       include ConfigurationOverridable
+      include Inclusive
 
       Registrations.register do
         register(Start, "start", "start", Start.summary)
         register(Start, "dev", "dev", "Alias of start")
       end
 
-      class_option :bind, aliases: "-B", desc: "URI for Puma to bind to (start with tcp://)"
+      class_option :port,
+                   aliases: "-P",
+                   type: :numeric,
+                   default: 4000,
+                   desc: "Serve your site on the specified port. Defaults to 4000."
+      class_option :bind,
+                   aliases: "-B",
+                   type: :string,
+                   default: "0.0.0.0",
+                   desc: "URL for the server to bind to."
       class_option :skip_frontend,
                    type: :boolean,
-                   desc: "Don't load the frontend bundler (always true for production)"
+                   desc: "Don't load the frontend bundler (always true for production)."
       class_option :skip_live_reload,
                    type: :boolean,
-                   desc: "Don't use the live reload functionality (always true for production)"
+                   desc: "Don't use the live reload functionality (always true for production)."
 
       def self.banner
         "bridgetown start [options]"
       end
-      summary "Start the Puma server, frontend bundler, and Bridgetown watcher"
+      summary "Start the web server, frontend bundler, and Bridgetown watcher"
 
-      def start # rubocop:todo Metrics/PerceivedComplexity
+      def start
+        pid_tracker = packages[Bridgetown::Foundation::Packages::PidTracker]
         Bridgetown.logger.writer.enable_prefix
         Bridgetown::Commands::Build.print_startup_message
         sleep 0.25
 
-        begin
-          require("puma/detect")
-        rescue LoadError
-          raise "** Puma server gem not found. Check your Gemfile and Bundler env? **"
-        end
-
         options = Thor::CoreExt::HashWithIndifferentAccess.new(self.options)
-        options[:using_puma] = true
+        options[:start_command] = true
 
         # Load Bridgetown configuration into thread memory
         bt_options = configuration_with_overrides(options)
+        port = ENV.fetch("BRIDGETOWN_PORT", bt_options.port)
+        # TODO: support Puma serving HTTPS directly?
+        bt_bound_url = "http://#{bt_options.bind}:#{port}"
 
         # Set a local site URL in the config if one is not available
-        if Bridgetown.env.development? && !options["url"]
-          scheme = bt_options.bind&.split("://")&.first == "ssl" ? "https" : "http"
-          port = bt_options.bind&.split(":")&.last || ENV["BRIDGETOWN_PORT"] || 4000
-          bt_options.url = "#{scheme}://localhost:#{port}"
-        end
+        bt_options.url = bt_bound_url if Bridgetown.env.development? && !options["url"]
 
-        puma_pid =
-          Process.fork do
-            require "puma/cli"
-
-            Puma::Runner.class_eval do
-              def output_header(mode)
-                log "* Puma version: #{Puma::Const::PUMA_VERSION} (#{ruby_engine}) (\"#{Puma::Const::CODE_NAME}\")" # rubocop:disable Layout/LineLength
-                if mode == "cluster"
-                  log "* Cluster Master PID: #{Process.pid}"
-                else
-                  log "* PID: #{Process.pid}"
-                end
-              end
-            end
+        Bridgetown::Server.new({
+          Host: bt_options.bind,
+          Port: port,
+          config: "config.ru",
+        }).tap do |server|
+          if server.serveable?
+            pid_tracker.create_pid_dir
 
-            puma_args = []
-            if bt_options[:bind]
-              puma_args << "--bind"
-              puma_args << bt_options[:bind]
-            end
+            bt_options.skip_live_reload = !server.using_puma?
 
-            cli = Puma::CLI.new puma_args
-            cli.launcher.events.on_stopped do
+            build_args = ["-w"] + ARGV.reject { |arg| arg == "start" }
+            build_pid = Process.fork { Bridgetown::Commands::Build.start(build_args) }
+            pid_tracker.add_pid(build_pid, file: :bridgetown)
+
+            after_stop_callback = -> {
+              say "Stopping Bridgetown server..."
               Bridgetown::Hooks.trigger :site, :server_shutdown
-            end
-            cli.run
-          end
+              Process.kill "SIGINT", build_pid
+              pid_tracker.remove_pidfile :bridgetown
 
-        begin
-          Signal.trap("TERM") do
-            Process.kill "SIGINT", puma_pid
-            sleep 0.5 # let it breathe
-            exit 0 # this runs the ensure block below
-          end
+              # Shut down the frontend bundler etc. if they're running
+              unless Bridgetown.env.production? || bt_options[:skip_frontend]
+                Bridgetown::Utils::Aux.kill_processes
+              end
+            }
 
-          Process.setproctitle("bridgetown #{Bridgetown::VERSION} [#{File.basename(Dir.pwd)}]")
-
-          build_args = ["-w"] + ARGV.reject { |arg| arg == "start" }
-          Bridgetown::Commands::Build.start(build_args)
-        rescue StandardError => e
-          Process.kill "SIGINT", puma_pid
-          sleep 0.5
-          raise e
-        ensure
-          # Shut down webpack, browsersync, etc. if they're running
-          Bridgetown::Utils::Aux.kill_processes
-        end
+            Bridgetown.logger.info ""
+            Bridgetown.logger.info "Booting #{server.name} at:", bt_bound_url.to_s.magenta
+            Bridgetown.logger.info ""
 
-        sleep 0.5 # finish cleaning up
+            server.start(after_stop_callback)
+          else
+            say "Unable to find a Rack server."
+          end
+        end
       end
     end
   end

data/lib/bridgetown-core/component.rb

@@ -2,6 +2,8 @@
 
 module Bridgetown
   class Component
+    using Bridgetown::Refinements
+    include Bridgetown::Streamlined
     extend Forwardable
 
     def_delegators :@view_context, :liquid_render, :partial
@@ -29,20 +31,20 @@ module Bridgetown
       # TODO: make this extensible
       #
       # @param ext [String] erb, slim, etc.
-      def renderer_for_ext(ext, &block)
+      def renderer_for_ext(ext, &)
         @_tmpl ||= case ext.to_s
                    when "erb"
                      Tilt::ErubiTemplate.new(component_template_path,
                                              outvar: "@_erbout",
                                              bufval: "Bridgetown::OutputBuffer.new",
                                              engine_class: Bridgetown::ERBEngine,
-                                             &block)
+                                             &)
                    when "serb"
-                     Tilt::SerbeaTemplate.new(component_template_path, &block)
+                     Tilt::SerbeaTemplate.new(component_template_path, &)
                    when "slim" # requires bridgetown-slim
-                     Slim::Template.new(component_template_path, &block)
+                     Slim::Template.new(component_template_path, &)
                    when "haml" # requires bridgetown-haml
-                     Tilt::HamlTemplate.new(component_template_path, &block)
+                     Tilt::HamlTemplate.new(component_template_path, &)
                    else
                      raise NameError
                    end
@@ -91,7 +93,7 @@ module Bridgetown
       end
 
       def path_for_errors
-        component_template_path
+        File.basename(component_template_path)
       rescue RuntimeError
         source_location
       end
@@ -121,7 +123,7 @@ module Bridgetown
       name = name.to_s
       slots.reject! { _1.name == name } if replace
 
-      slots << Slot.new(name: name, content: content, context: self, transform: false)
+      slots << Slot.new(name:, content:, context: self, transform: false)
 
       nil
     end
@@ -179,6 +181,12 @@ module Bridgetown
       @_content_block = block
 
       if render?
+        if helpers.site.config.fast_refresh
+          signal = helpers.site.tmp_cache["comp-signal:#{self.class.source_location}"] ||=
+            Signalize.signal(1)
+          # subscribe so resources are attached to this component within effect
+          signal.value
+        end
         before_render
         template
       else
@@ -194,7 +202,7 @@ module Bridgetown
     # Subclasses can override this method to return a string from their own
     # template handling.
     def template
-      call || _renderer.render(self)
+      (method(:call).arity.zero? ? call : nil) || _renderer.render(self)
     end
 
     # Typically not used but here as a compatibility nod toward ViewComponent.
@@ -221,14 +229,12 @@ module Bridgetown
     end
 
     def helpers
-      @helpers ||= Bridgetown::RubyTemplateView::Helpers.new(
-        self, view_context&.site || Bridgetown::Current.site
-      )
+      @helpers ||= Bridgetown::RubyTemplateView::Helpers.new(self, view_context&.site)
     end
 
-    def method_missing(method, *args, **kwargs, &block)
+    def method_missing(method, ...)
       if helpers.respond_to?(method.to_sym)
-        helpers.send method.to_sym, *args, **kwargs, &block
+        helpers.send(method.to_sym, ...)
       else
         super
       end

data/lib/bridgetown-core/concerns/layout_placeable.rb

@@ -7,7 +7,7 @@ module Bridgetown
     # Returns false if the document is an asset file or if the front matter
     #   specifies `layout: none`
     def place_in_layout?
-      !(yaml_file? || no_layout?)
+      no_layout?.!
     end
 
     def no_layout?

data/lib/bridgetown-core/concerns/prioritizable.rb

@@ -26,11 +26,21 @@ module Bridgetown
       def <=>(other)
         priorities[other.priority] <=> priorities[priority]
       end
+
+      # Return either this class' priorities or the superclass which has them (if any)
+      def priorities
+        return @priorities if @priorities
+
+        superclass.priorities if superclass.respond_to?(:priorities)
+      end
+
+      def priorities=(val)
+        @priorities = val
+      end
     end
 
     def self.included(klass)
       klass.extend ClassMethods
-      klass.class_attribute :priorities, instance_accessor: false
     end
 
     # Spaceship is priority [higher -> lower]

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

@@ -12,6 +12,7 @@ class Bridgetown::Site
       configure_component_paths
       configure_file_read_opts
 
+      # TODO: see if we can just get rid of this. It's only used by GeneratedPage
       self.permalink_style = (config["permalink"] || "pretty").to_sym
     end
 
@@ -28,40 +29,28 @@ class Bridgetown::Site
     end
     alias_method :dest, :destination
 
-    def uses_resource?
-      Bridgetown::Deprecator.deprecation_message(
-        "The Site#uses_resource? method will be removed in the next version"
-      )
-      true
-    end
-
     # Returns a base path from which the site is served (aka `/cool-site`) or
     # `/` if served from root.
     #
     # @param strip_slash_only [Boolean] set to true if you wish "/" to be returned as ""
     # @return [String]
     def base_path(strip_slash_only: false)
-      (config[:base_path] || config[:baseurl]).then do |path|
+      config[:base_path].then do |path|
         strip_slash_only ? path.to_s.sub(%r{^/$}, "") : path
       end
     end
 
-    def baseurl
-      Bridgetown::Deprecator.deprecation_message "Site#baseurl is now Site#base_path"
-      base_path(strip_slash_only: true).presence
-    end
-
     def defaults_reader
       @defaults_reader ||= Bridgetown::DefaultsReader.new(self)
     end
 
-    # Returns the current instance of {FrontmatterDefaults} or
-    #   creates a new instance {FrontmatterDefaults} if it doesn't already exist.
+    # Returns the current instance of {FrontMatter::Defaults} or
+    #   creates a new instance {FrontMatter::Defaults} if it doesn't already exist.
     #
-    # @return [FrontmatterDefaults]
-    #   Returns an instance of {FrontmatterDefaults}
+    # @return [FrontMatter::Defaults]
+    #   Returns an instance of {FrontMatter::Defaults}
     def frontmatter_defaults
-      @frontmatter_defaults ||= Bridgetown::FrontmatterDefaults.new(self)
+      @frontmatter_defaults ||= Bridgetown::FrontMatter::Defaults.new(self)
     end
 
     # Prefix a path or paths with the {#root_dir} directory.

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

@@ -3,6 +3,8 @@
 class Bridgetown::Site
   # Content is king!
   module Content
+    using Bridgetown::Refinements
+
     def resources_grouped_by_taxonomy(taxonomy)
       data.site_taxonomies_hash ||= {}
       data.site_taxonomies_hash[taxonomy.label] ||= taxonomy.terms.transform_values do |terms|
@@ -24,11 +26,10 @@ class Bridgetown::Site
       taxonomies.category
     end
 
-    # Returns the value of `data["site_metadata"]` or creates a new instance of
-    #   `HashWithDotAccess::Hash`
-    # @return [Hash] Returns a hash of site metadata
+    # Returns the contents of the site metadata file or a blank hash
+    # @return [HashWithDotAccess::Hash] Returns a hash of site metadata
     def metadata
-      data["site_metadata"] ||= HashWithDotAccess::Hash.new
+      signals["site_metadata"] ||= HashWithDotAccess::Hash.new
     end
 
     # The Hash payload containing site-wide data.
@@ -46,10 +47,10 @@ class Bridgetown::Site
     #
     #  If `config["collections"]` is not specified, a blank hash is returned.
     #
-    # @return [Hash{String, Symbol => Collection}] A Hash
+    # @return [HashWithDotAccess::Hash{String, Symbol => Collection}] A Hash
     #   containing a collection name-to-instance pairs.
     #
-    # @return [Hash] Returns a blank hash if no items found
+    # @return [HashWithDotAccess::Hash] Returns a blank hash if no items found
     def collections
       @collections ||= collection_names.each_with_object(
         HashWithDotAccess::Hash.new
@@ -67,7 +68,7 @@ class Bridgetown::Site
 
     # @return [Array<Bridgetown::Resource::TaxonomyType>]
     def taxonomy_types
-      @taxonomy_types ||= config.taxonomies.to_h do |label, key_or_metadata|
+      @taxonomy_types ||= config.taxonomies.to_dot_h do |label, key_or_metadata|
         key = key_or_metadata
         tax_metadata = if key_or_metadata.is_a? Hash
                          key = key_or_metadata["key"]
@@ -77,9 +78,9 @@ class Bridgetown::Site
                        end
 
         [label, Bridgetown::Resource::TaxonomyType.new(
-          site: self, label: label, key: key, metadata: tax_metadata
+          site: self, label:, key:, metadata: tax_metadata
         ),]
-      end.with_dot_access
+      end
     end
 
     # Get all loaded resources.

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

@@ -25,11 +25,9 @@ class Bridgetown::Site
 
         next unless ENV["BRIDGETOWN_LOG_LEVEL"] == "debug"
 
-        generator_name = if generator.class.respond_to?(:custom_name)
-                           generator.class.custom_name
-                         else
+        generator_name = generator.class.respond_to?(:custom_name) ?
+                           generator.class.custom_name :
                            generator.class.name
-                         end
         Bridgetown.logger.debug "Generating:",
                                 "#{generator_name} finished in #{Time.now - start} seconds."
       end
@@ -61,8 +59,8 @@ class Bridgetown::Site
     # @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
+    def on(event, reloadable: false, &)
+      Bridgetown::Hooks.register_one :site, event, reloadable:, &
     end
   end
 end

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

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+class Bridgetown::Site
+  module FastRefreshable
+    using Bridgetown::Refinements
+
+    def fast_refresh(paths = [], reload_if_needed: false) # rubocop:todo Metrics
+      FileUtils.rm_f(Bridgetown.build_errors_path)
+
+      @fast_refresh_ordering = 0
+      full_abort = false
+      found_gen_pages = false
+      paths.each do |path|
+        res = resources.find do |resource|
+          resource.id.start_with?("repo://") && in_source_dir(resource.relative_path) == path
+        end
+
+        layouts_to_reload = Set.new
+        locate_resource_layouts_and_partials_for_fash_refresh(path, layouts_to_reload) unless res
+
+        locate_components_for_fast_refresh(path) unless res
+
+        pages = locate_layouts_and_pages_for_fast_refresh(path, layouts_to_reload)
+
+        layouts_to_reload.each do |layout|
+          layouts[layout.label] = Bridgetown::Layout.new(
+            self, layout.instance_variable_get(:@base), layout.name
+          )
+        end
+        liquid_renderer.reset unless layouts_to_reload.empty?
+        next unless res || !pages.empty?
+
+        unless pages.empty?
+          found_gen_pages = true
+          mark_original_page_resources_for_fast_refresh(pages)
+          next
+        end
+
+        res.prepare_for_fast_refresh!.tap { full_abort = true unless _1 }
+        next unless res.collection.data?
+
+        res.collection.merge_data_resources.each do |k, v|
+          data[k] = v
+          signals[k] = v
+        end
+      end
+
+      marked_resources = resources.select(&:fast_refresh_order).sort_by(&:fast_refresh_order)
+      if full_abort || (marked_resources.empty? && !found_gen_pages)
+        # Darn, a full reload is needed (unless we're on a super-fast track)
+        if reload_if_needed
+          Bridgetown::Hooks.trigger :site, :pre_reload, self, paths
+          Bridgetown::Hooks.clear_reloadable_hooks
+          loaders_manager.reload_loaders
+          Bridgetown::Hooks.trigger :site, :post_reload, self, paths
+          process # bring out the big guns
+        end
+        return
+      end
+
+      Bridgetown::Hooks.trigger :site, :fast_refresh, self
+
+      transform_resources_for_fast_refresh(marked_resources, found_gen_pages)
+      transform_generated_pages_for_fast_refresh
+
+      FileUtils.touch(in_destination_dir("index.html"))
+
+      Bridgetown::Hooks.trigger :site, :post_write, self
+    end
+
+    private
+
+    def locate_resource_layouts_and_partials_for_fash_refresh(path, layouts_to_reload) # rubocop:todo Metrics/AbcSize
+      resources.each do |resource|
+        next unless resource.data.layout
+
+        res_layouts = validated_layouts_for(resource, resource.data.layout)
+          .select { _1.path == path }
+        next unless res_layouts.length.positive?
+
+        res_layouts.each { layouts_to_reload << _1 }
+        resource.mark_for_fast_refresh!
+      end
+
+      tmp_cache.each_key do |key|
+        next unless key.delete_prefix("partial-tmpl:") == path
+
+        tmp_cache[key].template = nil
+        tmp_cache[key].signal.value += 1
+      end
+    end
+
+    def locate_components_for_fast_refresh(path)
+      comp = Bridgetown::Component.descendants.find do |item|
+        item.component_template_path == path || item.source_location == path
+      rescue StandardError # rubocop:disable Lint/SuppressedException
+      end
+      return unless comp
+
+      tmp_cache["comp-signal:#{comp.source_location}"]&.value += 1
+
+      # brute force reload all components for now
+      load_path = config.components_load_paths.last
+      loader = loaders_manager.loaders[load_path]
+      Bridgetown::Hooks.trigger :loader, :pre_reload, loader, load_path
+      loader.reload
+      loader.eager_load if config.eager_load_paths.include?(load_path)
+      Bridgetown::Hooks.trigger :loader, :post_reload, loader, load_path
+    end
+
+    def locate_layouts_and_pages_for_fast_refresh(path, layouts_to_reload)
+      generated_pages.select do |pg|
+        next unless pg.respond_to?(:page_to_copy)
+
+        found = in_source_dir(pg.original_resource.relative_path) == path
+        next true if found
+        next false unless pg.data.layout
+
+        pg_layouts = validated_layouts_for(pg, pg.data.layout)
+          .select { _1.path == path }
+        next false unless pg_layouts.length.positive?
+
+        pg_layouts.each { layouts_to_reload << _1 }
+        true
+      end
+    end
+
+    def mark_original_page_resources_for_fast_refresh(pages)
+      pages.each do |page|
+        res = page.original_resource
+        res.prepare_for_fast_refresh! unless res.fast_refresh_order
+        page.mark_for_fast_refresh!
+      end
+    end
+
+    def transform_resources_for_fast_refresh(marked_resources, found_gen_pages)
+      marked_resources.each { _1.transform!.write }
+      number_of_resources = marked_resources.length
+      number_of_resources += 1 if found_gen_pages
+      Bridgetown.logger.info(
+        "⚡️",
+        "#{number_of_resources} resource#{"s" if number_of_resources > 1} fast refreshed"
+      )
+    end
+
+    def transform_generated_pages_for_fast_refresh
+      marked_generated = generated_pages.select(&:fast_refresh_order).sort_by(&:fast_refresh_order)
+      return if marked_generated.empty?
+
+      marked_generated.each do |page|
+        page.fast_refresh! if page.respond_to?(:fast_refresh!)
+        page.transform!.write(dest)
+      end
+      number_of_pages = marked_generated.length
+      Bridgetown.logger.info(
+        "⚡️",
+        "#{number_of_pages} generated page#{"s" if number_of_pages > 1} fast refreshed"
+      )
+    end
+  end
+end

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

@@ -35,6 +35,7 @@ class Bridgetown::Site
       self.generated_pages = []
       self.static_files = []
       self.data = HashWithDotAccess::Hash.new unless soft
+      @fast_refresh_ordering = 0 if config.fast_refresh
       @frontend_manifest = nil
       @collections = nil
       @documents = nil

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

@@ -26,19 +26,43 @@ class Bridgetown::Site
       end
     end
 
-    def matched_converters_for_convertible(convertible)
+    def matched_converters_for_convertible(convertible) # rubocop:todo Metrics
       @layout_converters ||= {}
 
       if convertible.is_a?(Bridgetown::Layout) && @layout_converters[convertible]
         return @layout_converters[convertible]
       end
 
-      matches = converters.select do |converter|
-        if converter.method(:matches).arity == 1
-          converter.matches(convertible.extname)
-        else
-          converter.matches(convertible.extname, convertible)
+      if convertible.is_a?(Bridgetown::GeneratedPage) && convertible.original_resource
+        convertible = convertible.original_resource
+      end
+
+      directly_matched_template_engine = nil
+      matches = converters.map do |converter|
+        result = [
+          converter,
+          converter.matches(convertible.extname, convertible),
+          converter.determine_template_engine(convertible),
+        ]
+
+        directly_matched_template_engine = converter if result[1] && converter.class.template_engine
+
+        result
+      end
+
+      matches = matches.filter_map do |result|
+        converter, ext_matched, engine_matched = result
+        next nil if !ext_matched && !engine_matched
+
+        next nil if !ext_matched &&
+          engine_matched && directly_matched_template_engine &&
+          converter != directly_matched_template_engine
+
+        if !convertible.data["template_engine"] && engine_matched
+          convertible.data["template_engine"] = converter.class.template_engine
         end
+
+        converter
       end
 
       @layout_converters[convertible] = matches if convertible.is_a?(Bridgetown::Layout)
@@ -85,7 +109,7 @@ class Bridgetown::Site
     end
 
     # Renders a content item while ensuring site locale is set if the data is available.
-    # @param item [Document, Page, Bridgetown::Resource::Base] The item to render
+    # @param item [Bridgetown::Resource::Base] The item to render
     # @yield Runs the block in between locale setting and resetting
     # @return [void]
     def render_with_locale(item)