bridgetown-core 0.21.5 → 1.0.0.alpha1

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,8 +38,7 @@ 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)
@@ -74,7 +73,7 @@ module Bridgetown
 
     # 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,7 +118,7 @@ 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]
@@ -135,23 +130,17 @@ module Bridgetown
       @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)

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.
@@ -56,7 +60,7 @@ module Bridgetown
           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/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/log_writer.rb

@@ -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

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://"))
+        @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.respond_to?(:resource_data_for_id)
+
+        builder.resource_data_for_id(id)
+      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| # rubocop:disable Style/MultilineBlockChain
+            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

@@ -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|
@@ -184,7 +183,6 @@ module Bridgetown
         end
       end
     end
-    # rubocop:enable Metrics/AbcSize
 
     def reload_component_loaders
       @component_loaders.each do |path, loader|

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

@@ -0,0 +1,47 @@
+# 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
+    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

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "rack/indifferent"
+
+class Roda
+  module RodaPlugins
+    module BridgetownSSR
+      def self.configure(app, _opts = {}, &block)
+        app.opts[:bridgetown_site] = Bridgetown::Site.start_ssr!(&block)
+      end
+    end
+
+    register_plugin :bridgetown_ssr, BridgetownSSR
+  end
+end
+
+module Bridgetown
+  module Rack
+    class Roda < ::Roda
+      plugin :hooks
+      plugin :common_logger, Bridgetown::Rack::Logger.new($stdout), method: :info
+      plugin :json
+      plugin :json_parser
+      plugin :cookies
+      plugin :public, root: Bridgetown::Current.preloaded_configuration.destination
+      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"
+      end
+      plugin :error_handler do |e|
+        puts "\n#{e.class} (#{e.message}):\n\n"
+        puts e.backtrace
+        output_folder = Bridgetown::Current.preloaded_configuration.destination
+        File.read(File.join(output_folder, "500.html"))
+      rescue Errno::ENOENT
+        "500 Internal Server Error"
+      end
+
+      def _roda_run_main_route(r) # rubocop:disable Naming/MethodParameterName
+        if self.class.opts[:bridgetown_site]
+          # The site had previously been initialized via the bridgetown_ssr plugin
+          Bridgetown::Current.site ||= self.class.opts[:bridgetown_site]
+        end
+        Bridgetown::Current.preloaded_configuration ||=
+          self.class.opts[:bridgetown_preloaded_config]
+
+        r.public
+
+        r.root do
+          output_folder = Bridgetown::Current.preloaded_configuration.destination
+          File.read(File.join(output_folder, "index.html"))
+        end
+
+        super
+      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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Rack
+    class Routes
+      class << self
+        attr_accessor :tracked_subclasses
+
+        def inherited(base)
+          Bridgetown::Rack::Routes.track_subclass base
+          super
+        end
+
+        def track_subclass(klass)
+          Bridgetown::Rack::Routes.tracked_subclasses ||= {}
+          Bridgetown::Rack::Routes.tracked_subclasses[klass.name] = klass
+        end
+
+        def reload_subclasses
+          Bridgetown::Rack::Routes.tracked_subclasses&.each_key do |klassname|
+            Kernel.const_get(klassname)
+          rescue NameError
+            Bridgetown::Rack::Routes.tracked_subclasses.delete klassname
+          end
+        end
+
+        attr_accessor :router_block
+
+        def route(&block)
+          self.router_block = block
+        end
+
+        def merge(roda_app)
+          return unless router_block
+
+          new(roda_app).handle_routes
+        end
+
+        def start!(roda_app)
+          if Bridgetown.env.development? &&
+              !Bridgetown::Current.preloaded_configuration.skip_live_reload
+            setup_live_reload roda_app.request
+          end
+
+          Bridgetown::Rack::Routes.tracked_subclasses&.each_value do |klass|
+            klass.merge roda_app
+          end
+
+          if defined?(Bridgetown::Routes::RodaRouter)
+            Bridgetown::Routes::RodaRouter.start!(roda_app)
+          end
+
+          nil
+        end
+
+        def setup_live_reload(request)
+          request.get "_bridgetown/live_reload" do
+            {
+              last_mod: File.stat(
+                File.join(Bridgetown::Current.preloaded_configuration.destination, "index.html")
+              ).mtime.to_i,
+            }
+          rescue StandardError => e
+            { last_mod: 0, error: e.message }
+          end
+        end
+      end
+
+      def initialize(roda_app)
+        @_roda_app = roda_app
+      end
+
+      def handle_routes
+        instance_exec(@_roda_app.request, &self.class.router_block)
+      end
+
+      # rubocop:disable Style/MissingRespondToMissing
+      ruby2_keywords def method_missing(method_name, *args, &block)
+        if @_roda_app.respond_to?(method_name.to_sym)
+          @_roda_app.send method_name.to_sym, *args, &block
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        @_roda_app.respond_to?(method_name.to_sym, include_private) || super
+      end
+      # rubocop:enable Style/MissingRespondToMissing
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "roda/plugins/public"
+
+Roda::RodaPlugins::Public::RequestMethods.module_eval do
+  SPLIT = Regexp.union(*[File::SEPARATOR, File::ALT_SEPARATOR].compact)
+  def public_path_segments(path) # rubocop:disable Metrics/CyclomaticComplexity
+    segments = []
+
+    path.split(SPLIT).each do |seg|
+      next if seg.empty? || seg == "."
+
+      seg == ".." ? segments.pop : segments << seg
+    end
+
+    path = ::File.join(roda_class.opts[:public_root], *segments)
+    unless ::File.file?(path)
+      path = ::File.join(path, "index.html")
+      if ::File.file?(path)
+        segments << "index.html"
+      else
+        segments[segments.size - 1] = "#{segments.last}.html"
+      end
+    end
+
+    segments
+  rescue IndexError
+    nil
+  end
+end