bridgetown-core 1.0.0.beta2 → 1.1.0.beta1

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

@@ -2,6 +2,13 @@
 
 require "rack/indifferent"
 
+begin
+  # If it's in the Gemfile's :bridgetown_plugins group it's already been required, but we'll try
+  # again just to be on the safe side:
+  require "bridgetown-routes"
+rescue LoadError
+end
+
 class Roda
   module RodaPlugins
     module BridgetownSSR
@@ -12,6 +19,34 @@ class Roda
     end
 
     register_plugin :bridgetown_ssr, BridgetownSSR
+
+    module BridgetownBoot
+      module InstanceMethods
+        # Helper shorthand for Bridgetown::Current.site
+        # @return [Bridgetown::Site]
+        def bridgetown_site
+          Bridgetown::Current.site
+        end
+      end
+
+      Roda::RodaRequest.alias_method :_previous_roda_cookies, :cookies
+
+      module RequestMethods
+        # Monkeypatch Roda/Rack's Request object so it returns a hash which allows for
+        # indifferent access
+        def cookies
+          # TODO: maybe replace with a simpler hash that offers an overloaded `[]` method
+          _previous_roda_cookies.with_indifferent_access
+        end
+
+        # Starts up the Bridgetown routing system
+        def bridgetown
+          Bridgetown::Rack::Routes.start!(scope)
+        end
+      end
+    end
+
+    register_plugin :bridgetown_boot, BridgetownBoot
   end
 end
 
@@ -24,6 +59,7 @@ module Bridgetown
       plugin :json_parser
       plugin :cookies
       plugin :streaming
+      plugin :bridgetown_boot
       plugin :public, root: Bridgetown::Current.preloaded_configuration.destination
       plugin :not_found do
         output_folder = Bridgetown::Current.preloaded_configuration.destination
@@ -31,15 +67,76 @@ module Bridgetown
       rescue Errno::ENOENT
         "404 Not Found"
       end
+      plugin :exception_page
       plugin :error_handler do |e|
-        puts "\n#{e.class} (#{e.message}):\n\n"
-        puts e.backtrace
+        Bridgetown::Errors.print_build_error(
+          e, logger: Bridgetown::LogAdapter.new(self.class.opts[:common_logger])
+        )
+        next exception_page(e) if ENV.fetch("RACK_ENV", nil) == "development"
+
         output_folder = Bridgetown::Current.preloaded_configuration.destination
         File.read(File.join(output_folder, "500.html"))
       rescue Errno::ENOENT
         "500 Internal Server Error"
       end
 
+      ::Roda::RodaPlugins::ExceptionPage.class_eval do
+        def self.css
+          <<~CSS
+            html * { padding:0; margin:0; }
+            body * { padding:10px 20px; }
+            body * * { padding:0; }
+            body { font-family: -apple-system, sans-serif; font-size: 90%; }
+            body>div { border-bottom:1px solid #ddd; }
+            code { font-family: ui-monospace, monospace; }
+            h1 { font-weight: bold; margin-block-end: .8em; }
+            h2 { margin-block-end:.8em; }
+            h2 span { font-size:80%; color:#f7f7db; font-weight:normal; }
+            h3 { margin:1em 0 .5em 0; }
+            h4 { margin:0 0 .5em 0; font-weight: normal; }
+            table {
+                border:1px solid #ccc; border-collapse: collapse; background:white; }
+            tbody td, tbody th { vertical-align:top; padding:2px 3px; }
+            thead th {
+                padding:1px 6px 1px 3px; background:#fefefe; text-align:left;
+                font-weight:normal; font-size:11px; border:1px solid #ddd; }
+            tbody th { text-align:right; opacity: 0.7; padding-right:.5em; }
+            table.vars { margin:5px 0 2px 40px; }
+            table.vars td, table.req td { font-family: ui-monospace, monospace; }
+            table td.code { width:100%;}
+            table td.code div { overflow:hidden; }
+            table.source th { color:#666; }
+            table.source td {
+                font-family: ui-monospace, monospace; white-space:pre; border-bottom:1px solid #eee; }
+            ul.traceback { list-style-type:none; }
+            ul.traceback li.frame { margin-bottom:1em; }
+            div.context { margin: 10px 0; }
+            div.context ol {
+                padding-left:30px; margin:0 10px; list-style-position: inside; }
+            div.context ol li {
+                font-family: ui-monospace, monospace; white-space:pre; color:#666; cursor:pointer; }
+            div.context ol.context-line li { color:black; background-color:#f7f7db; }
+            div.context ol.context-line li span { float: right; }
+            div.commands { margin-left: 40px; }
+            div.commands a { color:black; text-decoration:none; }
+            #summary { background: #1D453C; color: white; }
+            #summary h2 { font-weight: normal; color: white; }
+            #summary ul#quicklinks { list-style-type: none; margin-bottom: 2em; }
+            #summary ul#quicklinks li { float: left; padding: 0 1em; }
+            #summary ul#quicklinks>li+li { border-left: 1px #666 solid; }
+            #summary a { color: #f47c3c; }
+            #explanation { background:#eee; }
+            #traceback { background: white; }
+            #requestinfo { background:#f6f6f6; padding-left:120px; }
+            #summary table { border:none; background:transparent; }
+            #requestinfo h2, #requestinfo h3 { position:relative; margin-left:-100px; }
+            #requestinfo h3 { margin-bottom:-1em; }
+            .error { background: #ffc; }
+            .specific { color:#cc3300; font-weight:bold; }
+          CSS
+        end
+      end
+
       before do
         if self.class.opts[:bridgetown_site]
           # The site had previously been initialized via the bridgetown_ssr plugin
@@ -48,19 +145,14 @@ module Bridgetown
         Bridgetown::Current.preloaded_configuration ||=
           self.class.opts[:bridgetown_preloaded_config]
 
-        request.public
-
         request.root do
           output_folder = Bridgetown::Current.preloaded_configuration.destination
           File.read(File.join(output_folder, "index.html"))
+        rescue StandardError
+          response.status = 500
+          "<p>ERROR: cannot find <code>index.html</code> in the output folder.</p>"
         end
       end
-
-      # Helper shorthand for Bridgetown::Current.site
-      # @return [Bridgetown::Site]
-      def bridgetown_site
-        Bridgetown::Current.site
-      end
     end
   end
 end

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

@@ -9,19 +9,49 @@ module Bridgetown
     end
 
     class Routes
+      include Bridgetown::Prioritizable
+
+      self.priorities = {
+        highest: "010",
+        high: "020",
+        normal: "030",
+        low: "040",
+        lowest: "050",
+      }.freeze
+
       class << self
-        attr_accessor :tracked_subclasses, :router_block
+        # @return [Hash<String, Class(Routes)>]
+        attr_accessor :tracked_subclasses
+
+        # @return [Proc]
+        attr_accessor :router_block
+
+        # Spaceship is priority [higher -> lower]
+        #
+        # @param other [Class(Routes)] The class to be compared.
+        # @return [Integer] -1, 0, 1.
+        def <=>(other)
+          "#{priorities[priority]}#{self}" <=> "#{priorities[other.priority]}#{other}"
+        end
 
+        # @param base [Class(Routes)]
         def inherited(base)
           Bridgetown::Rack::Routes.track_subclass base
           super
         end
 
+        # @param klass [Class(Routes)]
         def track_subclass(klass)
           Bridgetown::Rack::Routes.tracked_subclasses ||= {}
           Bridgetown::Rack::Routes.tracked_subclasses[klass.name] = klass
         end
 
+        # @return [Array<Class(Routes)>]
+        def sorted_subclasses
+          Bridgetown::Rack::Routes.tracked_subclasses&.values&.sort
+        end
+
+        # @return [void]
         def reload_subclasses
           Bridgetown::Rack::Routes.tracked_subclasses&.each_key do |klassname|
             Kernel.const_get(klassname)
@@ -30,33 +60,78 @@ module Bridgetown
           end
         end
 
+        # Add a router block via the current Routes class
+        #
+        # Example:
+        #
+        #   class Routes::Hello < Bridgetown::Rack::Routes
+        #     route do |r|
+        #       r.get "hello", String do |name|
+        #         { hello: "friend #{name}" }
+        #       end
+        #     end
+        #   end
+        #
+        # @param block [Proc]
         def route(&block)
           self.router_block = block
         end
 
+        # Initialize a new Routes instance and execute the route as part of the
+        # Roda app request cycle
+        #
+        # @param roda_app [Bridgetown::Rack::Roda]
         def merge(roda_app)
           return unless router_block
 
           new(roda_app).handle_routes
         end
 
+        # Start the Roda app request cycle. There are two different code paths
+        # depending on if there's a site `base_path` configured
+        #
+        # @param roda_app [Bridgetown::Rack::Roda]
+        # @return [void]
         def start!(roda_app)
+          if Bridgetown::Current.preloaded_configuration.base_path == "/"
+            load_all_routes roda_app
+            return
+          end
+
+          # Support custom base_path configurations
+          roda_app.request.on(
+            Bridgetown::Current.preloaded_configuration.base_path.delete_prefix("/")
+          ) do
+            load_all_routes roda_app
+          end
+
+          nil
+        end
+
+        # Run the Roda public plugin first, set up live reload if allowed, then
+        # run through all the Routes blocks. If the file-based router plugin
+        # is available, kick off that request process next.
+        #
+        # @param roda_app [Bridgetown::Rack::Roda]
+        # @return [void]
+        def load_all_routes(roda_app)
+          roda_app.request.public
+
           if Bridgetown.env.development? &&
               !Bridgetown::Current.preloaded_configuration.skip_live_reload
             setup_live_reload roda_app
           end
 
-          Bridgetown::Rack::Routes.tracked_subclasses&.each_value do |klass|
+          Bridgetown::Rack::Routes.sorted_subclasses&.each do |klass|
             klass.merge roda_app
           end
 
-          if defined?(Bridgetown::Routes::RodaRouter)
-            Bridgetown::Routes::RodaRouter.start!(roda_app)
-          end
+          return unless defined?(Bridgetown::Routes::RodaRouter)
 
-          nil
+          Bridgetown::Routes::RodaRouter.start!(roda_app)
         end
 
+        # @param app [Bridgetown::Rack::Roda]
         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,
@@ -86,14 +161,20 @@ module Bridgetown
         end
       end
 
+      # @param roda_app [Bridgetown::Rack::Roda]
       def initialize(roda_app)
         @_roda_app = roda_app
       end
 
+      # Execute the router block via the instance, passing it the Roda request
+      #
+      # @return [Object] whatever is returned by the router block as expected
+      #   by the Roda API
       def handle_routes
         instance_exec(@_roda_app.request, &self.class.router_block)
       end
 
+      # Any missing methods are passed along to the underlying Roda app if possible
       def method_missing(method_name, *args, **kwargs, &block)
         if @_roda_app.respond_to?(method_name.to_sym)
           @_roda_app.send method_name.to_sym, *args, **kwargs, &block

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

@@ -7,6 +7,7 @@ module Bridgetown
       include Bridgetown::Publishable
       include Bridgetown::LayoutPlaceable
       include Bridgetown::LiquidRenderable
+      include Bridgetown::Localizable
 
       # @return [HashWithDotAccess::Hash]
       attr_reader :data
@@ -210,10 +211,7 @@ module Bridgetown
       def requires_destination?
         collection.write? && data.config&.output != false
       end
-
-      def write?
-        requires_destination? && site.publisher.publish?(self)
-      end
+      alias_method :write?, :requires_destination?
 
       # Write the generated Document file to the destination directory.
       #
@@ -295,7 +293,7 @@ module Bridgetown
 
       private
 
-      def ensure_default_data # rubocop:todo Metrics/AbcSize
+      def ensure_default_data
         determine_locale
 
         slug = if matches = relative_path.to_s.match(DATE_FILENAME_MATCHER) # rubocop:disable Lint/AssignmentInCondition
@@ -305,7 +303,7 @@ module Bridgetown
                  basename_without_ext
                end
 
-        slug.chomp!(".#{data.locale}") if data.locale && slug.ends_with?(".#{data.locale}")
+        Bridgetown::Utils.chomp_locale_suffix!(slug, data.locale)
 
         data.slug ||= slug
         data.title ||= Bridgetown::Utils.titleize_slug(slug)

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

@@ -12,6 +12,7 @@ module Bridgetown
       # @param resource [Bridgetown::Resource::Base]
       def initialize(resource)
         @resource = resource
+        warn_on_rails_style_extension
         @output_ext = resource.transformer.final_ext
       end
 
@@ -46,6 +47,23 @@ module Bridgetown
         Bridgetown.logger.debug "Writing:", path
         File.write(path, output, mode: "wb")
       end
+
+      private
+
+      def warn_on_rails_style_extension
+        return unless resource.relative_path.fnmatch?("*.{html,json,js}.*", File::FNM_EXTGLOB)
+
+        Bridgetown.logger.warn("Uh oh!", "You're using a Rails-style filename extension in:")
+        Bridgetown.logger.warn("", resource.relative_path)
+        Bridgetown.logger.warn(
+          "", "Instead, you can use either the desired output file extension or set a permalink."
+        )
+        Bridgetown.logger.warn(
+          "For more info:",
+          "https://www.bridgetownrb.com/docs/template-engines/erb-and-beyond#extensions-and-permalinks"
+        )
+        Bridgetown.logger.warn("")
+      end
     end
   end
 end

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

@@ -113,9 +113,8 @@ module Bridgetown
             if resource.site.config["collections_dir"].present?
               path.delete_prefix! "#{resource.site.config["collections_dir"]}/"
             end
-            if resource.data.locale && path.ends_with?(".#{resource.data.locale}")
-              path.chomp!(".#{resource.data.locale}")
-            end
+
+            Bridgetown::Utils.chomp_locale_suffix!(path, resource.data.locale)
           end,
         }
       end
@@ -137,7 +136,10 @@ module Bridgetown
 
       # @param resource [Bridgetown::Resource::Base]
       register_placeholder :locale, ->(resource) do
-        next nil if resource.data.locale&.to_sym == resource.site.config.default_locale
+        if !resource.site.config.prefix_default_locale &&
+            resource.data.locale&.to_sym == resource.site.config.default_locale
+          next nil
+        end
 
         locale_data = resource.data.locale&.to_sym
         resource.site.config.available_locales.include?(locale_data) ? locale_data.to_s : nil

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

@@ -68,7 +68,7 @@ module Bridgetown
       # @return [String]
       def kind_of_relation_for_type(type)
         relation_schema&.each do |relation_type, collections|
-          collections = Array(collections).yield_self do |collections_arr|
+          collections = Array(collections).then do |collections_arr|
             collections_arr +
               collections_arr.map { |item| ActiveSupport::Inflector.pluralize(item) }
           end.flatten.uniq

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

@@ -20,7 +20,8 @@ module Bridgetown
       def self.run_process(name, color, cmd)
         Thread.new do
           rd, wr = IO.pipe("BINARY")
-          pid = Process.spawn(cmd, out: wr, err: wr, pgroup: true)
+          pid = Process.spawn({ "BRIDGETOWN_NO_BUNDLER_REQUIRE" => nil },
+                              cmd, out: wr, err: wr, pgroup: true)
           @mutex.synchronize do
             add_pid pid
           end

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

@@ -41,15 +41,12 @@ module Bridgetown
             require name
           rescue LoadError => e
             Bridgetown.logger.error "Dependency Error:", <<~MSG
-              Yikes! It looks like you don't have #{name} or one of its dependencies installed.
-              In order to use Bridgetown as currently configured, you'll need to install this gem.
+              Oops! It looks like you don't have #{name} or one of its dependencies installed.
+              Please double-check you've added #{name} to your Gemfile.
 
-              If you've run Bridgetown with `bundle exec`, ensure that you have included the #{name}
-              gem in your Gemfile as well.
+              If you're stuck, you can find help at https://www.bridgetownrb.com/community
 
               The full error message from Ruby is: '#{e.message}'
-
-              If you run into trouble, you can find helpful resources at https://www.bridgetownrb.com/docs/community/
             MSG
             raise Bridgetown::Errors::MissingDependencyException, name
           end

data/lib/bridgetown-core/utils.rb

@@ -320,7 +320,7 @@ module Bridgetown
         end
 
         if continue_processing
-          line_indentation = line.match(%r!^ +!).yield_self do |indent|
+          line_indentation = line.match(%r!^ +!).then do |indent|
             indent.nil? ? "" : indent[0]
           end
           new_indentation = line_indentation.rjust(starting_indent_length, " ")
@@ -339,6 +339,11 @@ module Bridgetown
     end
     # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
 
+    # Return an asset path based on a frontend manifest file
+    #
+    # @param site [Bridgetown::Site] The current site object
+    # @param asset_type [String] js or css, or filename in manifest
+    # @return [String, nil]
     def parse_frontend_manifest_file(site, asset_type)
       case frontend_bundler_type(site.root_dir)
       when :webpack
@@ -362,9 +367,6 @@ module Bridgetown
     #   file isnt found
     # @return [nil] Returns nil if the asset isnt 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 parse_webpack_manifest_file(site, asset_type)
       return log_frontend_asset_error(site, "Webpack manifest") if site.frontend_manifest.nil?
 
@@ -389,16 +391,17 @@ module Bridgetown
     #   file isnt found
     # @return [nil] Returns nil if the asset isnt 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 parse_esbuild_manifest_file(site, asset_type) # rubocop:disable Metrics/PerceivedComplexity
       return log_frontend_asset_error(site, "esbuild manifest") if site.frontend_manifest.nil?
 
-      asset_path = if %w(js css).include?(asset_type)
-                     folder = asset_type == "js" ? "javascript" : "styles"
-                     site.frontend_manifest["#{folder}/index.#{asset_type}"] ||
-                       site.frontend_manifest["#{folder}/index.#{asset_type}.rb"]
+      asset_path = case asset_type
+                   when "css"
+                     site.frontend_manifest["styles/index.css"] ||
+                       site.frontend_manifest["styles/index.scss"] ||
+                       site.frontend_manifest["styles/index.sass"]
+                   when "js"
+                     site.frontend_manifest["javascript/index.js"] ||
+                       site.frontend_manifest["javascript/index.js.rb"]
                    else
                      site.frontend_manifest.find do |item, _|
                        item.sub(%r{^../(frontend/|src/)?}, "") == asset_type
@@ -457,7 +460,7 @@ module Bridgetown
       code = <<~JAVASCRIPT
         let lastmod = 0
         function startReloadConnection() {
-          const evtSource = new EventSource("/_bridgetown/live_reload")
+          const evtSource = new EventSource("#{site.base_path(strip_slash_only: true)}/_bridgetown/live_reload")
           evtSource.onmessage = event => {
             if (event.data == "reloaded!") {
               location.reload()
@@ -488,6 +491,16 @@ module Bridgetown
       %(<script type="module">#{code}</script>).html_safe
     end
 
+    def chomp_locale_suffix!(path, locale)
+      return path unless locale
+
+      if path.ends_with?(".#{locale}")
+        path.chomp!(".#{locale}")
+      elsif path.ends_with?(".multi")
+        path.chomp!(".multi")
+      end
+    end
+
     private
 
     def merge_values(target, overwrite)

data/lib/bridgetown-core/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Bridgetown
-  VERSION = "1.0.0.beta2"
-  CODE_NAME = "Pearl"
+  VERSION = "1.1.0.beta1"
+  CODE_NAME = "Belmont"
 end