bridgetown-core 0.21.4 → 1.0.0.alpha4

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # Handles Generated Pages
-Bridgetown::Hooks.register :pages, :post_init, reloadable: false do |page|
+Bridgetown::Hooks.register :generated_pages, :post_init, reloadable: false do |page|
   if page.class != Bridgetown::PrototypePage && page.data["prototype"].is_a?(Hash)
     Bridgetown::PrototypeGenerator.add_matching_template(page)
   end
@@ -38,43 +38,42 @@ module Bridgetown
     # @param site [Bridgetown::Site]
     def generate(site)
       @site = site
-      @configured_collection = "posts" unless site.uses_resource?
-      page_list = site.uses_resource? ? site.collections.pages.resources : site.pages
+      page_list = site.collections.pages.resources
 
       prototype_pages = self.class.matching_templates.select do |page|
         page_list.include?(page)
       end
 
-      if prototype_pages.length.positive?
-        ensure_pagination_enabled
+      return unless prototype_pages.length.positive?
 
-        page_list.reject! do |page|
-          prototype_pages.include? page
-        end
+      ensure_pagination_enabled
+
+      page_list.reject! do |page|
+        prototype_pages.include? page
+      end
 
-        prototype_pages.each do |prototype_page|
-          search_term = validate_search_term(prototype_page)
-          next if search_term.nil?
+      prototype_pages.each do |prototype_page|
+        search_term = validate_search_term(prototype_page)
+        next if search_term.nil?
 
-          terms_matching_pages(search_term).each do |term|
-            generate_new_page_from_prototype(prototype_page, search_term, term)
-          end
+        terms_matching_pages(search_term).each do |term|
+          generate_new_page_from_prototype(prototype_page, search_term, term)
         end
       end
     end
 
     def ensure_pagination_enabled
-      unless @site.config.dig(:pagination, :enabled)
-        Bridgetown.logger.warn(
-          "Pagination:",
-          "Must be enabled for prototype pages to contain matches"
-        )
-      end
+      return if @site.config.dig(:pagination, :enabled)
+
+      Bridgetown.logger.warn(
+        "Pagination:",
+        "Must be enabled for prototype pages to contain matches"
+      )
     end
 
     # Check incoming prototype configuration and normalize options.
     #
-    # @param prototype_page [Bridgetown::Page, Bridgetown::Resource::Base]
+    # @param prototype_page [Bridgetown::GeneratedPage, Bridgetown::Resource::Base]
     #
     # @return [String, nil]
     def validate_search_term(prototype_page)
@@ -110,11 +109,7 @@ module Bridgetown
     #
     # @return [Array<String>]
     def terms_matching_pages(search_term)
-      pages_list = if site.uses_resource?
-                     site.collections[@configured_collection].resources
-                   else
-                     site.collections[@configured_collection].docs
-                   end
+      pages_list = site.collections[@configured_collection].resources
 
       Bridgetown::Paginate::PaginationIndexer.index_documents_by(
         pages_list, search_term
@@ -123,35 +118,29 @@ module Bridgetown
   end
 
   class PrototypePage < GeneratedPage
-    # @return [Bridgetown::Page, Bridgetown::Resource::Base]
+    # @return [Bridgetown::GeneratedPage, Bridgetown::Resource::Base]
     attr_reader :prototyped_page
 
     # @param prototyped_page [Bridgetown::Page, Bridgetown::Resource::Base]
     # @param collection [Bridgetown::Collection]
     # @param search_term [String]
     # @param term [String]
-    def initialize(prototyped_page, collection, search_term, term)
+    def initialize(prototyped_page, collection, search_term, term) # rubocop:disable Lint/MissingSuper
       @prototyped_page = prototyped_page
       @site = prototyped_page.site
       @url = ""
       @name = "index.html"
-      @path = prototyped_page.path
-
-      process(@name)
+      @ext = ".html"
+      @basename = "index"
+      @dir = Pathname.new(prototyped_page.relative_path).dirname.to_s.sub(%r{^_pages}, "")
+      @path = site.in_source_dir(@dir, @name)
 
       self.data = Bridgetown::Utils.deep_merge_hashes prototyped_page.data, {}
       self.content = prototyped_page.content
 
-      # Perform some validation that is also performed in Bridgetown::Page
-      validate_data! prototyped_page.path
-      validate_permalink! prototyped_page.path
-
-      @dir = Pathname.new(prototyped_page.relative_path).dirname.to_s.sub(%r{^_pages}, "")
-      @path = site.in_source_dir(@dir, @name)
-
       process_prototype_page_data(collection, search_term, term)
 
-      Bridgetown::Hooks.trigger :pages, :post_init, self
+      Bridgetown::Hooks.trigger :generated_pages, :post_init, self
     end
 
     def process_prototype_page_data(collection, search_term, term)
@@ -171,22 +160,21 @@ module Bridgetown
       slugify_term(term)
     end
 
-    # rubocop:todo Metrics/AbcSize
-    def process_title_data_placeholder(search_term, term)
-      if prototyped_page.data["prototype"]["data"]
-        if data["title"]&.include?(":prototype-data-label")
-          related_data = site.data[prototyped_page.data["prototype"]["data"]].dig(term)
-          if related_data
-            data["#{search_term}_data"] = related_data
-            data_label = related_data[prototyped_page.data["prototype"]["data_label"]]
-            data["title"] = data["title"].gsub(
-              ":prototype-data-label", data_label
-            )
-          end
-        end
+    def process_title_data_placeholder(search_term, term) # rubocop:todo Metrics/AbcSize
+      unless prototyped_page.data["prototype"]["data"] &&
+          data["title"]&.include?(":prototype-data-label")
+        return
       end
+
+      related_data = site.data[prototyped_page.data["prototype"]["data"]][term]
+      return unless related_data
+
+      data["#{search_term}_data"] = related_data
+      data_label = related_data[prototyped_page.data["prototype"]["data_label"]]
+      data["title"] = data["title"].gsub(
+        ":prototype-data-label", data_label
+      )
     end
-    # rubocop:enable Metrics/AbcSize
 
     def process_title_simple_placeholders(term)
       if data["title"]&.include?(":prototype-term-titleize")
@@ -195,11 +183,11 @@ module Bridgetown
         )
       end
 
-      if data["title"]&.include?(":prototype-term")
-        data["title"] = data["title"].gsub(
-          ":prototype-term", term
-        )
-      end
+      return unless data["title"]&.include?(":prototype-term")
+
+      data["title"] = data["title"].gsub(
+        ":prototype-term", term
+      )
     end
 
     def slugify_term(term)

data/lib/bridgetown-core/helpers.rb

@@ -26,6 +26,10 @@ module Bridgetown
         Bridgetown::Utils.parse_webpack_manifest_file(site, asset_type.to_s)
       end
 
+      def live_reload_dev_js
+        Bridgetown::Utils.live_reload_js(site)
+      end
+
       # @param pairs [Hash] A hash of key/value pairs.
       #
       # @return [String] Space-separated keys where the values are truthy.
@@ -52,11 +56,11 @@ module Bridgetown
       #   `url` or `relative_url`
       # @return [String] the permalink URL for the file
       def url_for(relative_path)
-        if relative_path.respond_to?(:relative_url)
+        if relative_path.respond_to?(:relative_url) # rubocop:disable Style/GuardClause
           return safe(relative_path.relative_url) # new resource engine
         elsif relative_path.respond_to?(:url)
           return safe(relative_url(relative_path.url)) # old legacy engine
-        elsif relative_path.start_with?("/", "http")
+        elsif relative_path.to_s.start_with?("/", "http")
           return safe(relative_path)
         end
 
@@ -69,7 +73,8 @@ module Bridgetown
       # @raise [ArgumentError] if the file cannot be found
       def find_relative_url_for_path(relative_path)
         site.each_site_file do |item|
-          if item.relative_path == relative_path || item.relative_path == "/#{relative_path}"
+          if item.relative_path.to_s == relative_path ||
+              item.relative_path.to_s == "/#{relative_path}"
             return safe(item.respond_to?(:relative_url) ? item.relative_url : relative_url(item))
           end
         end

data/lib/bridgetown-core/hooks.rb

@@ -72,14 +72,14 @@ module Bridgetown
       @registry[owner].delete_if { |item| item.block == block }
     end
 
-    def self.trigger(owner, event, *args)
+    def self.trigger(owner, event, *args) # rubocop:disable Metrics/CyclomaticComplexity
       # proceed only if there are hooks to call
       hooks = @registry[owner]&.select { |item| item.event == event }
       return if hooks.nil? || hooks.empty?
 
       prioritized_hooks(hooks).each do |hook|
         if ENV["BRIDGETOWN_LOG_LEVEL"] == "debug"
-          hook_info = args[0]&.respond_to?(:url) ? args[0].relative_path : hook.block
+          hook_info = args[0].respond_to?(:url) ? args[0].relative_path : hook.block
           Bridgetown.logger.debug("Triggering hook:", "#{owner}:#{event} for #{hook_info}")
         end
         hook.block.call(*args)

data/lib/bridgetown-core/layout.rb

@@ -2,7 +2,6 @@
 
 module Bridgetown
   class Layout
-    include DataAccessible
     include FrontMatterImporter
     include LiquidRenderable
 
@@ -44,9 +43,7 @@ module Bridgetown
     # @param file [String]
     # @return [String]
     def self.label_for_file(file)
-      # TODO: refactor this so multi-extension layout filenames don't leak
-      # middle extensions into layout label
-      file.split(".")[0..-2].join(".")
+      file.split(".").first
     end
 
     # Initialize a new Layout.
@@ -93,6 +90,20 @@ module Bridgetown
       end
     end
 
+    # Returns the contents as a String.
+    def to_s
+      output || content || ""
+    end
+
+    # Accessor for data properties by Liquid.
+    #
+    # property - The String name of the property to retrieve.
+    #
+    # Returns the String value or nil if the property isn't included.
+    def [](property)
+      data[property]
+    end
+
     # The label of the layout (should match what would used in front matter
     # references).
     #

data/lib/bridgetown-core/liquid_renderer.rb

@@ -68,9 +68,7 @@ module Bridgetown
     private
 
     def filename_regex
-      @filename_regex ||= begin
-        %r!\A(#{Regexp.escape(source_dir)}/|/*)(.*)!i
-      end
+      @filename_regex ||= %r!\A(#{Regexp.escape(source_dir)}/|/*)(.*)!i
     end
 
     def new_profile_hash

data/lib/bridgetown-core/log_adapter.rb

@@ -120,7 +120,7 @@ module Bridgetown
     # colon -
     #
     # Returns the formatted topic statement
-    def formatted_topic(topic, colon = false)
+    def formatted_topic(topic, colon = false) # rubocop:disable Style/OptionalBooleanParameter
       "#{topic}#{colon ? ": " : " "}".rjust(20)
     end
 

data/lib/bridgetown-core/log_writer.rb

@@ -2,7 +2,7 @@
 
 module Bridgetown
   class LogWriter < ::Logger
-    def initialize
+    def initialize # rubocop:disable Lint/MissingSuper
       @progname = nil
       @level = DEBUG
       @default_formatter = Formatter.new
@@ -12,6 +12,12 @@ module Bridgetown
       end
     end
 
+    def enable_prefix
+      @formatter = proc do |_, _, _, msg|
+        "\e[32m[Bridgetown]\e[0m #{msg}"
+      end
+    end
+
     def add(severity, message = nil, progname = nil)
       severity ||= UNKNOWN
       @logdev = logdevice(severity)

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

@@ -46,8 +46,10 @@ module Bridgetown
       end
 
       class << self
-        def build(collection_name, path, data)
-          data = Bridgetown::Model::BuilderOrigin.new("builder://#{path}").read do
+        def build(builder, collection_name, path, data)
+          data = Bridgetown::Model::BuilderOrigin.new(
+            Bridgetown::Model::BuilderOrigin.id_for_builder_path(builder, path)
+          ).read do
             data[:_collection_] = Bridgetown::Current.site.collections[collection_name]
             data
           end
@@ -79,11 +81,17 @@ module Bridgetown
         Bridgetown::Resource::Base.new(model: self)
       end
 
+      # @return [Bridgetown::Resource::Base]
       def as_resource_in_collection
         collection.resources << to_resource.read!
         collection.resources.last
       end
 
+      # @return [Bridgetown::Resource::Base]
+      def render_as_resource
+        to_resource.read!.transform!
+      end
+
       # override if need be
       # @return [Bridgetown::Site]
       def site
@@ -114,7 +122,7 @@ module Bridgetown
         attributes.key?(method_name) || method_name.to_s.end_with?("=") || super
       end
 
-      def method_missing(method_name, *args) # rubocop:disable Style/MethodMissingSuper
+      def method_missing(method_name, *args)
         return attributes[method_name] if attributes.key?(method_name)
 
         key = method_name.to_s
@@ -126,7 +134,7 @@ module Bridgetown
         end
 
         Bridgetown.logger.warn "key `#{method_name}' not found in attributes for" \
-                               " #{attributes[:id].presence || ("new " + self.class.to_s)}"
+                               " #{attributes[:id].presence || "new #{self.class}"}"
         nil
       end
 

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

@@ -2,29 +2,29 @@
 
 module Bridgetown
   module Model
-    # Abstract Superclass
     class BuilderOrigin < Origin
       # @return [Pathname]
       attr_reader :relative_path
 
-      # Override in subclass
       def self.handle_scheme?(scheme)
         scheme == "builder"
       end
 
+      def self.id_for_builder_path(builder, path)
+        "builder://#{builder.class.name.gsub("::", ".")}/#{path}"
+      end
+
       def initialize(id)
-        self.id = id
-        @relative_path = Pathname.new(id.delete_prefix("builder://"))
+        super
+        @relative_path = Pathname.new(url.path.delete_prefix("/"))
+      end
+
+      def url
+        @url ||= URI.parse(id)
       end
 
       def read
-        @data = if block_given?
-                  yield
-                elsif defined?(SiteBuilder) && SiteBuilder.respond_to?(:data_for_id)
-                  SiteBuilder.data_for_id(id)
-                else
-                  raise "No builder exists which can read #{id}"
-                end
+        @data = block_given? ? yield : read_data_from_builder
         @data[:_id_] = id
         @data[:_origin_] = self
         @relative_path = Pathname.new(@data[:_relative_path_]) if @data[:_relative_path_]
@@ -35,6 +35,18 @@ module Bridgetown
       def exists?
         false
       end
+
+      def read_data_from_builder
+        builder = Kernel.const_get(url.host.gsub(".", "::"))
+        raise NameError unless builder.instance_methods.include?(:resource_data_for_id)
+
+        builder.new.resource_data_for_id(id) || raise(NameError)
+      rescue NameError
+        raise(
+          Bridgetown::Errors::FatalException,
+          "Builder not found which can read #{id}"
+        )
+      end
     end
   end
 end

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# See bottom of file for specific origin requires...
+
 module Bridgetown
   module Model
     # Abstract Superclass
@@ -36,3 +38,4 @@ end
 
 require "bridgetown-core/model/builder_origin"
 require "bridgetown-core/model/repo_origin"
+require "bridgetown-core/model/plugin_origin"

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Model
+    class PluginOrigin < RepoOrigin
+      class << self
+        def handle_scheme?(scheme)
+          scheme == "plugin"
+        end
+      end
+
+      def manifest
+        @manifest ||= begin
+          manifest_origin = Addressable::URI.unescape(url.path.delete_prefix("/")).split("/").first
+          Bridgetown::PluginManager.source_manifests.find do |manifest|
+            manifest.origin.to_s == manifest_origin
+          end.tap do |manifest|
+            raise "Unable to locate a source manifest for #{manifest_origin}" unless manifest
+          end
+        end
+      end
+
+      def relative_path
+        @relative_path ||= Pathname.new(
+          Addressable::URI.unescape(url.path.delete_prefix("/")).split("/")[1..-1].join("/")
+        )
+      end
+
+      def original_path
+        @original_path ||= relative_path.expand_path(manifest.content)
+      end
+    end
+  end
+end

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

@@ -47,7 +47,7 @@ module Bridgetown
       end
 
       def url
-        @url = URI.parse(id)
+        @url ||= URI.parse(id)
       end
 
       def relative_path

data/lib/bridgetown-core/plugin_manager.rb

@@ -104,7 +104,7 @@ module Bridgetown
 
       # check matching version number is see if it's already installed
       if package_json["dependencies"]
-        current_version = package_json["dependencies"].dig(yarn_dependency.first)
+        current_version = package_json["dependencies"][yarn_dependency.first]
         package_requires_updating?(current_version, yarn_dependency.last)
       else
         true
@@ -112,7 +112,7 @@ module Bridgetown
     end
 
     def self.package_requires_updating?(current_version, dep_version)
-      current_version.nil? || current_version != dep_version && !current_version.include?("/")
+      current_version.nil? || (current_version != dep_version && !current_version.include?("/"))
     end
 
     # Require all .rb files
@@ -160,7 +160,6 @@ module Bridgetown
       end
     end
 
-    # rubocop:disable Metrics/AbcSize
     def setup_component_loaders
       unless @component_loaders.keys.empty?
         @component_loaders.each do |_path, loader|
@@ -173,16 +172,17 @@ module Bridgetown
       # source components _before_ we load any from plugins
       site.components_load_paths.reverse_each do |load_path|
         next unless Dir.exist? load_path
-        next if Zeitwerk::Registry.loaders.find { |loader| loader.manages?(load_path) }
 
-        @component_loaders[load_path] = Zeitwerk::Loader.new
-        @component_loaders[load_path].push_dir(load_path)
-        @component_loaders[load_path].enable_reloading if load_path.start_with?(site.root_dir)
-        @component_loaders[load_path].ignore(File.join(load_path, "**", "*.js.rb"))
-        @component_loaders[load_path].setup
+        begin
+          @component_loaders[load_path] = Zeitwerk::Loader.new
+          @component_loaders[load_path].push_dir(load_path)
+          @component_loaders[load_path].enable_reloading if load_path.start_with?(site.root_dir)
+          @component_loaders[load_path].ignore(File.join(load_path, "**", "*.js.rb"))
+          @component_loaders[load_path].setup
+        rescue Zeitwerk::Error # rubocop:disable Lint/SuppressedException
+        end
       end
     end
-    # rubocop:enable Metrics/AbcSize
 
     def reload_component_loaders
       @component_loaders.each do |path, loader|

data/lib/bridgetown-core/publisher.rb

@@ -15,7 +15,7 @@ module Bridgetown
       return false unless thing.respond_to?(:date)
 
       future_allowed =
-        thing.respond_to?(:collection) && thing.collection.metadata.future || @site.config.future
+        (thing.respond_to?(:collection) && thing.collection.metadata.future) || @site.config.future
       thing_time = thing.date.is_a?(Date) ? thing.date.to_time.to_i : thing.date.to_i
       !future_allowed && thing_time > @site.time.to_i
     end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "zeitwerk"
+require "roda"
+require "json"
+require "roda/plugins/public"
+
+Bridgetown::Current.preloaded_configuration ||= Bridgetown.configuration
+
+require_relative "logger"
+require_relative "roda"
+require_relative "routes"
+require_relative "static_indexes"
+
+module Bridgetown
+  module Rack
+    def self.boot
+      autoload_server_folder(root: Dir.pwd)
+      RodaApp.opts[:bridgetown_preloaded_config] = Bridgetown::Current.preloaded_configuration
+    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 `roda_app.rb'"
+      end
+
+      raise e
+    end
+
+    def self.autoload_server_folder(root:)
+      server_folder = File.join(root, "server")
+      loader = Zeitwerk::Loader.new
+      loader.push_dir server_folder
+      loader.enable_reloading unless ENV["BRIDGETOWN_ENV"] == "production"
+      loader.setup
+      loader.eager_load
+      loader.do_not_eager_load(File.join(server_folder, "roda_app.rb"))
+
+      unless ENV["BRIDGETOWN_ENV"] == "production"
+        begin
+          Listen.to(server_folder) do |_modified, _added, _removed|
+            loader.reload
+            loader.eager_load
+            Bridgetown::Rack::Routes.reload_subclasses
+          end.start
+        # interrupt isn't handled well by the listener
+        rescue ThreadError # rubocop:disable Lint/SuppressedException
+        end
+      end
+    rescue Zeitwerk::Error
+      # We assume if there's an error it's because Zeitwerk already registered this folder,
+      # so it's fine to swallow the error
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module Bridgetown
+  module Rack
+    class Logger < Logger
+      def self.message_with_prefix(msg)
+        return if msg.include?("/_bridgetown/live_reload")
+
+        "\e[35m[Server]\e[0m #{msg}"
+      end
+
+      def initialize(*)
+        super
+        @formatter = proc do |_, _, _, msg|
+          self.class.message_with_prefix(msg)
+        end
+      end
+    end
+  end
+end