bridgetown-core 2.0.0.beta3 → 2.0.0.beta4

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

@@ -7,93 +7,53 @@ say_status :minitesting, "Adding test gems and examples"
 append_to_file "Gemfile" do
   <<~GEMS
     \n
-    group :test, optional: true do
-      gem "nokogiri"
+    group :test do
       gem "minitest"
-      gem "minitest-profile"
       gem "minitest-reporters"
-      gem "shoulda"
-      gem "rails-dom-testing"
+      gem "rack-test"
     end
   GEMS
 end
 
-create_file "test/helper.rb" do
-  <<~RUBY
-    require "nokogiri"
-    require "minitest/autorun"
-    require "minitest/reporters"
-    require "minitest/profile"
-    require "shoulda"
-    require "rails-dom-testing"
+gsub_file "Gemfile", '# gem "nokolexbor"', 'gem "nokolexbor"'
 
-    # Report with color.
-    Minitest::Reporters.use! [
-      Minitest::Reporters::DefaultReporter.new(
-        color: true
-      ),
-    ]
-
-    Minitest::Test.class_eval do
-      include Rails::Dom::Testing::Assertions
-
-      def site
-        @site ||= Bridgetown::Current.site
-      end
-
-      def nokogiri(input)
-        input.respond_to?(:output) ? Nokogiri::HTML(input.output) : Nokogiri::HTML(input)
-      end
-
-      def document_root(root)
-        @document_root = root.is_a?(Nokogiri::XML::Document) ? root : nokogiri(root)
-      end
+insert_into_file "Rakefile", after: %(ENV["BRIDGETOWN_ENV"] = "test"\n  Bridgetown::Commands::Build.start\nend\n) do
+  <<~RUBY
 
-      def document_root_element
-        if @document_root.nil?
-          raise "Call `document_root' with a Nokogiri document before testing your assertions"
-        end
-        @document_root
-      end
+    require "minitest/test_task"
+    Minitest::TestTask.create(:test) do |t| # add on to the test task
+      t.warning = false
     end
   RUBY
 end
 
-create_file "test/test_homepage.rb" do
+create_file "test/minitest_helper.rb" do
   <<~RUBY
-    require_relative "./helper"
-
-    class TestHomepage < Minitest::Test
-      context "homepage" do
-        setup do
-          page = site.collections.pages.resources.find { |doc| doc.relative_url == "/" }
-          document_root page
-        end
+    ENV["MT_NO_EXPECTATIONS"] = "true"
+    require "minitest/autorun"
+    require "minitest/reporters"
+    Minitest::Reporters.use! [Minitest::Reporters::ProgressReporter.new]
 
-        should "exist" do
-          assert_select "body"
-        end
-      end
-    end
+    require "bridgetown/test"
   RUBY
 end
 
-create_file "plugins/test_output.rb" do
+create_file "test/test_homepage.rb" do
   <<~RUBY
-    module TestOutput
-      unless Bridgetown.env.development?
-        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}") }
-        rescue LoadError
-          Bridgetown.logger.warn "Testing:", "To run tests, you must first run \`bundle install --with test\`"
-        end
+    require "minitest_helper"
+
+    class TestHomepage < Bridgetown::Test
+      def test_homepage
+        html get "/"
+
+        assert document.query_selector("body")
       end
     end
   RUBY
 end
 
+run "bundle install", env: { "BUNDLE_GEMFILE" => Bundler::SharedHelpers.in_bundle? }
+
 say_status :minitesting, "All set! To get started, look at test/test_homepage.rb and then run \`bin/bridgetown test\`"
 
 # rubocop:enable all

data/lib/bridgetown-core/converters/erb_templates.rb

@@ -119,13 +119,17 @@ module Bridgetown
       def convert(content, convertible)
         erb_view = Bridgetown::ERBView.new(convertible)
 
-        erb_renderer = Tilt::ErubiTemplate.new(
-          convertible.path,
-          line_start(convertible),
-          outvar: "@_erbout",
-          bufval: "Bridgetown::OutputBuffer.new",
-          engine_class: ERBEngine
-        ) { content }
+        erb_renderer =
+          convertible.site.tmp_cache["erb-tmpl:#{convertible.path}:#{content.hash}"] ||=
+            Tilt::ErubiTemplate.new(
+              convertible.path,
+              line_start(convertible),
+              outvar: "@_erbout",
+              bufval: "Bridgetown::OutputBuffer.new",
+              engine_class: ERBEngine
+            ) do
+              content
+            end
 
         if convertible.is_a?(Bridgetown::Layout)
           erb_renderer.render(erb_view) do

data/lib/bridgetown-core/converters/serbea_templates.rb

@@ -34,10 +34,13 @@ module Bridgetown
       # @return [String] The converted content
       def convert(content, convertible)
         serb_view = Bridgetown::SerbeaView.new(convertible)
-        serb_renderer = Tilt::SerbeaTemplate.new(
-          convertible.path,
-          line_start(convertible)
-        ) { content }
+
+        serb_renderer =
+          convertible.site.tmp_cache["serb-tmpl:#{convertible.path}:#{content.hash}"] ||=
+            Tilt::SerbeaTemplate.new(
+              convertible.path,
+              line_start(convertible)
+            ) { content }
 
         if convertible.is_a?(Bridgetown::Layout)
           serb_renderer.render(serb_view) do

data/lib/bridgetown-core/front_matter/defaults.rb

@@ -5,6 +5,8 @@ module Bridgetown
     # This class handles custom defaults for front matter settings.
     # It is exposed via the frontmatter_defaults method on the site class.
     class Defaults
+      using Bridgetown::Refinements
+
       # @return [Bridgetown::Site]
       attr_reader :site
 
@@ -16,6 +18,7 @@ module Bridgetown
       def reset
         @glob_cache = {}
         @defaults_cache = {}
+        @sets = nil
       end
 
       def ensure_time!(set)
@@ -175,15 +178,12 @@ module Bridgetown
 
       # Returns a list of valid sets
       #
-      # This is not cached to allow plugins to modify the configuration
-      # and have their changes take effect
-      #
       # @return [Array<Hash>]
       def valid_sets
-        sets = site.config["defaults"]
-        return [] unless sets.is_a?(Array)
+        @sets ||= site.config["defaults"].map(&:as_dots)
+        return [] unless @sets.is_a?(Array)
 
-        sets.filter_map do |set|
+        @sets.filter_map do |set|
           if valid?(set)
             massage_scope!(set)
             # TODO: is this trip really necessary?

data/lib/bridgetown-core/helpers.rb

@@ -11,7 +11,7 @@ module Bridgetown
       include ::Streamlined::Helpers
       include Inclusive
 
-      # @return [Bridgetown::RubyTemplateView]
+      # @return [Bridgetown::RubyTemplateView, Bridgetown::Component]
       attr_reader :view
 
       # @return [Bridgetown::Site]
@@ -22,7 +22,7 @@ module Bridgetown
       # @return [Bridgetown::Foundation::SafeTranslations]
       packages def translate_package = [Bridgetown::Foundation::Packages::SafeTranslations]
 
-      # @param view [Bridgetown::RubyTemplateView]
+      # @param view [Bridgetown::RubyTemplateView, Bridgetown::Component]
       # @param site [Bridgetown::Site]
       def initialize(view = nil, site = nil)
         @view = view

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

@@ -3,14 +3,16 @@
 require "zeitwerk"
 require "roda"
 require "json"
+require "bridgetown"
 
-Bridgetown::Current.preloaded_configuration ||= Bridgetown.configuration
-
+require_relative "loader_hooks"
 require_relative "logger"
 require_relative "routes"
 
 module Bridgetown
   module Rack
+    Bridgetown.begin!(with_config: :initializers)
+
     class << self
       # @return [Bridgetown::Utils::LoadersManager]
       attr_accessor :loaders_manager
@@ -23,61 +25,9 @@ module Bridgetown
       self.loaders_manager =
         Bridgetown::Utils::LoadersManager.new(Bridgetown::Current.preloaded_configuration)
       Bridgetown::Current.preloaded_configuration.run_initializers! context: :server
-      autoload_server_folder
-    rescue Roda::RodaError => e
-      if e.message.include?("sessions plugin :secret option")
-        raise Bridgetown::Errors::InvalidConfigurationError,
-              "The Roda sessions plugin can't find a valid secret. Run `bin/bridgetown secret' " \
-              "and put the key in a ENV var you can use to configure the session in the Roda app"
-      end
-
-      raise e
-    end
-
-    # @param root [String] root of Bridgetown site, defaults to config value
-    def self.autoload_server_folder( # rubocop:todo Metrics
-      root: Bridgetown::Current.preloaded_configuration.root_dir
-    )
-      server_folder = File.join(root, "server")
-
-      Bridgetown::Hooks.register_one(
-        :loader, :post_setup, reloadable: false
-      ) do |loader, load_path|
-        next unless load_path == server_folder
-
-        loader.eager_load
-        loader.do_not_eager_load(File.join(server_folder, "roda_app.rb"))
-
-        unless ENV["BRIDGETOWN_ENV"] == "production"
-          Listen.to(server_folder) do |modified, added, removed|
-            c = modified + added + removed
-            n = c.length
-
-            Bridgetown.logger.info(
-              "Reloading…",
-              "#{n} file#{"s" if n > 1} changed at #{Time.now.strftime("%Y-%m-%d %H:%M:%S")}"
-            )
-            c.each do |path|
-              Bridgetown.logger.info "", "- #{path["#{File.dirname(server_folder)}/".length..]}"
-            end
-
-            loader.reload
-            loader.eager_load
-          rescue SyntaxError => e
-            Bridgetown::Errors.print_build_error(e)
-          end.start
-        end
-      end
-
-      Bridgetown::Hooks.register_one(
-        :loader, :post_reload, reloadable: false
-      ) do |loader, load_path|
-        next unless load_path == server_folder
-
-        loader.eager_load
-      end
-
-      loaders_manager.setup_loaders([server_folder])
+      LoaderHooks.autoload_server_folder(
+        File.join(Bridgetown::Current.preloaded_configuration.root_dir, "server")
+      )
     end
   end
 end

data/lib/bridgetown-core/rack/default_config.ru

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "bridgetown-core/rack/boot"
+
+Bridgetown::Rack.boot
+
+unless defined?(RodaApp)
+  class RodaApp < Roda
+    plugin :bridgetown_server
+    route(&:bridgetown)
+  end
+end
+
+run RodaApp.freeze.app

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Rack
+    module LoaderHooks
+      # Sets up a Zeitwerk loader for the Roda routes in the server folder. Called by the server
+      # boot process when Rack starts up
+      #
+      # @param server_folder [String] typically `server` within the site root
+      def self.autoload_server_folder(server_folder)
+        reload_file_path = Bridgetown.live_reload_path
+
+        register_hooks server_folder, reload_file_path
+
+        Bridgetown::Rack.loaders_manager.setup_loaders([server_folder])
+      end
+
+      # Registers a `post_setup` and `post_reload` hook for the Zeitwerk loader in order to handle
+      # eager loading and, in development, the live reload watcher
+      #
+      # @param server_folder [String]
+      # @param reload_file_path [String] path to the special live reload txt file
+      def self.register_hooks(server_folder, reload_file_path) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
+        Bridgetown::Hooks.register_one(
+          :loader, :post_setup, reloadable: false
+        ) do |loader, load_path|
+          next unless load_path == server_folder
+
+          loader.eager_load
+          subclass_names = Roda.subclasses.map(&:name)
+          subclass_paths = Set.new
+
+          loader.all_expected_cpaths.each do |cpath, cname|
+            if subclass_names.include?(cname) && cpath.start_with?(server_folder)
+              subclass_paths << cpath
+              loader.do_not_eager_load cpath
+            end
+          end
+
+          unless ENV["BRIDGETOWN_ENV"] == "production"
+            setup_autoload_listener loader, server_folder, subclass_paths
+          end
+        end
+
+        Bridgetown::Hooks.register_one(
+          :loader, :post_reload, reloadable: false
+        ) do |loader, load_path|
+          next unless load_path == server_folder
+
+          loader.eager_load
+          Bridgetown.touch_live_reload_file(reload_file_path)
+        end
+      end
+
+      # Creates a listener to detect file changes within the server folder and notify Zeitwerk
+      #
+      # @param loader [Zeitwerk::Loader]
+      # @param server_loader [String]
+      # @param subclass_paths [Array<string>]
+      def self.setup_autoload_listener(loader, server_folder, subclass_paths)
+        Listen.to(server_folder) do |modified, added, removed|
+          c = modified + added + removed
+          n = c.length
+
+          unless n == 1 && subclass_paths.include?(c.first)
+            Bridgetown.logger.info(
+              "Reloading…",
+              "#{n} file#{"s" if n > 1} changed at #{Time.now.strftime("%Y-%m-%d %H:%M:%S")}"
+            )
+            c.each do |path|
+              Bridgetown.logger.info "", "- #{path["#{File.dirname(server_folder)}/".length..]}"
+            end
+          end
+
+          loader.reload
+          Bridgetown::Hooks.trigger :loader, :post_reload, loader, server_folder
+        rescue SyntaxError => e
+          Bridgetown::Errors.print_build_error(e)
+        end.start
+      end
+    end
+  end
+end

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

@@ -101,13 +101,14 @@ module Bridgetown
           Bridgetown::Rack::Routes.sorted_subclasses&.each do |klass|
             klass.merge roda_app
           end
+
+          nil # required for proper 404 handling
         end
 
         # @param app [Roda]
         def setup_live_reload(app) # rubocop:disable Metrics
           sleep_interval = 0.5
-          file_to_check = File.join(Bridgetown::Current.preloaded_configuration.destination,
-                                    "index.html")
+          file_to_check = Bridgetown.live_reload_path
           errors_file = Bridgetown.build_errors_path
 
           app.request.get "_bridgetown/live_reload" do

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

@@ -20,7 +20,9 @@ module Bridgetown
 
       # @return [HashWithDotAccess::Hash]
       def relation_schema
-        resource.collection.metadata.relations
+        @relation_schema ||= resource.collection.metadata.relations&.transform_values do |value|
+          value.is_a?(Array) ? value.map(&:to_s) : value.to_s
+        end
       end
 
       # @return [Array<String>]

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

@@ -4,9 +4,9 @@ Bridgetown.initializer :dotenv do |config|
   Bridgetown.load_dotenv root: config.root_dir
 end
 
-Bridgetown.initializer :ssr do |config, setup: nil|
+Bridgetown.initializer :ssr do |config, setup: nil, **options|
   config.roda do |app|
-    app.plugin(:bridgetown_ssr, &setup)
+    app.plugin(:bridgetown_ssr, options, &setup)
   end
 end
 

data/lib/bridgetown-core.rb

@@ -54,8 +54,9 @@ I18n::Backend::Simple.include I18n::Backend::Fallbacks
 
 # Monkey patches:
 
+# @!visibility private
 module HashWithDotAccess
-  class Hash # :nodoc:
+  class Hash
     def to_liquid
       to_h.to_liquid
     end
@@ -99,6 +100,7 @@ module Bridgetown
   autoload :Slot,                "bridgetown-core/slot"
   autoload :StaticFile,          "bridgetown-core/static_file"
   autoload :Transformable,       "bridgetown-core/concerns/transformable"
+  autoload :Viewable,            "bridgetown-core/concerns/viewable"
   autoload :Utils,               "bridgetown-core/utils"
   autoload :VERSION,             "bridgetown-core/version"
   autoload :Watcher,             "bridgetown-core/watcher"
@@ -131,10 +133,16 @@ module Bridgetown
 
     # Set up the Bridgetown execution environment before attempting to load any
     # plugins or gems prior to a site build
-    def begin!
+    def begin!(with_config: :preflight)
       ENV["RACK_ENV"] ||= environment
 
-      Bridgetown::Current.preloaded_configuration = Bridgetown::Configuration::Preflight.new
+      if with_config == :preflight
+        Bridgetown::Current.preloaded_configuration ||= Bridgetown::Configuration::Preflight.new
+      elsif with_config == :initializers &&
+          !Bridgetown::Current.preloaded_configuration.is_a?(Bridgetown::Configuration)
+        Bridgetown::Current.preloaded_configuration = Bridgetown.configuration
+      end
+
       Bridgetown::PluginManager.setup_bundler
     end
 
@@ -365,11 +373,23 @@ module Bridgetown
     #
     # @return [String] the path to the cached errors file
     def build_errors_path
-      File.join(
-        (Bridgetown::Current.site&.config || Bridgetown::Current.preloaded_configuration).root_dir,
-        ".bridgetown-cache",
-        "build_errors.txt"
-      )
+      site_config = Bridgetown::Current.site&.config || Bridgetown::Current.preloaded_configuration
+      File.join(site_config.root_dir, site_config.cache_dir, "build_errors.txt")
+    end
+
+    # This file gets touched each time there's a new build, which then triggers live reload
+    # in the browser.
+    #
+    # @see Bridgetown::Rack::Routes.setup_live_reload
+    # @return [String] the path to the empty file being watched
+    def live_reload_path
+      site_config = Bridgetown::Current.site&.config || Bridgetown::Current.preloaded_configuration
+      File.join(site_config.root_dir, site_config.cache_dir, "live_reload.txt")
+    end
+
+    def touch_live_reload_file(path = live_reload_path)
+      FileUtils.mkdir_p File.dirname(path)
+      FileUtils.touch path
     end
   end
 

data/lib/roda/plugins/bridgetown_server.rb

@@ -13,20 +13,15 @@ class Roda
 
         app.extend ClassMethods # we need to do this here because Roda hasn't done it yet
         app.plugin :initializers
-        app.plugin :method_override
-        app.plugin :all_verbs
-        app.plugin :hooks
         app.plugin :common_logger, Bridgetown::Rack::Logger.new($stdout), method: :info
         app.plugin :json
         app.plugin :json_parser
-        app.plugin :indifferent_params
-        app.plugin :cookies, path: "/"
         app.plugin :ssg, root: Bridgetown::Current.preloaded_configuration.destination
         app.plugin :not_found do
           output_folder = Bridgetown::Current.preloaded_configuration.destination
           File.read(File.join(output_folder, "404.html"))
         rescue Errno::ENOENT
-          "404 Not Found"
+          "<h1>404 Not Found</h1>"
         end
         app.plugin :exception_page
         app.plugin :error_handler do |e|
@@ -35,10 +30,10 @@ class Roda
           )
           next exception_page(e) if ENV.fetch("RACK_ENV", nil) == "development"
 
-          output_folder = Bridgetown::Current.preloaded_configuration.destination
+          output_folder = self.class.opts[:bridgetown_preloaded_config].destination
           File.read(File.join(output_folder, "500.html"))
         rescue Errno::ENOENT
-          "500 Internal Server Error"
+          "<h1>500 Internal Server Error</h1>"
         end
 
         # TODO: there may be a better way to do this, see `exception_page_css` instance method
@@ -123,9 +118,12 @@ class Roda
             hook_result = instance_exec(&self.class.opts[:root_hook]) if self.class.opts[:root_hook]
             next hook_result if hook_result
 
-            status, headers, body = self.class.opts[:ssg_server].serving(
-              request, File.join(self.class.opts[:ssg_root], "index.html")
-            )
+            root_file = [
+              File.join(self.class.opts[:ssg_root], "index.html"),
+              File.expand_path("generic_index.html", __dir__),
+            ].find { File.exist?(_1) }
+
+            status, headers, body = self.class.opts[:ssg_server].serving(request, root_file)
             response_headers = response.headers
             response_headers.replace(headers)
 
@@ -133,7 +131,7 @@ class Roda
           rescue StandardError => e
             Bridgetown.logger.debug("Root handler error: #{e.message}")
             response.status = 500
-            "<p>ERROR: cannot find <code>index.html</code> in the output folder.</p>"
+            "<p>ERROR: cannot serve the root <code>index</code> file.</p>"
           end
         end
 
@@ -158,20 +156,11 @@ class Roda
           scope.initialize_bridgetown_context
           scope.initialize_bridgetown_root
 
-          # There are two different code paths depending on if there's a site `base_path` configured
-          if Bridgetown::Current.preloaded_configuration.base_path == "/"
+          base_path = Bridgetown::Current.preloaded_configuration.base_path.delete_prefix("/")
+          on(base_path.empty? ? true : base_path) do
             ssg # static file server
             Bridgetown::Rack::Routes.load_all scope
-            return
           end
-
-          # Support custom base_path configurations
-          on(Bridgetown::Current.preloaded_configuration.base_path.delete_prefix("/")) do
-            ssg # static file server
-            Bridgetown::Rack::Routes.load_all scope
-          end
-
-          nil
         end
       end
     end

data/lib/roda/plugins/bridgetown_ssr.rb

@@ -13,13 +13,31 @@ class Roda
         alias_method :site, :bridgetown_site
       end
 
-      def self.load_dependencies(app)
-        app.plugin :custom_block_results
+      def self.load_dependencies(app, opts = { sessions: false })
+        app.plugin :all_verbs
+        app.plugin :cookies, path: "/"
+        app.plugin :indifferent_params
+        app.plugin :method_override
+        app.plugin :route_csrf
 
         # This lets us return callable objects directly in Roda response blocks
+        app.plugin :custom_block_results
         app.handle_block_result(Bridgetown::RodaCallable) do |callable|
-          callable.(self)
+          request.send :block_result_body, callable.(self)
+        end
+
+        return unless opts[:sessions]
+
+        secret_key = ENV.fetch("RODA_SECRET_KEY", nil)
+        unless secret_key
+          raise Bridgetown::Errors::InvalidConfigurationError,
+                "The Roda sessions plugin can't find a valid secret. Run " \
+                "`bin/bridgetown secret' and put the key in your ENV as the " \
+                "RODA_SECRET_KEY variable"
         end
+
+        app.plugin :sessions, secret: secret_key
+        app.plugin :flashier
       end
 
       def self.configure(app, _opts = {}, &)