bridgetown-core 0.21.2 → 1.0.0.alpha2

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,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,88 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Rack
+    class Routes
+      class << self
+        attr_accessor :tracked_subclasses, :router_block
+
+        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
+
+        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
+
+      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
+    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) # rubocop:disable Lint/ConstantDefinitionInBlock
+  def public_path_segments(path) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    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

data/lib/bridgetown-core/reader.rb

@@ -2,6 +2,7 @@
 
 module Bridgetown
   class Reader
+    # @return [Bridgetown::Site]
     attr_reader :site
 
     def initialize(site)
@@ -11,34 +12,34 @@ module Bridgetown
     # Read Site data from disk and load it into internal data structures.
     #
     # Returns nothing.
-    def read # rubocop:todo Metrics/AbcSize
+    def read
       site.defaults_reader.read
-      site.layouts = LayoutReader.new(site).read
+      read_layouts
       read_directories
-      read_included_excludes
+      read_includes
       sort_files!
+      site.data = site.collections.data.read.merge_data_resources
       read_collections
-      site.data = if site.uses_resource?
-                    site.collections.data.merge_data_resources
-                  else
-                    DataReader.new(site).read
-                  end
-      Bridgetown::PluginManager.source_manifests.map(&:content).compact.each do |plugin_content_dir|
-        PluginContentReader.new(site, plugin_content_dir).read
+      Bridgetown::PluginManager.source_manifests.select(&:content).each do |manifest|
+        PluginContentReader.new(site, manifest).read
       end
     end
 
+    def read_layouts
+      site.layouts = LayoutReader.new(site).read
+    end
+
     def read_collections
       site.collections.each_value do |collection|
-        collection.read unless !site.uses_resource? &&
-          collection.legacy_reader?
+        next if collection.data?
+
+        collection.read
       end
     end
 
-    # Sorts posts, pages, and static files.
+    # Sorts generated pages and static files.
     def sort_files!
-      site.collections.each_value { |c| c.docs.sort! }
-      site.pages.sort_by!(&:name)
+      site.generated_pages.sort_by!(&:name)
       site.static_files.sort_by!(&:relative_path)
     end
 
@@ -70,24 +71,11 @@ module Bridgetown
         end
       end
 
-      retrieve_posts(dir) unless site.uses_resource?
       retrieve_dirs(base, dir, dot_dirs)
       retrieve_pages(dir, dot_pages)
       retrieve_static_files(dir, dot_static_files)
     end
 
-    # Retrieves all the posts(posts) from the given directory
-    # and add them to the site and sort them.
-    #
-    # dir - The String representing the directory to retrieve the posts from.
-    #
-    # Returns nothing.
-    def retrieve_posts(dir)
-      return if outside_configured_directory?(dir)
-
-      post_reader.read_posts(dir)
-    end
-
     # Recursively traverse directories with the read_directories function.
     #
     # base - The String representing the site's base directory.
@@ -111,14 +99,9 @@ module Bridgetown
     #
     # Returns nothing.
     def retrieve_pages(dir, dot_pages)
-      if site.uses_resource?
-        dot_pages.each do |page_path|
-          site.collections.pages.read_resource(site.in_source_dir(dir, page_path))
-        end
-        return
+      dot_pages.each do |page_path|
+        site.collections.pages.read_resource(site.in_source_dir(dir, page_path))
       end
-
-      site.pages.concat(PageReader.new(site, dir).read(dot_pages))
     end
 
     # Retrieve all the static files from the current directory,
@@ -176,13 +159,7 @@ module Bridgetown
       !collections_dir.empty? && !dir.start_with?("/#{collections_dir}")
     end
 
-    # Create a single PostReader instance to retrieve posts from all valid
-    # directories in current site.
-    def post_reader
-      @post_reader ||= PostReader.new(site)
-    end
-
-    def read_included_excludes
+    def read_includes
       site.config.include.each do |entry|
         next if entry == ".htaccess"
 
@@ -196,11 +173,7 @@ module Bridgetown
     def read_included_file(entry_path)
       dir  = File.dirname(entry_path).sub(site.source, "")
       file = Array(File.basename(entry_path))
-      if Utils.has_yaml_header?(entry_path)
-        site.pages.concat(PageReader.new(site, dir).read(file))
-      else
-        retrieve_static_files(dir, file)
-      end
+      retrieve_static_files(dir, file)
     end
   end
 end

data/lib/bridgetown-core/readers/layout_reader.rb

@@ -47,10 +47,10 @@ module Bridgetown
       Layout.label_for_file(file)
     end
 
-    def within(directory)
+    def within(directory, &block)
       return unless File.exist?(directory)
 
-      Dir.chdir(directory) { yield }
+      Dir.chdir(directory, &block)
     end
   end
 end

data/lib/bridgetown-core/readers/plugin_content_reader.rb

@@ -2,11 +2,14 @@
 
 module Bridgetown
   class PluginContentReader
-    attr_reader :site, :content_dir
+    attr_reader :site, :manifest, :content_dir
 
-    def initialize(site, plugin_content_dir)
+    # @param site [Bridgetown::Site]
+    # @param manifest [Bridgetown::Plugin::SourceManifest]
+    def initialize(site, manifest)
       @site = site
-      @content_dir = plugin_content_dir
+      @manifest = manifest
+      @content_dir = manifest.content
       @content_files = Set.new
     end
 
@@ -28,13 +31,11 @@ module Bridgetown
       dir = File.dirname(path.sub("#{content_dir}/", ""))
       name = File.basename(path)
 
-      @content_files << if Utils.has_yaml_header?(path)
-                          Bridgetown::Page.new(site, content_dir, dir, name, from_plugin: true)
+      @content_files << if Utils.has_yaml_header?(path) || Utils.has_rbfm_header?(path)
+                          site.collections.pages.read_resource(path, manifest: manifest)
                         else
                           Bridgetown::StaticFile.new(site, content_dir, "/#{dir}", name)
                         end
-
-      add_to(site.pages, Bridgetown::Page)
       add_to(site.static_files, Bridgetown::StaticFile)
     end
 

data/lib/bridgetown-core/renderer.rb

@@ -65,7 +65,7 @@ module Bridgetown
     def execute_inline_ruby!
       return unless site.config.should_execute_inline_ruby?
 
-      Bridgetown::Utils::RubyExec.search_data_for_ruby_code(document, self)
+      Bridgetown::Utils::RubyExec.search_data_for_ruby_code(document)
     end
 
     # Convert the document using the converters which match this renderer's document.
@@ -98,7 +98,6 @@ module Bridgetown
 
       while layout
         output = render_layout(output, layout)
-        add_regenerator_dependencies(layout)
 
         next unless (layout = site.layouts[layout.data["layout"]])
         break if used.include?(layout)
@@ -120,7 +119,7 @@ module Bridgetown
         !(document.is_a? Bridgetown::Excerpt)
 
       Bridgetown.logger.warn "Build Warning:", "Layout '#{document.data["layout"]}' requested " \
-        "in #{document.relative_path} does not exist."
+                                               "in #{document.relative_path} does not exist."
     end
 
     # Render layout content into document.output
@@ -144,15 +143,6 @@ module Bridgetown
       end
     end
 
-    def add_regenerator_dependencies(layout)
-      return unless document.write?
-
-      site.regenerator.add_dependency(
-        site.in_source_dir(document.path),
-        layout.path
-      )
-    end
-
     def permalink_ext
       document_permalink = document.permalink
       if document_permalink &&