bridgetown-core 0.21.4 → 1.0.0.alpha4

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

@@ -12,36 +12,33 @@ 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 = if site.uses_resource?
-                    site.collections.data.read
-                    site.collections.data.merge_data_resources
-                  else
-                    DataReader.new(site).read
-                  end
+      site.data = site.collections.data.read.merge_data_resources
       read_collections
-      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|
-        next if site.uses_resource? && collection.data?
-        next if !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.posts.docs.sort! unless site.uses_resource?
       site.generated_pages.sort_by!(&:name)
       site.static_files.sort_by!(&:relative_path)
     end
@@ -74,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.
@@ -115,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,
@@ -180,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"
 
@@ -200,12 +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)
-        # TODO: does this need to get incorporated into the resource engine?
-        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 &&

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

@@ -53,7 +53,7 @@ module Bridgetown
         @layout = site.layouts[data.layout].tap do |layout|
           unless layout
             Bridgetown.logger.warn "Resource:", "Layout '#{data.layout}' " \
-            "requested via #{relative_path} does not exist."
+                                                "requested via #{relative_path} does not exist."
           end
         end
       end
@@ -116,6 +116,8 @@ module Bridgetown
 
       def transform!
         transformer.process! unless collection.data?
+
+        self
       end
 
       def trigger_hooks(hook_name, *args)
@@ -261,19 +263,18 @@ module Bridgetown
         "#<#{self.class} #{id}>"
       end
 
-      # Compare this document against another document.
-      # Comparison is a comparison between the 2 paths of the documents.
+      # Compare this resource against another resource.
+      # Comparison is a comparison between the 2 dates or paths of the resources.
       #
-      # Returns -1, 0, +1 or nil depending on whether this doc's path is less than,
-      #   equal or greater than the other doc's path. See String#<=> for more details.
+      # @return [Integer] -1, 0, or +1
       def <=>(other) # rubocop:todo Metrics/AbcSize
         return nil unless other.respond_to?(:data)
 
-        if data.date.respond_to?(:to_datetime) && other.data.date.respond_to?(:to_datetime)
-          return data.date.to_datetime <=> other.data.date.to_datetime
-        end
+        cmp = if data.date.respond_to?(:to_datetime) && other.data.date.respond_to?(:to_datetime)
+                data.date.to_datetime <=> other.data.date.to_datetime
+              end
 
-        cmp = data["date"] <=> other.data["date"]
+        cmp = data["date"] <=> other.data["date"] if cmp.nil?
         cmp = path <=> other.path if cmp.nil? || cmp.zero?
         cmp
       end
@@ -292,7 +293,9 @@ module Bridgetown
 
       private
 
-      def ensure_default_data
+      def ensure_default_data # rubocop:todo Metrics/AbcSize
+        determine_locale
+
         slug = if matches = relative_path.to_s.match(DATE_FILENAME_MATCHER) # rubocop:disable Lint/AssignmentInCondition
                  set_date_from_string(matches[1]) unless data.date
                  matches[2]
@@ -300,6 +303,8 @@ module Bridgetown
                  basename_without_ext
                end
 
+        slug.chomp!(".#{data.locale}") if data.locale && slug.ends_with?(".#{data.locale}")
+
         data.slug ||= slug
         data.title ||= Bridgetown::Utils.titleize_slug(slug)
       end
@@ -309,7 +314,7 @@ module Bridgetown
 
         data.date = Bridgetown::Utils.parse_date(
           new_date,
-          "Document '#{relative_path}' does not have a valid date in the #{model}."
+          "Resource '#{relative_path}' does not have a valid date."
         )
       end
 
@@ -332,6 +337,24 @@ module Bridgetown
         end
       end
 
+      def determine_locale # rubocop:todo Metrics/AbcSize
+        unless data.locale
+          data.locale = locale_from_alt_data_or_filename.presence || site.config.default_locale
+        end
+
+        return unless data.locale_overrides.is_a?(Hash) && data.locale_overrides&.key?(data.locale)
+
+        data.merge!(data.locale_overrides[data.locale])
+      end
+
+      # Look for alternative front matter or look at the filename pattern: slug.locale.ext
+      def locale_from_alt_data_or_filename
+        found_locale = data.language || data.lang || basename_without_ext.split(".")[1..-1].last
+        return unless found_locale && site.config.available_locales.include?(found_locale.to_sym)
+
+        found_locale
+      end
+
       def format_url(url)
         url.to_s.sub(%r{index\.html?$}, "").sub(%r{\.html?$}, "")
       end

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

@@ -36,20 +36,20 @@ module Bridgetown
         new_url = url_segments.map do |segment|
           segment.starts_with?(":") ? process_segment(segment.sub(%r{^:}, "")) : segment
         end.select(&:present?).join("/")
-
         # No relative URLs should ever end in /index.html
         new_url.sub!(%r{/index$}, "") if final_ext == ".html"
 
-        add_base_path finalize_permalink(new_url, permalink)
+        ensure_base_path finalize_permalink(new_url, permalink)
       end
 
       def process_segment(segment)
         segment = segment.to_sym
         if self.class.placeholder_processors[segment]
           segment_value = self.class.placeholder_processors[segment].(resource)
-          if segment_value.is_a?(Hash)
+          case segment_value
+          when Hash
             segment_value[:raw_value]
-          elsif segment_value.is_a?(Array)
+          when Array
             segment_value.map do |subsegment|
               Utils.slugify(subsegment, mode: slugify_mode)
             end.join("/")
@@ -66,13 +66,13 @@ module Bridgetown
 
         case permalink_style.to_sym
         when :pretty
-          "#{collection_prefix}/:categories/:year/:month/:day/:slug/"
+          "/:locale/#{collection_prefix}/:categories/:year/:month/:day/:slug/"
         when :pretty_ext, :date
-          "#{collection_prefix}/:categories/:year/:month/:day/:slug.*"
+          "/:locale/#{collection_prefix}/:categories/:year/:month/:day/:slug.*"
         when :simple
-          "#{collection_prefix}/:categories/:slug/"
+          "/:locale/#{collection_prefix}/:categories/:slug/"
         when :simple_ext
-          "#{collection_prefix}/:categories/:slug.*"
+          "/:locale/#{collection_prefix}/:categories/:slug.*"
         else
           permalink_style.to_s
         end
@@ -96,7 +96,7 @@ module Bridgetown
         end
       end
 
-      def add_base_path(permalink)
+      def ensure_base_path(permalink)
         if resource.site.base_path.present?
           return "#{resource.site.base_path(strip_slash_only: true)}#{permalink}"
         end
@@ -108,7 +108,16 @@ module Bridgetown
 
       # @param resource [Bridgetown::Resource::Base]
       register_placeholder :path, ->(resource) do
-        { raw_value: resource.relative_path_basename_without_prefix }
+        {
+          raw_value: resource.relative_path_basename_without_prefix.tap do |path|
+            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
+          end,
+        }
       end
 
       # @param resource [Bridgetown::Resource::Base]
@@ -128,8 +137,10 @@ module Bridgetown
 
       # @param resource [Bridgetown::Resource::Base]
       register_placeholder :locale, ->(resource) do
-        locale_data = resource.data.locale
-        resource.site.config.available_locales.include?(locale_data) ? locale_data : nil
+        next nil if resource.data.locale&.to_sym == resource.site.config.default_locale
+
+        locale_data = resource.data.locale&.to_sym
+        resource.site.config.available_locales.include?(locale_data) ? locale_data.to_s : nil
       end
       register_placeholder :lang, placeholder_processors[:locale]
 

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

@@ -94,9 +94,8 @@ module Bridgetown
       # @return [Bridgetown::Resource::Base, Array<Bridgetown::Resource::Base>]
       def belongs_to_relation_for_type(type)
         if resource.data[type].is_a?(Array)
-          other_collection_for_type(type).resources.select do |other_resource|
-            other_resource.data.slug.in?(resource.data[type])
-          end
+          other_slugs = other_collection_for_type(type).resources_by_slug
+          resource.data[type].map { |slug| other_slugs[slug] }.compact
         else
           other_collection_for_type(type).resources.find do |other_resource|
             other_resource.data.slug == resource.data[type]

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

@@ -3,11 +3,7 @@
 module Bridgetown
   module Resource
     class TaxonomyTerm
-      attr_reader :resource
-
-      attr_reader :label
-
-      attr_reader :type
+      attr_reader :resource, :label, :type
 
       def initialize(resource:, label:, type:)
         @resource = resource

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

@@ -41,7 +41,7 @@ module Bridgetown
       def execute_inline_ruby!
         return unless site.config.should_execute_inline_ruby?
 
-        Bridgetown::Utils::RubyExec.search_data_for_ruby_code(resource, self)
+        Bridgetown::Utils::RubyExec.search_data_for_ruby_code(resource)
       end
 
       def inspect
@@ -103,10 +103,12 @@ module Bridgetown
       end
 
       def warn_on_missing_layout(layout, layout_name)
-        if layout.nil? && layout_name
-          Bridgetown.logger.warn "Build Warning:", "Layout '#{layout_name}' " \
-          "requested via #{resource.relative_path} does not exist."
-        end
+        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
@@ -152,7 +154,7 @@ module Bridgetown
         layout_input = layout.content.dup
 
         layout_converters.inject(layout_input) do |content, converter|
-          next(content) unless [2, -2].include?(converter.method(:convert).arity)
+          next(content) unless [2, -2].include?(converter.method(:convert).arity) # rubocop:disable Performance/CollectionLiteralInLoop
 
           layout.current_document = resource
           layout.current_document_output = output

data/lib/bridgetown-core/ruby_template_view.rb

@@ -61,19 +61,17 @@ module Bridgetown
       @helpers ||= Helpers.new(self, site)
     end
 
-    # rubocop:disable Style/MissingRespondToMissing
-    ruby2_keywords def method_missing(method, *args, &block)
-      if helpers.respond_to?(method.to_sym)
-        helpers.send method.to_sym, *args, &block
+    ruby2_keywords def method_missing(method_name, *args, &block)
+      if helpers.respond_to?(method_name.to_sym)
+        helpers.send method_name.to_sym, *args, &block
       else
         super
       end
     end
 
-    def respond_to_missing?(method, include_private = false)
-      helpers.respond_to?(method.to_sym, include_private) || super
+    def respond_to_missing?(method_name, include_private = false)
+      helpers.respond_to?(method_name.to_sym, include_private) || super
     end
-    # rubocop:enable Style/MissingRespondToMissing
 
     private
 
@@ -84,7 +82,7 @@ module Bridgetown
                            ["{% render \"#{component}\""]
                          end
       unless options.empty?
-        render_statement << ", " + options.keys.map { |k| "#{k}: #{k}" }.join(", ")
+        render_statement << ", #{options.keys.map { |k| "#{k}: #{k}" }.join(", ")}"
       end
       render_statement << " %}"
       if options[:_block_content]