bridgetown-core 1.0.0.alpha11 → 1.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '09c13a3ec4bb37595ede90e5536eca3159812d06c482397d971d1130eab3ceab'
-  data.tar.gz: 48cd4b6488ba57a185e510f00e6986b8514ad33887b7710431c40d9efcae4f45
+  metadata.gz: b6953f85017e90090c0078b710b3e447b69366bd9fed38bd5e307ee72ae3181c
+  data.tar.gz: 863dcdcea016110ae4e05922f7357b866bd2a77998b5da78ffb92819238c59c4
 SHA512:
-  metadata.gz: '008f32b43e009a8349bc69fe01277c9a7ebdef2c7062d8c0dc331826d0eac394491a75b48892629d5a835eeef12e435c573d4c811ec33441555ec820870157d6'
-  data.tar.gz: b6cf7933d50093c1332b1b39f5764768a3d8cdc3ff91b115e3d31790afa350826815f30e7d3e8c3891ddffea236f40b8e5b52268ec8eb019b4e20f319f1171ef
+  metadata.gz: eb6a1aa56f1544fcc37c4e204df417b5d7d37fa0e219e6a484872cdf4defee1c165fda09f4f30486d64635ef9ab6cf6db3edc8c63316dd3e61ab37be1394443c
+  data.tar.gz: 81b03e750b6fe6b25c1fbb2e62350f2c2776bf4902c236c5299f90c653720037e74ae8500bf71d928825efd3d83c651ad1d80523cb1362a1db2100d8f88daef9

data/.rubocop.yml

@@ -12,6 +12,7 @@ AllCops:
     - tmp/**/*
     - test/source/**/*
     - test/resources/src/_pages/*.rb
+    - lib/site_template/TEMPLATES/**/*
     - lib/site_template/Rakefile
     - lib/site_template/config.ru
     - lib/site_template/config/**/*

data/bin/bridgetown

@@ -34,4 +34,9 @@ end
 ENV["RACK_ENV"] = ENV["BRIDGETOWN_ENV"]
 
 require "bridgetown-core/commands/base"
-Bridgetown::Commands::Base.start unless output_version
+begin
+  Bridgetown::Commands::Base.start unless output_version
+rescue StandardError => e
+  Bridgetown::Errors.print_build_error(e)
+  exit(false)
+end

data/bridgetown-core.gemspec

@@ -30,15 +30,15 @@ Gem::Specification.new do |s|
 
   s.required_ruby_version     = ">= 2.7.0"
 
-  s.add_runtime_dependency("activemodel",           "~> 6.0")
-  s.add_runtime_dependency("activesupport",         "~> 6.0")
+  s.add_runtime_dependency("activemodel",           [">= 6.0", "< 8.0"])
+  s.add_runtime_dependency("activesupport",         [">= 6.0", "< 8.0"])
   s.add_runtime_dependency("addressable",           "~> 2.4")
   s.add_runtime_dependency("amazing_print",         "~> 1.2")
   s.add_runtime_dependency("colorator",             "~> 1.0")
   s.add_runtime_dependency("erubi",                 "~> 1.9")
   s.add_runtime_dependency("faraday",               "~> 1.0")
   s.add_runtime_dependency("faraday_middleware",    "~> 1.0")
-  s.add_runtime_dependency("hash_with_dot_access",  "~> 1.0")
+  s.add_runtime_dependency("hash_with_dot_access",  "~> 1.2")
   s.add_runtime_dependency("i18n",                  "~> 1.0")
   s.add_runtime_dependency("kramdown",              "~> 2.1")
   s.add_runtime_dependency("kramdown-parser-gfm",   "~> 1.0")

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

@@ -34,41 +34,42 @@ module Bridgetown
           rake.display_tasks_and_comments
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Style/GlobalVars
+        def load_rake_tasks(rake)
+          rake.load_rakefile
+          tasks = rake.instance_variable_get(:@tasks)
+          rake.instance_variable_set(:@tasks, tasks.reject do |_k, v|
+            v.locations.first&.include?("/lib/rails/tasks/") ||
+              v.locations.first&.include?("/lib/rake/dsl_definition")
+          end)
+        end
+
+        # rubocop:disable Style/GlobalVars
         def handle_no_command_error(cmd, _has_namespace = $thor_runner)
           require "rake"
           Rake::TaskManager.record_task_metadata = true
 
           Rake.with_application do |rake|
-            rake.instance_variable_set(:@name, "bridgetown")
             rake.standard_exception_handling do
               rakefile, _location = rake.find_rakefile_location
               unless rakefile
-                puts "No Rakefile found (searching: #{rake.class::DEFAULT_RAKEFILES.join(", ")})\n"
+                puts "No Rakefile found (searching: #{rake.class::DEFAULT_RAKEFILES.join(", ")})\n\n" # rubocop:disable Layout/LineLength
                 new.invoke("help")
                 return # rubocop:disable Lint/NonLocalExitFromIterator
               end
-              rake.load_rakefile
-              rake.top_level
-            end
-            cmd = cmd.split("[")
-            args = []
-            if cmd[1]
-              args = cmd[1].gsub("\\,", "__COMMA__").delete_suffix!("]").split(",").map do |item|
-                item.gsub("__COMMA__", ",")
-              end
+              rake.init("bridgetown")
+              load_rake_tasks(rake)
             end
 
-            if Rake::Task.task_defined?(cmd[0])
-              Rake::Task[cmd[0]].invoke(*args)
+            if Rake::Task.task_defined?(cmd.split("[")[0])
+              rake.top_level
             else
-              puts "Unknown task: #{cmd[0]}\n\nHere's a list of tasks you can run:"
+              puts "Unknown task: #{cmd.split("[")[0]}\n\nHere's a list of tasks you can run:"
               display_rake_tasks(rake)
             end
           end
         end
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Style/GlobalVars
+      # rubocop:enable Style/GlobalVars
 
       desc "dream", "There's a place where that idea still exists as a reality"
       def dream
@@ -101,8 +102,7 @@ module Bridgetown
               rakefile, _location = rake.find_rakefile_location
               return unless rakefile # rubocop:disable Lint/NonLocalExitFromIterator
 
-              rake.load_rakefile
-              rake.top_level
+              self.class.load_rake_tasks(rake)
               puts "Available Rake Tasks:"
               self.class.display_rake_tasks(rake)
             end

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

@@ -77,7 +77,7 @@ module Bridgetown
         end
         Bridgetown.logger.info "Generating…"
         @site.process
-        Bridgetown.logger.info "Done! 🎉", "#{"Completed".green} in less than" \
+        Bridgetown.logger.info "Done! 🎉", "#{"Completed".bold.green} in less than" \
                                           " #{(Time.now - t).ceil(2)} seconds."
 
         return unless config_options[:using_puma]

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

@@ -21,12 +21,12 @@ module Bridgetown
         destination = config["destination"]
         metadata_file = File.join(config["root_dir"], ".bridgetown-metadata")
         cache_dir = File.join(config["root_dir"], config["cache_dir"])
-        webpack_dir = File.join(config["root_dir"], ".bridgetown-webpack")
+        bundling_dir = File.join(config["root_dir"], ".bridgetown-cache", "frontend-bundling")
 
         remove(destination, checker_func: :directory?)
         remove(metadata_file, checker_func: :file?)
         remove(cache_dir, checker_func: :directory?)
-        remove(webpack_dir, checker_func: :directory?)
+        remove(bundling_dir, checker_func: :directory?)
       end
 
       protected

data/lib/bridgetown-core/commands/esbuild/esbuild.config.js

@@ -0,0 +1,27 @@
+const build = require("./config/esbuild.defaults.js")
+
+// Update this if you need to configure a destination folder other than `output`
+const outputFolder = "output"
+
+// You can customize this as you wish, perhaps to add new esbuild plugins.
+//
+// Eg:
+//
+//  ```
+//  const path = require("path")
+//  const esbuildCopy = require('esbuild-plugin-copy').default
+//  const esbuildOptions = {
+//    plugins: [
+//      esbuildCopy({
+//        assets: {
+//          from: [path.resolve(__dirname, 'node_modules/somepackage/files/*')],
+//          to: [path.resolve(__dirname, 'output/_bridgetown/somepackage/files')],
+//        },
+//        verbose: false
+//      }),
+//    ]
+//  }
+//  ```
+const esbuildOptions = {}
+
+build(outputFolder, esbuildOptions)

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

@@ -0,0 +1,216 @@
+// This file is created and managed by Bridgetown.
+// Instead of editing this file, add your overrides to `esbuild.config.js`
+//
+// To update this file to the latest version provided by Bridgetown,
+// run `bridgetown esbuild update`. Any changes to this file will be overwritten
+// when an update is applied hence we strongly recommend adding overrides to
+// `esbuild.config.js` instead of editing this file.
+//
+// Shipped with Bridgetown v<%= Bridgetown::VERSION %>
+
+const path = require("path")
+const fsLib = require("fs")
+const fs = fsLib.promises
+const glob = require("glob")
+const postcss = require("postcss")
+const postCssImport = require("postcss-import")
+const readCache = require("read-cache")
+
+// Glob plugin derived from:
+// https://github.com/thomaschaaf/esbuild-plugin-import-glob
+// https://github.com/xiaohui-zhangxh/jsbundling-rails/commit/b15025dcc20f664b2b0eb238915991afdbc7cb58
+const importGlobPlugin = () => ({
+  name: "import-glob",
+  setup: (build) => {
+    build.onResolve({ filter: /\*/ }, async (args) => {
+      if (args.resolveDir === "") {
+        return; // Ignore unresolvable paths
+      }
+
+      const adjustedPath = args.path.replace(/^bridgetownComponents\//, "../../src/_components/")
+
+      return {
+        path: adjustedPath,
+        namespace: "import-glob",
+        pluginData: {
+          path: adjustedPath,
+          resolveDir: args.resolveDir,
+        },
+      }
+    })
+
+    build.onLoad({ filter: /.*/, namespace: "import-glob" }, async (args) => {
+      const files = glob.sync(args.pluginData.path, {
+        cwd: args.pluginData.resolveDir,
+      }).sort()
+
+      const importerCode = `
+        ${files
+          .map((module, index) => `import * as module${index} from '${module}'`)
+          .join(';')}
+        const modules = {${files
+          .map((module, index) => `
+            "${module.replace("../../src/_components/", "")}": module${index},`)
+          .join("")}
+        };
+        export default modules;
+      `
+
+      return { contents: importerCode, resolveDir: args.pluginData.resolveDir }
+    })
+  },
+})
+
+const postCssPlugin = (options) => ({
+  name: "postcss",
+  async setup(build) {
+    // Process .css files with PostCSS
+    build.onLoad({ filter: /\.(css)$/ }, async (args) => {
+      const additionalFilePaths = []
+      const css = await fs.readFile(args.path, "utf8")
+
+      // Configure import plugin so PostCSS can properly resolve `@import`ed CSS files
+      const importPlugin = postCssImport({
+        filter: itemPath => {
+          // We'll want to track any imports later when in watch mode
+          additionalFilePaths.push(path.resolve(path.dirname(args.path), itemPath))
+          return true
+        },
+        load: async filename => {
+          let contents = await readCache(filename, "utf-8")
+          const filedir = path.dirname(filename)
+
+          // We need to transform `url(...)` in imported CSS so the filepaths are properly
+          // relative to the entrypoint. Seems icky to have to hack this! C'est la vie...
+          contents = contents.replace(/url\(['"]?\.\/(.*?)['"]?\)/g, (_match, p1) => {
+            const relpath = path.relative(args.path, path.resolve(filedir, p1)).replace(/^\.\.\//, "")
+            return `url("${relpath}")`
+          })
+          return contents
+        }
+      })
+
+      // Process the file through PostCSS
+      const result = await postcss([importPlugin, ...options.plugins]).process(css, {
+        map: true,
+        ...options.options,
+        from: args.path,
+      });
+
+      return {
+        contents: result.css,
+        loader: "css",
+        watchFiles: [args.path, ...additionalFilePaths],
+      }
+    })
+  },
+})
+
+// Set up defaults and generate frontend bundling manifest file
+const bridgetownPreset = (outputFolder) => ({
+  name: "bridgetownPreset",
+  async setup(build) {
+    // Ensure any imports anywhere starting with `/` are left verbatim
+    // so they can be used in-browser for actual `src` repo files
+    build.onResolve({ filter: /^\// }, args => {
+      return { path: args.path, external: true }
+    })
+
+    build.onStart(() => {
+      console.log("esbuild: frontend bundling started...")
+    })
+
+    // Generate the final output manifest
+    build.onEnd(async (result) => {
+      if (!result.metafile) {
+        console.warn("esbuild: build process error, cannot write manifest")
+        return
+      }
+
+      const manifest = {}
+      const entrypoints = []
+
+      // We don't need `frontend/` cluttering up everything
+      const stripPrefix = (str) => str.replace(/^frontend\//, "")
+
+      // For calculating the file size of bundle output
+      const fileSize = (path) => {
+        const { size } = fsLib.statSync(path)
+        const i = Math.floor(Math.log(size) / Math.log(1024))
+        return (size / Math.pow(1024, i)).toFixed(2) * 1 + ['B', 'KB', 'MB', 'GB', 'TB'][i]
+      }
+
+      // Let's loop through all the various outputs
+      for (const key in result.metafile.outputs) {
+        const value = result.metafile.outputs[key]
+        const inputs = Object.keys(value.inputs)
+        const pathShortener = new RegExp(`^${outputFolder}\\/_bridgetown\\/static\\/`, "g")
+        const outputPath = key.replace(pathShortener, "")
+
+        if (value.entryPoint) {
+          // We have an entrypoint!
+          manifest[stripPrefix(value.entryPoint)] = outputPath
+          entrypoints.push([outputPath, fileSize(key)])
+        } else if (key.match(/index(\.js)?\.[^-.]*\.css/) && inputs.find(item => item.endsWith("index.css"))) {
+          // Special treatment for index.css
+          manifest[stripPrefix(inputs.find(item => item.endsWith("index.css")))] = outputPath
+          entrypoints.push([outputPath, fileSize(key)])
+        } else if (inputs.length > 0) {
+          // Naive implementation, we'll just grab the first input and hope it's accurate
+          manifest[stripPrefix(inputs[0])] = outputPath
+        }
+      }
+
+      const manifestFolder = path.join(process.cwd(), ".bridgetown-cache", "frontend-bundling")
+      await fs.mkdir(manifestFolder, { recursive: true })
+      await fs.writeFile(path.join(manifestFolder, "manifest.json"), JSON.stringify(manifest))
+
+      console.log("esbuild: frontend bundling complete!")
+      console.log("esbuild: entrypoints processed:")
+      entrypoints.forEach(entrypoint => {
+        const [entrypointName, entrypointSize] = entrypoint
+        console.log(`         - ${entrypointName}: ${entrypointSize}`)
+      })
+    })
+  }
+})
+
+// Load the PostCSS config from postcss.config.js or whatever else is a supported location/format
+const postcssrc = require("postcss-load-config")
+const postCssConfig = postcssrc.sync()
+
+module.exports = (outputFolder, esbuildOptions) => {
+  esbuildOptions.plugins = esbuildOptions.plugins || []
+  // Add the PostCSS & glob plugins to the top of the plugin stack
+  esbuildOptions.plugins.unshift(postCssPlugin(postCssConfig))
+  esbuildOptions.plugins.unshift(importGlobPlugin())
+  // Add the Bridgetown preset to the bottom of the plugin stack
+  esbuildOptions.plugins.push(bridgetownPreset(outputFolder))
+
+  // esbuild, take it away!
+  require("esbuild").build({
+    bundle: true,
+    loader: {
+      ".jpg": "file",
+      ".png": "file",
+      ".gif": "file",
+      ".svg": "file",
+      ".woff": "file",
+      ".woff2": "file",
+      ".ttf": "file",
+      ".eot": "file",
+    },
+    resolveExtensions: [".tsx",".ts",".jsx",".js",".css",".json",".js.rb"],
+    nodePaths: ["frontend/javascript", "frontend/styles"],
+    watch: process.argv.includes("--watch"),
+    minify: process.argv.includes("--minify"),
+    sourcemap: true,
+    target: "es2016",
+    entryPoints: ["frontend/javascript/index.js"],
+    entryNames: "[dir]/[name].[hash]",
+    outdir: path.join(process.cwd(), `${outputFolder}/_bridgetown/static`),
+    publicPath: "/_bridgetown/static",
+    metafile: true,
+    ...esbuildOptions,
+  }).catch(() => process.exit(1))
+}

data/lib/bridgetown-core/commands/esbuild/migrate-from-webpack.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# rubocop:disable Layout/LineLength
+
+if package_json["devDependencies"].key?("sass")
+  say "Unable to migrate, project uses Sass. Please migrate to PostCSS first before migrating to esbuild."
+  return
+end
+
+remove_file "webpack.config.js"
+remove_file "config/webpack.defaults.js"
+
+apply find_in_source_paths("setup.rb"), verbose: false
+
+default_postcss_config = File.expand_path("../../../site_template/postcss.config.js.erb", __dir__)
+template default_postcss_config, "postcss.config.js"
+
+unless Bridgetown.environment.test?
+  required_packages = %w(esbuild glob postcss postcss-flexbugs-fixes postcss-preset-env postcss-import postcss-load-config)
+  redundant_packages = %w(esbuild-loader webpack webpack-cli webpack-manifest-plugin webpack-merge css-loader file-loader mini-css-extract-plugin postcss-loader)
+
+  say "Installing required packages"
+
+  gsub_file "package.json", %r!    "postcss-focus-within": "^4.0.0",?!, ""
+
+  run "yarn add -D #{required_packages.join(" ")}"
+
+  packages_to_remove = package_json["devDependencies"].slice(*redundant_packages).keys
+  unless packages_to_remove.empty?
+    confirm = ask "\nThe following packages will be removed: \n\n#{packages_to_remove.join("\n")}\n\nWould you like to continue? [Yn]"
+    return unless confirm.casecmp?("Y")
+
+    run "yarn remove #{packages_to_remove.join(" ")}"
+  end
+end
+
+gsub_file "Rakefile", %(desc "Build the frontend with Webpack for deployment"), %(desc "Build the frontend with esbuild for deployment")
+gsub_file "Rakefile", %(desc "Watch the frontend with Webpack during development"), %(desc "Watch the frontend with esbuild during development")
+gsub_file "Rakefile", %(sh "yarn run webpack-build"), %(sh "yarn run esbuild")
+gsub_file "Rakefile", %(sh "yarn run webpack-dev --color"), %(sh "yarn run esbuild-dev")
+gsub_file "package.json", %("webpack-build": "webpack --mode production"), %("esbuild": "node esbuild.config.js --minify")
+gsub_file "package.json", %("webpack-dev": "webpack --mode development -w"), %("esbuild-dev": "node esbuild.config.js --watch")
+
+say "🎉 Migration steps to esbuild finished!"
+say "Make sure you replace your `webpack_path` helpers with `asset_path` helpers in your templates"
+
+# rubocop:enable Layout/LineLength

data/lib/bridgetown-core/commands/esbuild/setup.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+template "esbuild.defaults.js.erb", "config/esbuild.defaults.js"
+copy_file "esbuild.config.js", force: true

data/lib/bridgetown-core/commands/esbuild/update.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+template "esbuild.defaults.js.erb", "config/esbuild.defaults.js", force: true
+say "🎉 esbuild configuration updated successfully!"

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Commands
+    class Esbuild < Thor::Group
+      include Thor::Actions
+      extend Summarizable
+
+      Registrations.register do
+        register(Esbuild, "esbuild", "esbuild ACTION", Esbuild.summary)
+      end
+
+      def self.banner
+        "bridgetown esbuild ACTION"
+      end
+      summary "Perform actions on the Bridgetown esbuild configuration"
+
+      def self.exit_on_failure?
+        true
+      end
+
+      def esbuild
+        @logger = Bridgetown.logger
+        return show_actions if args.empty?
+
+        action = args.first
+        if supported_actions.include?(action)
+          perform action
+        else
+          @logger.error "Error:".red, "🚨 Please enter a valid action."
+          say "\n"
+          show_actions
+        end
+      end
+
+      def self.source_root
+        File.expand_path("./esbuild", __dir__)
+      end
+
+      def self.destination_root
+        config.root_dir
+      end
+
+      protected
+
+      def config
+        @config ||= Bridgetown.configuration({ root_dir: Dir.pwd })
+      end
+
+      def package_json
+        @package_json ||= begin
+          package_json_file = File.read(Bridgetown.sanitized_path(config.root_dir, "package.json"))
+          JSON.parse(package_json_file)
+        end
+      end
+
+      def perform(action)
+        automation = find_in_source_paths("#{action}.rb")
+        inside(New.created_site_dir || Dir.pwd) do
+          apply automation, verbose: false
+        end
+      end
+
+      def show_actions
+        say "Available actions:\n".bold
+
+        longest_action = supported_actions.keys.max_by(&:size).size
+        supported_actions.each do |action, description|
+          say "#{action.ljust(longest_action).to_s.bold.blue}\t# #{description}"
+        end
+      end
+
+      def supported_actions
+        {
+          setup: "Sets up an esbuild integration with Bridgetown in your project",
+          update: "Updates the Bridgetown esbuild defaults to the latest available version",
+          "migrate-from-webpack":
+            "Removes Webpack from your project and installs/configures esbuild",
+        }.with_indifferent_access
+      end
+    end
+  end
+end