bridgetown-core 0.21.4 → 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,15 +106,6 @@ 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

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,20 +33,18 @@ class Bridgetown::Site
         )
       end
       self.layouts = HashWithDotAccess::Hash.new
-      self.pages = []
+      self.generated_pages = []
       self.static_files = []
-      self.data = HashWithDotAccess::Hash.new
+      self.data = HashWithDotAccess::Hash.new unless soft
       @frontend_manifest = nil
-      @post_attr_hash = {}
       @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.
@@ -52,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

data/lib/bridgetown-core/configuration.rb

@@ -34,32 +34,28 @@ module Bridgetown
       "encoding"             => "utf-8",
       "markdown_ext"         => "markdown,mkdown,mkdn,mkd,md",
       "strict_front_matter"  => false,
-      "slugify_categories"   => true,
       "slugify_mode"         => "pretty",
 
       # Filtering Content
-      "limit_posts"          => 0,
       "future"               => false,
       "unpublished"          => false,
       "ruby_in_front_matter" => true,
 
       # Conversion
+      "content_engine"       => "resource",
       "markdown"             => "kramdown",
       "highlighter"          => "rouge",
-      "lsi"                  => false,
       "excerpt_separator"    => "\n\n",
-      "incremental"          => false,
 
       # Serving
-      "detach"               => false, # default to not detaching the server
       "port"                 => "4000",
       "host"                 => "127.0.0.1",
       "base_path"            => "/",
       "show_dir_listing"     => false,
 
       # Output Configuration
-      "available_locales"    => ["en"],
-      "default_locale"       => "en",
+      "available_locales"    => [:en],
+      "default_locale"       => :en,
       "permalink"            => nil, # default is set according to content engine
       "timezone"             => nil, # use the local timezone
 
@@ -103,6 +99,7 @@ module Bridgetown
       def from(user_config, starting_defaults = DEFAULTS)
         Utils.deep_merge_hashes(starting_defaults.deep_dup, Configuration[user_config])
           .merge_environment_specific_options!
+          .setup_locales
           .add_default_collections
           .add_default_excludes
           .check_include_exclude
@@ -247,6 +244,12 @@ module Bridgetown
       self
     end
 
+    def setup_locales
+      self.default_locale = default_locale.to_sym
+      available_locales.map!(&:to_sym)
+      self
+    end
+
     def add_default_collections # rubocop:todo all
       # It defaults to `{}`, so this is only if someone sets it to null manually.
       return self if self[:collections].nil?
@@ -263,23 +266,16 @@ module Bridgetown
       self[:collections][:posts][:output] = true
       self[:collections][:posts][:sort_direction] ||= "descending"
 
-      if self[:content_engine] == "resource"
-        self[:permalink] = "pretty" if self[:permalink].blank?
-        self[:collections][:pages] = {} unless self[:collections][:pages]
-        self[:collections][:pages][:output] = true
-        self[:collections][:pages][:permalink] ||= "/:path/"
+      self[:permalink] = "pretty" if self[:permalink].blank?
+      self[:collections][:pages] = {} unless self[:collections][:pages]
+      self[:collections][:pages][:output] = true
+      self[:collections][:pages][:permalink] ||= "/:locale/:path/"
 
-        self[:collections][:data] = {} unless self[:collections][:data]
-        self[:collections][:data][:output] = false
+      self[:collections][:data] = {} unless self[:collections][:data]
+      self[:collections][:data][:output] = false
 
-        unless self[:collections][:posts][:permalink]
-          self[:collections][:posts][:permalink] = self[:permalink]
-        end
-      else
-        self[:permalink] = "date" if self[:permalink].blank?
-        unless self[:collections][:posts][:permalink]
-          self[:collections][:posts][:permalink] = style_to_permalink(self[:permalink])
-        end
+      unless self[:collections][:posts][:permalink]
+        self[:collections][:posts][:permalink] = self[:permalink]
       end
 
       self
@@ -304,26 +300,6 @@ module Bridgetown
         self["ruby_in_front_matter"]
     end
 
-    # Deprecated, to be removed when Bridgetown goes Resource-only
-    def style_to_permalink(permalink_style) # rubocop:todo Metrics/CyclomaticComplexity
-      case permalink_style.to_s.to_sym
-      when :pretty
-        "/:categories/:year/:month/:day/:title/"
-      when :simple
-        "/:categories/:title/"
-      when :none
-        "/:categories/:title:output_ext"
-      when :date
-        "/:categories/:year/:month/:day/:title:output_ext"
-      when :ordinal
-        "/:categories/:year/:y_day/:title:output_ext"
-      when :weekdate
-        "/:categories/:year/W:week/:short_day/:title:output_ext"
-      else
-        permalink_style.to_s
-      end
-    end
-
     def check_include_exclude
       %w(include exclude).each do |option|
         next unless key?(option)
@@ -333,11 +309,6 @@ module Bridgetown
               "'#{option}' should be set as an array, but was: #{self[option].inspect}."
       end
 
-      unless self[:include].include?("_pages") || self[:content_engine] == "resource"
-        # add _pages to includes set
-        self[:include] << "_pages"
-      end
-
       self
     end