bridgetown-core 1.0.0.beta3 → 1.1.0.beta2

data/lib/bridgetown-core/filters/translation_filters.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Filters
+    module TranslationFilters
+      def t(input)
+        I18n.t(input.to_s)
+      end
+    end
+  end
+end

data/lib/bridgetown-core/filters/url_filters.rb

@@ -7,9 +7,8 @@ module Bridgetown
 
       # Produces an absolute URL based on site.url and site.base_path.
       #
-      # input - the URL to make absolute.
-      #
-      # Returns the absolute URL as a String.
+      # @param input [String] the URL to make absolute.
+      # @return [String] the absolute URL as a String.
       def absolute_url(input)
         cache = (@context.registers[:cached_absolute_urls] ||= {})
         cache[input] ||= compute_absolute_url(input)
@@ -18,19 +17,47 @@ module Bridgetown
       # Produces a URL relative to the domain root based on site.base_path
       # unless it is already an absolute url with an authority (host).
       #
-      # input - the URL to make relative to the domain root
-      #
-      # Returns a URL relative to the domain root as a String.
+      # @param input [String] the URL to make relative to the domain root
+      # @return [String] a URL relative to the domain root as a String.
       def relative_url(input)
         cache = (@context.registers[:cached_relative_urls] ||= {})
         cache[input] ||= compute_relative_url(input)
       end
 
-      # Strips trailing `/index.html` from URLs to create pretty permalinks
+      # For string input, adds a prefix of the current site locale to a relative
+      # URL, unless it's a default locale and prefix_current_locale config is
+      # false. For a resources array input, return a filtered resources array
+      # based on the locale.
       #
-      # input - the URL with a possible `/index.html`
+      # @param input [String, Array] the relative URL, or an array of resources
+      # @param use_locale [String] another locale to use beside the current one
+      #   (must be in site's `available_locales` config)
+      # @return [String, Array] the prefixed relative URL, or filtered resources
+      def in_locale(input, use_locale = nil)
+        site = @context.registers[:site]
+        use_locale ||= site.locale
+
+        # If we're given a collection, filter down and return
+        if input.is_a?(Array)
+          return input.select do |res|
+            res.data[:locale].to_sym == use_locale.to_sym
+          end
+        end
+
+        if !site.config.prefix_default_locale &&
+            use_locale.to_sym == site.config.default_locale
+          return input
+        end
+
+        return input unless site.config.available_locales.include?(use_locale.to_sym)
+
+        "#{use_locale}/#{input.to_s.delete_prefix("/")}"
+      end
+
+      # Strips trailing `/index.html` from URLs to create pretty permalinks
       #
-      # Returns a URL with the trailing `/index.html` removed
+      # @param input [String] the URL with a possible `/index.html`
+      # @return [String] a URL with the trailing `/index.html` removed
       def strip_index(input)
         return if input.nil? || input.to_s.empty?
 
@@ -42,7 +69,7 @@ module Bridgetown
       # @param input [Object] value which responds to `to_s`
       # @return [String]
       def strip_extname(input)
-        Pathname.new(input.to_s).yield_self do |path|
+        Pathname.new(input.to_s).then do |path|
           path.dirname + path.basename(".*")
         end.to_s
       end

data/lib/bridgetown-core/filters.rb

@@ -435,3 +435,6 @@ end
 Liquid::Template.register_filter(
   Bridgetown::Filters
 )
+Liquid::Template.register_filter(
+  Bridgetown::Filters::TranslationFilters
+)

data/lib/bridgetown-core/frontmatter_defaults.rb

@@ -9,10 +9,12 @@ module Bridgetown
 
     def initialize(site)
       @site = site
+      @defaults_cache = {}
     end
 
     def reset
       @glob_cache = {}
+      @defaults_cache = {}
     end
 
     def ensure_time!(set)
@@ -29,16 +31,19 @@ module Bridgetown
     # Collects a hash with all default values for a resource
     #
     # @param path [String] the relative path of the resource
-    # @param collection [Symbol] :posts, :pages, etc.
+    # @param collection_name [Symbol] :posts, :pages, etc.
     #
-    # @returns [Hash] all default values (an empty hash if there are none)
-    def all(path, collection)
-      defaults = {}
+    # @return [Hash] all default values (an empty hash if there are none)
+    def all(path, collection_name)
+      if @defaults_cache.key?([path, collection_name])
+        return @defaults_cache[[path, collection_name]]
+      end
 
+      defaults = {}
       merge_data_cascade_for_path(path, defaults)
 
       old_scope = nil
-      matching_sets(path, collection).each do |set|
+      matching_sets(path, collection_name).each do |set|
         if has_precedence?(old_scope, set["scope"])
           defaults = Utils.deep_merge_hashes(defaults, set["values"])
           old_scope = set["scope"]
@@ -46,7 +51,8 @@ module Bridgetown
           defaults = Utils.deep_merge_hashes(set["values"], defaults)
         end
       end
-      defaults
+
+      @defaults_cache[[path, collection_name]] = defaults
     end
 
     private
@@ -123,7 +129,7 @@ module Bridgetown
     # @param scope [Hash] the defaults set being asked about
     # @param collection [Symbol] the collection of the resource being processed
     #
-    # @returns [Boolean] whether either of the above conditions are satisfied
+    # @return [Boolean] whether either of the above conditions are satisfied
     def applies_collection?(scope, collection)
       !scope.key?("collection") || scope["collection"].eql?(collection.to_s)
     end
@@ -132,7 +138,7 @@ module Bridgetown
     #
     # @param set [Hash] the default value hash as defined in bridgetown.config.yml
     #
-    # @returns [Boolean] if the set is valid and can be used
+    # @return [Boolean] if the set is valid and can be used
     def valid?(set)
       set.is_a?(Hash) && set["values"].is_a?(Hash)
     end

data/lib/bridgetown-core/generated_page.rb

@@ -4,6 +4,7 @@ module Bridgetown
   class GeneratedPage
     include LayoutPlaceable
     include LiquidRenderable
+    include Localizable
     include Publishable
     include Transformable
 

data/lib/bridgetown-core/kramdown/parser/gfm.rb

@@ -0,0 +1,36 @@
+# Frozen-string-literal: true
+
+require "kramdown-parser-gfm"
+
+module Kramdown
+  module Parser
+    class GFM
+      MARK_DELIMITER = %r{(==|::)+}.freeze
+      MARK_MATCH = %r{#{MARK_DELIMITER}(?!\s|=|:).*?[^\s=:]#{MARK_DELIMITER}}m.freeze
+
+      # Monkey-patch GFM initializer to add our new mark parser
+      alias_method :_old_initialize, :initialize
+      def initialize(source, options)
+        _old_initialize(source, options)
+        @span_parsers << :mark if @options[:mark_highlighting]
+      end
+
+      def parse_mark
+        line_number = @src.current_line_number
+
+        @src.pos += @src.matched_size
+        el = Element.new(:html_element, "mark", {}, category: :span, line: line_number)
+        @tree.children << el
+
+        env = save_env
+        reset_env(src: Kramdown::Utils::StringScanner.new(@src.matched[2..-3], line_number),
+                  text_type: :text)
+        parse_spans(el)
+        restore_env(env)
+
+        el
+      end
+      define_parser(:mark, MARK_MATCH)
+    end
+  end
+end

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

@@ -95,8 +95,7 @@ module Bridgetown
 
       # @return [Bridgetown::Resource::Base]
       def as_resource_in_collection
-        collection.resources << to_resource.read!
-        collection.resources.last
+        collection.add_resource_from_model(self)
       end
 
       # @return [Bridgetown::Resource::Base]

data/lib/bridgetown-core/plugin.rb

@@ -3,55 +3,24 @@
 module Bridgetown
   class Plugin
     extend ActiveSupport::DescendantsTracker
+    include Bridgetown::Prioritizable
 
-    PRIORITIES = {
-      low: -10,
+    self.priorities = {
       highest: 100,
-      lowest: -100,
-      normal: 0,
       high: 10,
+      normal: 0,
+      low: -10,
+      lowest: -100,
     }.freeze
 
     SourceManifest = Struct.new(:origin, :components, :content, :layouts, keyword_init: true)
 
-    # Get or set the priority of this plugin. When called without an
-    # argument it returns the priority. When an argument is given, it will
-    # set the priority.
-    #
-    # priority - The Symbol priority (default: nil). Valid options are:
-    #            :lowest, :low, :normal, :high, :highest
-    #
-    # Returns the Symbol priority.
-    def self.priority(priority = nil)
-      @priority ||= nil
-      @priority = priority if priority && PRIORITIES.key?(priority)
-      @priority || :normal
-    end
-
-    # Spaceship is priority [higher -> lower]
-    #
-    # other - The class to be compared.
-    #
-    # Returns -1, 0, 1.
-    def self.<=>(other)
-      PRIORITIES[other.priority] <=> PRIORITIES[priority]
-    end
-
-    # Spaceship is priority [higher -> lower]
-    #
-    # other - The class to be compared.
-    #
-    # Returns -1, 0, 1.
-    def <=>(other)
-      self.class <=> other.class
-    end
-
     # Initialize a new plugin. This should be overridden by the subclass.
     #
     # config - The Hash of configuration options.
     #
     # Returns a new instance.
-    def initialize(config = {})
+    def initialize(config = {}) # rubocop:disable Style/RedundantInitialize
       # no-op for default
     end
   end

data/lib/bridgetown-core/plugin_manager.rb

@@ -40,7 +40,8 @@ module Bridgetown
       @loaders_manager = Bridgetown::Utils::LoadersManager.new(site.config)
     end
 
-    def self.require_from_bundler
+    def self.require_from_bundler(skip_yarn: false) # rubocop:todo Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      # NOTE: investigate why this ENV var is really necessary
       if !ENV["BRIDGETOWN_NO_BUNDLER_REQUIRE"] && File.file?("Gemfile")
         require "bundler"
 
@@ -48,7 +49,7 @@ module Bridgetown
           (dep.groups & [PLUGINS_GROUP]).any? && dep.should_include?
         end
 
-        install_yarn_dependencies(required_gems)
+        install_yarn_dependencies(required_gems) unless skip_yarn
 
         required_gems.each do |installed_gem|
           add_registered_plugin installed_gem

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

@@ -19,6 +19,11 @@ module Bridgetown
       attr_accessor :loaders_manager
     end
 
+    # Start up the Roda Rack application and the Zeitwerk autoloaders. Ensure the
+    # Roda app is provided the preloaded Bridgetown site configuration. Handle
+    # any uncaught Roda errors.
+    #
+    # @param [Bridgetown::Rack::Roda] optional, defaults to the `RodaApp` constant
     def self.boot(roda_app = nil)
       self.loaders_manager =
         Bridgetown::Utils::LoadersManager.new(Bridgetown::Current.preloaded_configuration)

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

@@ -4,19 +4,29 @@ require "logger"
 
 module Bridgetown
   module Rack
-    class Logger < Logger
+    class Logger < Bridgetown::LogWriter
       def self.message_with_prefix(msg)
-        return if msg.include?("/_bridgetown/live_reload")
+        #        return if msg.include?("/_bridgetown/live_reload")
 
         "\e[35m[Server]\e[0m #{msg}"
       end
 
-      def initialize(*)
-        super
+      def enable_prefix
         @formatter = proc do |_, _, _, msg|
           self.class.message_with_prefix(msg)
         end
       end
+
+      def add(severity, message = nil, progname = nil)
+        return if progname&.include?("/_bridgetown/live_reload")
+
+        super
+      end
+
+      def initialize(*_args)
+        super()
+        enable_prefix
+      end
     end
   end
 end

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