bridgetown-core 0.21.1 → 1.0.0.alpha1

data/lib/bridgetown-core/commands/start.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Commands
+    class Start < Thor::Group
+      extend BuildOptions
+      extend Summarizable
+      include ConfigurationOverridable
+
+      Registrations.register do
+        register(Start, "start", "start", Start.summary)
+        register(Start, "dev", "dev", "Alias of start")
+      end
+
+      class_option :bind, aliases: "-B", desc: "URI for Puma to bind to (start with tcp://)"
+      class_option :skip_frontend,
+                   type: :boolean,
+                   desc: "Don't load the frontend bundler (always true for production)"
+      class_option :skip_live_reload,
+                   type: :boolean,
+                   desc: "Don't use the live reload functionality (always true for production)"
+
+      def self.banner
+        "bridgetown start [options]"
+      end
+      summary "Start the Puma server, frontend bundler, and Bridgetown watcher"
+
+      def start # rubocop:todo Metrics/PerceivedComplexity
+        Bridgetown.logger.writer.enable_prefix
+        Bridgetown::Commands::Build.print_startup_message
+        sleep 0.25
+
+        unless Bundler.definition.specs.find { |s| s.name == "puma" }
+          raise "** No Rack-compatible server found **"
+        end
+
+        options = Thor::CoreExt::HashWithIndifferentAccess.new(self.options)
+        options[:using_puma] = true
+
+        # Load Bridgetown configuration into thread memory
+        bt_options = configuration_with_overrides(options)
+
+        puma_pid =
+          Process.fork do
+            require "puma/cli"
+
+            Puma::Runner.class_eval do
+              def output_header(mode)
+                log "* Puma version: #{Puma::Const::PUMA_VERSION} (#{ruby_engine}) (\"#{Puma::Const::CODE_NAME}\")" # rubocop:disable Layout/LineLength
+                if mode == "cluster"
+                  log "* Cluster Master PID: #{Process.pid}"
+                else
+                  log "* PID: #{Process.pid}"
+                end
+              end
+            end
+
+            puma_args = []
+            if bt_options[:bind]
+              puma_args << "--bind"
+              puma_args << bt_options[:bind]
+            end
+
+            cli = Puma::CLI.new puma_args
+            cli.run
+          end
+
+        begin
+          unless Bridgetown.env.production? || options[:skip_frontend]
+            require "rake"
+            Rake.with_application do |rake|
+              rake.load_rakefile
+              rake["frontend:watcher"].invoke(true)
+            end
+          end
+
+          Signal.trap("TERM") do
+            Process.kill "SIGINT", puma_pid
+            sleep 0.5 # let it breathe
+            exit 0 # this runs the ensure block below
+          end
+
+          Process.setproctitle("bridgetown #{Bridgetown::VERSION} [#{File.basename(Dir.pwd)}]")
+
+          build_args = ["-w"] + ARGV.reject { |arg| arg == "start" }
+          if Bridgetown.env.development? && !options["url"]
+            scheme = bt_options.bind&.split("://")&.first == "ssl" ? "https" : "http"
+            port = bt_options.bind&.split(":")&.last || ENV["BRIDGETOWN_PORT"] || 4000
+            build_args << "--url"
+            build_args << "#{scheme}://localhost:#{port}"
+          end
+          Bridgetown::Commands::Build.start(build_args)
+        rescue StandardError => e
+          Process.kill "SIGINT", puma_pid
+          sleep 0.5
+          raise e
+        ensure
+          # Shut down webpack, browsersync, etc. if they're running
+          Bridgetown::Utils::Aux.kill_processes
+        end
+
+        sleep 0.5 # finish cleaning up
+      end
+    end
+  end
+end

data/lib/bridgetown-core/commands/webpack/webpack.defaults.js.erb

@@ -24,8 +24,8 @@ const output = {
 
 // Rules and Loaders
 
-const jsRule =  {
-  test: /\.(js|jsx)/,
+const jsRule = {
+  test: /\.(js|jsx)$/,
   use: {
     loader: "esbuild-loader",
     options: {

data/lib/bridgetown-core/concerns/site/configurable.rb

@@ -62,18 +62,6 @@ class Bridgetown::Site
       @frontmatter_defaults ||= Bridgetown::FrontmatterDefaults.new(self)
     end
 
-    # Whether to perform a full rebuild without incremental regeneration.
-    #   If either `override["incremental"]` or `config["incremental"]` are true,
-    #   fully rebuild the site. If not, incrementally build the site.
-    #
-    # @param [Hash] override
-    #   An override hash to override the current config value
-    # @option override [Boolean] "incremental" Whether to incrementally build
-    # @return [Boolean] true for full rebuild, false for normal build
-    def incremental?(override = {})
-      override["incremental"] || config["incremental"]
-    end
-
     # Returns the current instance of {Publisher} or creates a new instance of
     #   {Publisher} if one doesn't exist.
     #

data/lib/bridgetown-core/concerns/site/content.rb

@@ -3,37 +3,9 @@
 class Bridgetown::Site
   # Content is king!
   module Content
-    # Construct a Hash of Posts indexed by the specified Post attribute.
-    #
-    # Returns a hash like so: `{ attr => posts }` where:
-    #
-    # * `attr` - One of the values for the requested attribute.
-    # * `posts` - The array of Posts with the given attr value.
-    #
-    # @param post_attr [String] The String name of the Post attribute.
-    #
-    # @example
-    #   post_attr_hash('categories')
-    #   # => { 'tech' => [<Post A>, <Post B>],
-    #   #      'ruby' => [<Post B>] }
-    #
-    # @return [Hash{String, Symbol => Array<Post>}]
-    #   Returns a hash of !{attr => posts}
-    def post_attr_hash(post_attr)
-      # Build a hash map based on the specified post attribute ( post attr =>
-      # array of posts ) then sort each array in reverse order.
-      @post_attr_hash[post_attr] ||= begin
-        hash = Hash.new { |h, key| h[key] = [] }
-        posts.docs.each do |p|
-          p.data[post_attr]&.each { |t| hash[t] << p }
-        end
-        hash.each_value { |posts| posts.sort!.reverse! }
-        hash
-      end
-    end
-
     def resources_grouped_by_taxonomy(taxonomy)
-      @post_attr_hash[taxonomy.label] ||= begin
+      data.site_taxonomies_hash ||= {}
+      data.site_taxonomies_hash[taxonomy.label] ||= begin
         taxonomy.terms.transform_values { |terms| terms.map(&:resource).sort.reverse }
       end
     end
@@ -44,29 +16,12 @@ class Bridgetown::Site
       end
     end
 
-    # Returns a hash of "tags" using {#post_attr_hash} where each tag is a key
-    #  and each value is a post which contains the key.
-    # @example
-    #   tags
-    #   # => { 'tech': [<Post A>, <Post B>],
-    #   #      'ruby': [<Post C> }
-    # @return [Hash{String, Array<Post>}] Returns a hash of all tags and their corresponding posts
-    # @see post_attr_hash
     def tags
-      uses_resource? ? taxonomies.tag : post_attr_hash("tags")
+      taxonomies.tag
     end
 
-    # Returns a hash of "categories" using {#post_attr_hash} where each tag is
-    #  a key and each value is a post which contains the key.
-    # @example
-    #   categories
-    #   # => { 'tech': [<Post A>, <Post B>],
-    #   #      'ruby': [<Post C> }
-    # @return [Hash{String, Array<Post>}] Returns a hash of all categories and
-    #   their corresponding posts
-    # @see post_attr_hash
     def categories
-      uses_resource? ? taxonomies.category : post_attr_hash("categories")
+      taxonomies.category
     end
 
     # Returns the value of `data["site_metadata"]` or creates a new instance of
@@ -78,34 +33,7 @@ class Bridgetown::Site
 
     # The Hash payload containing site-wide data.
     #
-    # @example
-    #   site_payload
-    #   # => { "site" => data } Where data is a Hash. See example below
-    #
-    #   site = site_payload["site"]
-    #   # => Returns a Hash with the following keys:
-    #   #
-    #   # site["time"]       - The Time as specified in the configuration or the
-    #   #                      current time if none was specified.
-    #   #
-    #   # site["posts"]      - The Array of Posts, sorted chronologically by post date
-    #   #                      and then title.
-    #   #
-    #   # site["pages"]      - The Array of all Pages.
-    #   #
-    #   # site["html_pages"] - The Array of HTML Pages.
-    #   #
-    #   # site["categories"] - The Hash of category values and Posts.
-    #   #                      See Site#post_attr_hash for type info.
-    #   #
-    #   # site["tags"]       - The Hash of tag values and Posts.
-    #   #                      See Site#post_attr_hash for type info.
-    #
     # @return [Hash] Returns a hash in the structure of { "site" => data }
-    #
-    #   See above example for usage.
-    #
-    # @see #post_attr_hash
     def site_payload
       Bridgetown::Drops::UnifiedPayloadDrop.new self
     end
@@ -154,25 +82,6 @@ class Bridgetown::Site
       end.to_h.with_dot_access
     end
 
-    # Get all documents.
-    # @return [Array<Document>] an array of documents from the
-    # configuration
-    def documents
-      collections.each_with_object(Set.new) do |(_, collection), set|
-        set.merge(collection.docs)
-      end.to_a
-    end
-
-    # Get the documents to be written
-    #
-    # @return [Array<Document>] an array of documents which should be
-    #   written and that `respond_to :write?`
-    # @see #documents
-    # @see Collection
-    def docs_to_write
-      documents.select(&:write?)
-    end
-
     # Get all loaded resources.
     # @return [Array<Bridgetown::Resource::Base>] an array of resources
     def resources
@@ -181,23 +90,12 @@ class Bridgetown::Site
       end.to_a
     end
 
+    alias_method :contents, :resources
+
     def resources_to_write
       resources.select(&:write?)
     end
 
-    # Get all posts. Deprecated, to be removed in v1.0.
-    #
-    # @return [Collection] Returns {#collections}`["posts"]`, creating it if need be
-    # @see Collection
-    def posts
-      unless @wrote_deprecation_msg
-        Bridgetown::Deprecator.deprecation_message "Call site.collections.posts " \
-                                                   "instead of site.posts (Ruby code)"
-      end
-      @wrote_deprecation_msg ||= true
-      collections["posts"] ||= Bridgetown::Collection.new(self, "posts")
-    end
-
     # Get the static files to be written
     #
     # @return [Array<StaticFile>] an array of files which should be
@@ -208,17 +106,18 @@ class Bridgetown::Site
       static_files.select(&:write?)
     end
 
-    # Get all pages and documents (posts and collection items) in a single array.
-    #
-    # @return [Array]
-    def contents
-      return resources if uses_resource?
-
-      pages + documents
-    end
-
     def add_generated_page(generated_page)
       generated_pages << generated_page
     end
+
+    # Loads and memoizes the parsed Webpack manifest file (if available)
+    # @return [Hash]
+    def frontend_manifest
+      @frontend_manifest ||= begin
+        manifest_file = in_root_dir(".bridgetown-webpack", "manifest.json")
+
+        JSON.parse(File.read(manifest_file)) if File.exist?(manifest_file)
+      end
+    end
   end
 end

data/lib/bridgetown-core/concerns/site/localizable.rb

@@ -7,7 +7,9 @@ class Bridgetown::Site
     def locale
       @locale ||= begin
         locale = ENV.fetch("BRIDGETOWN_LOCALE", config[:default_locale]).to_sym
-        I18n.load_path << Dir[in_source_dir("_locales") + "/*.yml"]
+        Dir[in_source_dir("_locales") + "/*.yml"].each do |locale_path|
+          I18n.load_path << locale_path
+        end
         I18n.available_locales = config[:available_locales]
         I18n.default_locale = locale
       end

data/lib/bridgetown-core/concerns/site/processable.rb

@@ -22,8 +22,10 @@ class Bridgetown::Site
     end
 
     # Reset all in-memory data and content.
+    #
+
     # @return [void]
-    def reset
+    def reset(soft: false)
       self.time = Time.now
       if config["time"]
         self.time = Bridgetown::Utils.parse_date(
@@ -31,19 +33,18 @@ class Bridgetown::Site
         )
       end
       self.layouts = HashWithDotAccess::Hash.new
-      self.pages = []
+      self.generated_pages = []
       self.static_files = []
-      self.data = HashWithDotAccess::Hash.new
-      @post_attr_hash = {}
+      self.data = HashWithDotAccess::Hash.new unless soft
+      @frontend_manifest = nil
       @collections = nil
       @documents = nil
       @docs_to_write = nil
-      @regenerator.clear_cache
       @liquid_renderer.reset
-      frontmatter_defaults.reset
+      frontmatter_defaults.reset unless soft
 
-      Bridgetown::Cache.clear_if_config_changed config
-      Bridgetown::Hooks.trigger :site, :after_reset, self
+      Bridgetown::Cache.clear_if_config_changed config unless soft
+      Bridgetown::Hooks.trigger :site, (soft ? :after_soft_reset : :after_reset), self
     end
 
     # Read data from disk and load it into internal memory.
@@ -51,23 +52,11 @@ class Bridgetown::Site
     def read
       Bridgetown::Hooks.trigger :site, :pre_read, self
       reader.read
-      limit_posts!
       Bridgetown::Hooks.trigger :site, :post_read, self
     end
 
     private
 
-    # Limits the current posts; removes the posts which exceed the limit_posts
-    def limit_posts!
-      if config.limit_posts.positive?
-        Bridgetown::Deprecator.deprecation_message(
-          "The limit_posts config option will be removed prior to Bridgetown 1.0"
-        )
-        limit = posts.docs.length < config.limit_posts ? posts.docs.length : config.limit_posts
-        posts.docs = posts.docs[-limit, limit]
-      end
-    end
-
     def print_stats
       Bridgetown.logger.info @liquid_renderer.stats_table
     end

data/lib/bridgetown-core/concerns/site/renderable.rb

@@ -9,23 +9,20 @@ class Bridgetown::Site
     def render
       Bridgetown::Hooks.trigger :site, :pre_render, self
       execute_inline_ruby_for_layouts!
-      render_docs
-      render_pages
+      render_resources
+      render_generated_pages
       Bridgetown::Hooks.trigger :site, :post_render, self
     end
 
-    # Executes inline Ruby frontmatter
+    # Executes procs in Ruby frontmatter
     #
-    # @example
-    #   calculation: !ruby/string:Rb |
-    #     [2 * 4, 5 + 2].min
     # @return [void]
     # @see https://www.bridgetownrb.com/docs/front-matter#ruby-front-matter
     def execute_inline_ruby_for_layouts!
       return unless config.should_execute_inline_ruby?
 
       layouts.each_value do |layout|
-        Bridgetown::Utils::RubyExec.search_data_for_ruby_code(layout, self)
+        Bridgetown::Utils::RubyExec.search_data_for_ruby_code(layout)
       end
     end
 
@@ -49,16 +46,10 @@ class Bridgetown::Site
       matches
     end
 
-    # Renders all documents
+    # Renders all resources
     # @return [void]
-    def render_docs
+    def render_resources
       collections.each_value do |collection|
-        collection.docs.each do |document|
-          render_with_locale(document) do
-            render_regenerated document
-          end
-        end
-
         collection.resources.each do |resource|
           render_with_locale(resource) do
             resource.transform!
@@ -67,22 +58,22 @@ class Bridgetown::Site
       end
     end
 
-    # Renders all pages
+    # Renders all generated pages
     # @return [void]
-    def render_pages
-      pages.each do |page|
-        render_regenerated page
+    def render_generated_pages
+      generated_pages.each do |page|
+        render_page page
       end
     end
 
-    # Renders a document while ensuring site locale is set if the data is available.
-    # @param document [Document] The document to render
+    # Renders a content item while ensuring site locale is set if the data is available.
+    # @param item [Document, Page, Bridgetown::Resource::Base] The item to render
     # @yield Runs the block in between locale setting and resetting
     # @return [void]
-    def render_with_locale(document)
-      if document.data["locale"]
+    def render_with_locale(item)
+      if item.data["locale"]
         previous_locale = locale
-        self.locale = document.data["locale"]
+        self.locale = item.data["locale"]
         yield
         self.locale = previous_locale
       else
@@ -90,13 +81,11 @@ class Bridgetown::Site
       end
     end
 
-    # Regenerates a site using {Renderer}
-    # @param document [Document] The document to regenerate.
+    # Regenerates a content item using {Renderer}
+    # @param item [Page] The page to render
     # @return [void]
-    def render_regenerated(document)
-      return unless regenerator.regenerate?(document)
-
-      Bridgetown::Renderer.new(self, document).run
+    def render_page(page)
+      Bridgetown::Renderer.new(self, page).run
     end
   end
 end

data/lib/bridgetown-core/concerns/site/ssr.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+class Bridgetown::Site
+  module SSR
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      # Establish an SSR pipeline for a persistent backend process
+      def start_ssr!
+        if Bridgetown::Current.site
+          raise Bridgetown::Errors::FatalException, "Bridgetown SSR already started! " \
+                                                    "Check your Rack app for threading issues"
+        end
+
+        Bridgetown::PluginManager.require_from_bundler
+        site = new(Bridgetown::Current.preloaded_configuration)
+        site.enable_ssr
+
+        Bridgetown::Hooks.trigger :site, :pre_read, site
+        site.defaults_reader.tap do |d|
+          d.path_defaults.clear
+          d.read
+        end
+        site.layouts = Bridgetown::LayoutReader.new(site).read
+        site.collections.data.tap do |coll|
+          coll.read
+          site.data = coll.merge_data_resources
+        end
+        Bridgetown::Hooks.trigger :site, :post_read, site
+
+        yield(site) if block_given? # provide additional setup hook
+
+        site
+      end
+    end
+
+    def ssr?
+      @ssr_enabled == true
+    end
+
+    def enable_ssr
+      Bridgetown.logger.info "SSR:", "enabled."
+      @ssr_enabled = true
+    end
+
+    def disable_ssr
+      Bridgetown.logger.info "SSR:", "now disabled."
+      @ssr_enabled = false
+    end
+  end
+end

data/lib/bridgetown-core/concerns/site/writable.rb

@@ -13,21 +13,18 @@ class Bridgetown::Site
     #
     # @return [void]
     def write
-      each_site_file do |item|
-        item.write(dest) if regenerator.regenerate?(item)
-      end
-      regenerator.write_metadata
+      each_site_file { |item| item.write(dest) }
       Bridgetown::Hooks.trigger :site, :post_write, self
     end
 
-    # Yields all content objects while looping through {#pages},
-    #   {#static_files_to_write}, {#docs_to_write}, {#resources_to_write}.
+    # Yields all content objects while looping through {#generated_pages},
+    #   {#static_files_to_write}, {#resources_to_write}.
     #
-    # @yieldparam item [Document, Page, StaticFile]
+    # @yieldparam item [Bridgetown::Resource::Base, GeneratedPage, StaticFile]
     #
     # @return [void]
     def each_site_file
-      %w(pages static_files_to_write docs_to_write resources_to_write).each do |type|
+      %w(generated_pages static_files_to_write resources_to_write).each do |type|
         send(type).each do |item|
           yield item
         end