bridgetown-core 0.21.4 → 1.0.0.alpha1

data/lib/bridgetown-core/utils/aux.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Utils
+    module Aux
+      def self.with_color(name, message)
+        return message unless !name.nil? && Bridgetown::Utils::Ansi::COLORS[name.to_sym]
+
+        Bridgetown::Utils::Ansi.send(name, message)
+      end
+
+      def self.running_pids
+        @running_pids ||= []
+      end
+
+      def self.add_pid(pid)
+        running_pids << pid
+      end
+
+      def self.run_process(name, color, cmd)
+        Thread.new do
+          rd, wr = IO.pipe("BINARY")
+          pid = Process.spawn(cmd, out: wr, err: wr, pgroup: true)
+          @mutex.synchronize do
+            add_pid pid
+          end
+
+          loop do
+            line = rd.gets
+            line.to_s.lines.map(&:chomp).each do |message|
+              output = +""
+              output << with_color(color, "[#{name}] ") if color
+              output << message
+              @mutex.synchronize do
+                $stdout.puts output
+                $stdout.flush
+              end
+            end
+          end
+        end
+      end
+
+      def self.group(&block)
+        @mutex = Thread::Mutex.new
+        instance_exec(&block)
+      end
+
+      def self.kill_processes
+        Bridgetown.logger.info "Stopping auxiliary processes..."
+        running_pids.each do |pid|
+          Process.kill("SIGTERM", -Process.getpgid(pid))
+        rescue Errno::ESRCH, Errno::EPERM, Errno::ECHILD # rubocop:disable Lint/SuppressedException
+        end
+      end
+    end
+  end
+end

data/lib/bridgetown-core/utils/ruby_exec.rb

@@ -3,10 +3,7 @@
 module Bridgetown
   module Utils
     module RubyExec
-      extend self
-
-      # TODO: Deprecate storing Ruby code in YAML, Rb, etc. and just use native Ruby Front Matter
-      def search_data_for_ruby_code(convertible, renderer) # rubocop:todo Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def self.search_data_for_ruby_code(convertible)
         return if convertible.data.empty?
 
         # Iterate using `keys` here so inline Ruby script can add new data keys
@@ -14,49 +11,10 @@ module Bridgetown
         data_keys = convertible.data.keys
         data_keys.each do |k|
           v = convertible.data[k]
-          next unless v.is_a?(Rb) || v.is_a?(Hash) || v.is_a?(Proc)
-
-          if v.is_a?(Proc)
-            convertible.data[k] = convertible.instance_exec(&v)
-          elsif v.is_a?(Hash)
-            v.each do |nested_k, nested_v|
-              next unless nested_v.is_a?(Rb)
-
-              convertible.data[k][nested_k] = run(nested_v, convertible, renderer)
-            end
-          else
-            convertible.data[k] = run(v, convertible, renderer)
-          end
-        end
-      end
-
-      # Sets up a new context in which to eval Ruby coming from front matter.
-      #
-      # ruby_code - a string of code
-      # convertible - the Document/Page/Layout with the Ruby front matter
-      # renderer - the Renderer instance that's processing the document (optional)
-      #
-      # Returns the transformed output of the code
-      def run(ruby_code, convertible, renderer)
-        return unless ruby_code.is_a?(Rb)
+          next unless v.is_a?(Proc)
 
-        klass = Class.new
-        obj = klass.new
-
-        if convertible.is_a?(Layout)
-          klass.attr_accessor :layout, :site, :data
-          obj.layout = convertible
-        else
-          klass.attr_accessor :document, :page, :renderer, :site, :data
-          obj.document = obj.page = convertible
-          obj.renderer = renderer
+          convertible.data[k] = convertible.instance_exec(&v)
         end
-        obj.site = convertible.site
-        obj.data = convertible.data
-
-        # This is where the magic happens! DON'T BE EVIL!!! ;-)
-        output = obj.instance_eval(ruby_code)
-        output.is_a?(Hash) ? output.with_dot_access : output
       end
     end
   end

data/lib/bridgetown-core/utils/ruby_front_matter.rb

@@ -3,20 +3,23 @@
 module Bridgetown
   module Utils
     module RubyFrontMatterDSL
-      def front_matter(&block)
-        RubyFrontMatter.new.tap { |fm| fm.instance_exec(&block) }
+      def front_matter(scope: nil, &block)
+        RubyFrontMatter.new(scope: scope).tap { |fm| fm.instance_exec(&block) }
       end
     end
 
     class RubyFrontMatter
-      def initialize
+      def initialize(scope: nil)
         @data = {}
+        @scope = scope
       end
 
-      def method_missing(key, value) # rubocop:disable Style/MissingRespondToMissing
-        return super if respond_to?(key)
+      def method_missing(key, *value, &block) # rubocop:disable Metrics/CyclomaticComplexity, Style/MissingRespondToMissing
+        return super if respond_to?(key) || (value.length.zero? && block.nil? && !@data.key?(key))
 
-        set(key, value)
+        return get(key) if value.length.zero? && block.nil? && @data.key?(key)
+
+        set(key, value[0], &block)
       end
 
       def each(&block)
@@ -27,7 +30,19 @@ module Bridgetown
         @data[key]
       end
 
-      def set(key, value)
+      def set(key, value = nil, &block)
+        # Handle nested data within a block
+        if block
+          value = self.class.new(scope: @scope).tap do |fm|
+            fm.instance_exec(&block)
+          end.to_h
+        end
+
+        # Execute lambda value within the resolver
+        if @scope && value.is_a?(Hash) && value[:from].is_a?(Proc)
+          value = @scope.instance_exec(&value[:from])
+        end
+
         @data[key] = value
       end
 

data/lib/bridgetown-core/utils.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
 module Bridgetown
-  module Utils
+  module Utils # rubocop:todo Metrics/ModuleLength
     extend self
     autoload :Ansi, "bridgetown-core/utils/ansi"
+    autoload :Aux, "bridgetown-core/utils/aux"
     autoload :RequireGems, "bridgetown-core/utils/require_gems"
     autoload :RubyExec, "bridgetown-core/utils/ruby_exec"
+    autoload :RubyFrontMatter, "bridgetown-core/utils/ruby_front_matter"
     autoload :RubyFrontMatterDSL, "bridgetown-core/utils/ruby_front_matter"
 
     # Constants for use in #slugify
@@ -398,6 +400,39 @@ module Bridgetown
       "master"
     end
 
+    def live_reload_js(site) # rubocop:disable Metrics/MethodLength
+      return "" unless Bridgetown.env.development? && !site.config.skip_live_reload
+
+      code = <<~JAVASCRIPT
+        let first_mod = 0
+        let connection_errors = 0
+        const checkForReload = () => {
+          fetch("/_bridgetown/live_reload").then(response => {
+            if (response.ok) {
+              response.json().then(data => {
+                const last_mod = data.last_mod
+                if (first_mod === 0) {
+                  first_mod = last_mod
+                } else if (last_mod > first_mod) {
+                  location.reload()
+                }
+                setTimeout(() => checkForReload(), 700)
+              })
+            } else {
+              if (connection_errors < 20) setTimeout(() => checkForReload(), 6000)
+              connection_errors++
+            }
+          }).catch((err) => {
+            if (connection_errors < 20) setTimeout(() => checkForReload(), 6000)
+            connection_errors++
+          })
+        }
+        checkForReload()
+      JAVASCRIPT
+
+      %(<script type="module">#{code}</script>).html_safe
+    end
+
     private
 
     def merge_values(target, overwrite)
@@ -447,7 +482,7 @@ module Bridgetown
         end
 
       # Strip according to the mode
-      string.gsub(replaceable_char, "-")
+      string.to_s.gsub(replaceable_char, "-")
     end
   end
 end

data/lib/bridgetown-core/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Bridgetown
-  VERSION = "0.21.4"
-  CODE_NAME = "Broughton Beach"
+  VERSION = "1.0.0.alpha1"
+  CODE_NAME = "Pearl"
 end

data/lib/bridgetown-core/watcher.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "listen"
-
 module Bridgetown
   module Watcher
     extend self
@@ -19,9 +17,9 @@ module Bridgetown
       listener = build_listener(site, options)
       listener.start
 
-      Bridgetown.logger.info "Auto-regeneration:", "enabled."
+      Bridgetown.logger.info "Auto-regeneration:", "enabled." unless options[:using_puma]
 
-      unless options["serving"]
+      unless options[:serving]
         trap("INT") do
           listener.stop
           Bridgetown.logger.info "", "Halting auto-regeneration."

data/lib/bridgetown-core.rb

@@ -47,6 +47,7 @@ require "hash_with_dot_access"
 require "addressable/uri"
 require "liquid"
 require "liquid-component"
+require "listen"
 require "kramdown"
 require "colorator"
 require "i18n"
@@ -66,53 +67,39 @@ end
 class Rb < String; end
 
 module Bridgetown
+  autoload :Cache,               "bridgetown-core/cache"
+  autoload :Current,             "bridgetown-core/current"
   autoload :Cleaner,             "bridgetown-core/cleaner"
   autoload :Collection,          "bridgetown-core/collection"
   autoload :Component,           "bridgetown-core/component"
   autoload :Configuration,       "bridgetown-core/configuration"
-  autoload :DataAccessible,      "bridgetown-core/concerns/data_accessible"
+  autoload :DefaultsReader,      "bridgetown-core/readers/defaults_reader"
   autoload :Deprecator,          "bridgetown-core/deprecator"
-  autoload :Document,            "bridgetown-core/document"
   autoload :EntryFilter,         "bridgetown-core/entry_filter"
   # TODO: we have too many errors! This is silly
   autoload :Errors,              "bridgetown-core/errors"
-  autoload :Excerpt,             "bridgetown-core/excerpt"
   autoload :FrontmatterDefaults, "bridgetown-core/frontmatter_defaults"
   autoload :FrontMatterImporter, "bridgetown-core/concerns/front_matter_importer"
+  autoload :GeneratedPage,       "bridgetown-core/generated_page"
   autoload :Hooks,               "bridgetown-core/hooks"
   autoload :Layout,              "bridgetown-core/layout"
   autoload :LayoutPlaceable,     "bridgetown-core/concerns/layout_placeable"
-  autoload :Cache,               "bridgetown-core/cache"
-  autoload :Current,             "bridgetown-core/current"
-  # TODO: remove this when legacy content engine is gone:
-  autoload :DataReader,          "bridgetown-core/readers/data_reader"
-  autoload :DefaultsReader,      "bridgetown-core/readers/defaults_reader"
   autoload :LayoutReader,        "bridgetown-core/readers/layout_reader"
-  # TODO: remove this when legacy content engine is gone:
-  autoload :PostReader,          "bridgetown-core/readers/post_reader"
-  # TODO: remove this when legacy content engine is gone:
-  autoload :PageReader,          "bridgetown-core/readers/page_reader"
-  autoload :PluginContentReader, "bridgetown-core/readers/plugin_content_reader"
+  autoload :LiquidRenderable,    "bridgetown-core/concerns/liquid_renderable"
+  autoload :LiquidRenderer,      "bridgetown-core/liquid_renderer"
   autoload :LogAdapter,          "bridgetown-core/log_adapter"
-  autoload :Page,                "bridgetown-core/page"
-  autoload :GeneratedPage,       "bridgetown-core/page"
+  autoload :PluginContentReader, "bridgetown-core/readers/plugin_content_reader"
   autoload :PluginManager,       "bridgetown-core/plugin_manager"
   autoload :Publishable,         "bridgetown-core/concerns/publishable"
   autoload :Publisher,           "bridgetown-core/publisher"
   autoload :Reader,              "bridgetown-core/reader"
-  # TODO: remove this when the incremental regenerator is gone:
-  autoload :Regenerator,         "bridgetown-core/regenerator"
-  autoload :RelatedPosts,        "bridgetown-core/related_posts"
   autoload :Renderer,            "bridgetown-core/renderer"
-  autoload :LiquidRenderable,    "bridgetown-core/concerns/liquid_renderable"
-  autoload :LiquidRenderer,      "bridgetown-core/liquid_renderer"
   autoload :RubyTemplateView,    "bridgetown-core/ruby_template_view"
   autoload :LogWriter,           "bridgetown-core/log_writer"
   autoload :Site,                "bridgetown-core/site"
   autoload :StaticFile,          "bridgetown-core/static_file"
   autoload :URL,                 "bridgetown-core/url"
   autoload :Utils,               "bridgetown-core/utils"
-  autoload :Validatable,         "bridgetown-core/concerns/validatable"
   autoload :VERSION,             "bridgetown-core/version"
   autoload :Watcher,             "bridgetown-core/watcher"
   autoload :YAMLParser,          "bridgetown-core/yaml_parser"
@@ -126,7 +113,6 @@ module Bridgetown
   require "bridgetown-core/filters"
 
   require "bridgetown-core/drops/drop"
-  require "bridgetown-core/drops/document_drop"
   require "bridgetown-core/drops/resource_drop"
   require_all "bridgetown-core/converters"
   require_all "bridgetown-core/converters/markdown"
@@ -173,6 +159,12 @@ module Bridgetown
       Bridgetown::Commands::Registrations.register(&block)
     end
 
+    def load_tasks
+      require "bridgetown-core/commands/base"
+      Bridgetown::PluginManager.require_from_bundler
+      load File.expand_path("bridgetown-core/tasks/bridgetown_tasks.rake", __dir__)
+    end
+
     # Determines the correct Bundler environment block method to use and passes
     # the block on to it.
     #

data/lib/site_template/Gemfile.erb

@@ -3,9 +3,9 @@ git_source(:github) { |repo| "https://github.com/#{repo}.git" }
 
 # Hello! This is where you manage which Bridgetown version is used to run.
 # When you want to use a different version, change it below, save the
-# file and run `bundle install`. Run Bridgetown with `bundle exec`, like so:
+# file and run `bundle install`. Run Bridgetown like so:
 #
-#   bundle exec bridgetown serve
+#   bin/bridgetown start (or console, etc.)
 #
 # This will help ensure the proper Bridgetown version is running.
 #
@@ -17,3 +17,7 @@ git_source(:github) { |repo| "https://github.com/#{repo}.git" }
 # Happy Bridgetowning!
 
 gem "bridgetown", "~> <%= Bridgetown::VERSION %>"
+
+# Puma is a Rack-compatible server
+# (you can optionally limit this to the "development" group)
+gem "puma", "~> 5.2"

data/lib/site_template/README.md

@@ -18,9 +18,9 @@ Welcome to your new Bridgetown website! You can update this README file to provi
 - [Ruby](https://www.ruby-lang.org/en/downloads/)
   - `>= 2.5`
 - [Bridgetown Gem](https://rubygems.org/gems/bridgetown)
-  - `gem install bundler bridgetown -N`
+  - `gem install bridgetown -N`
 - [Node](https://nodejs.org)
-  - `>= 10.13`
+  - `>= 12`
 - [Yarn](https://yarnpkg.com)
 
 ## Install
@@ -33,7 +33,7 @@ bundle install && yarn install
 
 ## Development
 
-To start your site in development mode, run `yarn start` and navigate to [localhost:4000](https://localhost:4000/)!
+To start your site in development mode, run `bin/bridgetown start` and navigate to [localhost:4000](https://localhost:4000/)!
 
 Use a [theme](https://github.com/topics/bridgetown-theme), add some [plugins](https://www.bridgetownrb.com/plugins/), and/or run some [automations](https://github.com/topics/bridgetown-automation) to get started quickly.
 
@@ -41,13 +41,13 @@ Use a [theme](https://github.com/topics/bridgetown-theme), add some [plugins](ht
 
 ```sh
 # running locally
-yarn start
+bin/bridgetown start
 
 # build & deploy to production
-yarn deploy
+bin/bridgetown deploy
 
 # load the site up within a Ruby console (IRB)
-bundle exec bridgetown console
+bin/bridgetown console
 ```
 
 > Learn more: [Bridgetown CLI Documentation](https://www.bridgetownrb.com/docs/command-line-usage)

data/lib/site_template/Rakefile

@@ -0,0 +1,49 @@
+require "bridgetown"
+
+Bridgetown.load_tasks
+
+#
+# Standard set of tasks, which you can customize if you wish:
+#
+desc "Build the Bridgetown site for deployment"
+task :deploy => [:clean, "frontend:build"] do
+  Bridgetown::Commands::Build.start
+end
+
+desc "Build the site in a test environment"
+task :test do
+  ENV["BRIDGETOWN_ENV"] = "test"
+  Bridgetown::Commands::Build.start
+end
+
+desc "Runs the clean command"
+task :clean do
+  Bridgetown::Commands::Clean.start
+end
+
+namespace :frontend do
+  desc "Build the frontend with Webpack for deployment"
+  task :build do
+    sh "yarn run webpack-build"
+  end
+
+  desc "Watch the frontend with Webpack during development"
+  task :dev do
+    sh "yarn run webpack-dev --color"
+  rescue Interrupt
+  end
+end
+
+#
+# Add your own Rake tasks here! You can use `environment` as a prerequisite
+# in order to write automations or other commands requiring a loaded site.
+#
+# task :my_task => :environment do
+#   puts site.root_dir
+#   automation do
+#     say_status :rake, "I'm a Rake tast =) #{site.config.url}"
+#   end
+# end
+
+# Run rake without specifying any command to execute a deploy build by default.
+task default: :deploy

data/lib/site_template/bridgetown.config.yml

@@ -4,11 +4,10 @@
 # which you are expected to set up once and rarely edit after that.
 #
 # For technical reasons, this file is *NOT* reloaded automatically when you use
-# 'bundle exec bridgetown serve'. If you change this file, please restart the
-# server process.
+# `bin/bridgetown start`. If you change this file, please restart the server process.
 #
 # For reloadable site metadata like title, SEO description, social media
-# handles, etc., take a look at src/_data/site_metadata.yml
+# handles, etc., take a look at `src/_data/site_metadata.yml`
 #
 # If you need help with YAML syntax, here are some quick references for you:
 # https://learn-the-web.algonquindesign.ca/topics/markdown-yaml-cheat-sheet/#yaml

data/lib/site_template/config/puma.rb

@@ -0,0 +1,27 @@
+# Puma is a fast, concurrent web server for Ruby & Rack
+#
+# Learn more at: https://puma.io
+#
+port ENV.fetch("BRIDGETOWN_PORT") { 4000 }
+
+# You can adjust the number of workers (separate processes) and threads
+# (per process) based on your production system
+#
+if ENV["BRIDGETOWN_ENV"] == "production"
+  workers ENV.fetch("BRIDGETOWN_CONCURRENCY") { 4 }
+end
+
+max_threads_count = ENV.fetch("BRIDGETOWN_MAX_THREADS") { 5 }
+min_threads_count = ENV.fetch("BRIDGETOWN_MIN_THREADS") { max_threads_count }
+threads min_threads_count, max_threads_count
+
+# Preload the application for maximum performance
+#
+preload_app!
+
+# Use the Bridgetown logger format
+#
+require "bridgetown-core/rack/logger"
+log_formatter do |msg|
+  Bridgetown::Rack::Logger.message_with_prefix msg
+end

data/lib/site_template/config.ru

@@ -0,0 +1,7 @@
+# This file is used by Rack-based servers during the Bridgetown boot process.
+
+require "bridgetown-core/rack/boot"
+
+Bridgetown::Rack.boot
+
+run RodaApp.freeze.app # see server/roda_app.rb

data/lib/site_template/package.json.erb

@@ -3,18 +3,10 @@
   "version": "1.0.0",
   "private": true,
   "scripts": {
-    "build": "bundle exec bridgetown build",
-    "serve": "bundle exec bridgetown serve",
-    "clean": "bundle exec bridgetown clean",
     "webpack-build": "webpack --mode production",
-    "webpack-dev": "webpack --mode development -w",
-    "deploy": "yarn clean && yarn webpack-build && yarn build",
-    "sync": "node sync.js",
-    "start": "node start.js"
+    "webpack-dev": "webpack --mode development -w"
   },
   "devDependencies": {
-    "browser-sync": "^2.26.7",
-    "concurrently": "^5.2.0",
     "css-loader": "^4.3.0",
     "esbuild": "^0.12.7",
     "esbuild-loader": "^2.13.1",

data/lib/site_template/server/roda_app.rb

@@ -0,0 +1,22 @@
+# Roda is a simple Rack-based framework with a flexible architecture based
+# on the concept of a routing tree. Bridgetown uses it for its development
+# server, but you can also run it in production for fast, dynamic applications.
+#
+# Learn more at: http://roda.jeremyevans.net
+
+# Uncomment to use the file-based routing for Bridgetown SSR:
+# require "bridgetown-routes"
+
+class RodaApp < Bridgetown::Rack::Roda
+  # Add additional Roda configuration here if needed
+
+  # Uncomment to use Bridgetown SSR:
+  # plugin :bridgetown_ssr
+  # plugin :bridgetown_routes
+
+  route do |r|
+    # Load all files in server/routes and src/_routes if "bridgetown-routes" is loaded
+    # (see server/routes/hello.rb.sample)
+    Bridgetown::Rack::Routes.start! self
+  end
+end

data/lib/site_template/server/routes/hello.rb.sample

@@ -0,0 +1,10 @@
+# Rename this file to hello.rb to try out
+
+class Routes::Hello < Bridgetown::Rack::Routes
+  route do |r|
+    # route: GET /hello/:name
+    r.get "hello", String do |name|
+      { hello: "friend #{name}" }
+    end
+  end
+end

data/lib/site_template/src/_components/head.liquid

@@ -1,9 +1,10 @@
 <meta charset="utf-8" />
 <meta name="viewport" content="width=device-width, initial-scale=1.0" />
 {% capture page_title %}{{ title | strip_html | strip_newlines }}{% endcapture %}
-<title>{% if page_title != "" %}{{ page_title | escape }} | {{ metadata.title | escape }}{% else %}{{ metadata.title | escape }}: {{ metadata.tagline | escape }}{% endif %}</title>
+<title>{% if page_title != "Index" %}{{ page_title | escape }} | {{ metadata.title | escape }}{% else %}{{ metadata.title | escape }}: {{ metadata.tagline | escape }}{% endif %}</title>
 
 <meta name="description" content="{{ metadata.description }}" />
 
 <link rel="stylesheet" href="{% webpack_path css %}" />
 <script src="{% webpack_path js %}" defer></script>
+{% live_reload_dev_js %}

data/lib/site_template/src/about.md

@@ -1,7 +1,6 @@
 ---
 layout: page
 title: About
-permalink: /about/
 ---
 
 This is the basic Bridgetown site template. You can find out more info about customizing your Bridgetown site, as well as basic Bridgetown usage documentation at [bridgetownrb.com](https://bridgetownrb.com/)

data/lib/site_template/src/posts.md

@@ -1,13 +1,12 @@
 ---
 layout: page
 title: Posts
-permalink: /posts/
 ---
 
 <ul>
-  {% for post in site.posts %}
+  {% for post in collections.posts.resources %}
     <li>
-      <a href="{{ post.url }}">{{ post.title }}</a>
+      <a href="{{ post.relative_url }}">{{ post.title }}</a>
     </li>
   {% endfor %}
 </ul>