bridgetown-core 0.20.0 → 0.21.0

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Commands
+    class Webpack < Thor::Group
+      include Thor::Actions
+      extend Summarizable
+
+      Registrations.register do
+        register(Webpack, "webpack", "webpack ACTION", Webpack.summary)
+      end
+
+      def self.banner
+        "bridgetown webpack ACTION"
+      end
+      summary "Perform actions on the bridgetown webpack configuration"
+
+      def self.exit_on_failure?
+        true
+      end
+
+      def webpack
+        @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("./webpack", __dir__)
+      end
+
+      def self.destination_root
+        config.root_dir
+      end
+
+      def config
+        @config ||= Bridgetown.configuration({ root_dir: Dir.pwd })
+      end
+
+      protected
+
+      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 a webpack integration with Bridgetown in your project",
+          update: "Updates the Bridgetown webpack defaults to the latest available version",
+          "enable-postcss": "Configures PostCSS in your project",
+        }.with_indifferent_access
+      end
+    end
+  end
+end

data/lib/bridgetown-core/commands/webpack/enable-postcss.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+default_postcss_config = File.expand_path("../../../site_template/postcss.config.js.erb", __dir__)
+
+template default_postcss_config, "postcss.config.js"
+template "webpack.defaults.js.erb", "config/webpack.defaults.js", force: true
+
+unless Bridgetown.environment.test?
+  packages = %w(postcss@8.3.0 postcss-loader@4.3.0 postcss-flexbugs-fixes postcss-preset-env)
+  run "yarn add -D #{packages.join(" ")}"
+  run "yarn remove sass sass-loader"
+end

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

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

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

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+template "webpack.defaults.js.erb", "config/webpack.defaults.js", force: true

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

@@ -0,0 +1,18 @@
+const config = require("./config/webpack.defaults.js")
+
+// Add any overrides to the default webpack config here:
+
+// Eg:
+//
+//  ```
+//    const path = require("path")
+//    config.resolve.modules.push(path.resolve(__dirname, 'frontend', 'components'))
+//    config.resolve.alias.frontendComponents = path.resolve(__dirname, 'frontend', 'components')
+//  ```
+
+
+
+
+////////////////////////////////////////////////////////
+
+module.exports = config

data/lib/{site_template/webpack.config.js.erb → bridgetown-core/commands/webpack/webpack.defaults.js.erb}

@@ -1,10 +1,21 @@
+// This file is created and managed by Bridgetown.
+// Instead of editing this file, add your overrides to `webpack.config.js`
+//
+// To update this file to the latest version provided by Bridgetown,
+// run `bridgetown webpack update`. Any changes to this file will be overwritten
+// when an update is applied hence we strongly recommend adding overrides to
+// `webpack.config.js` instead of editing this file.
+//
+// Shipped with Bridgetown v<%= Bridgetown::VERSION %>
+
 const path = require("path");
+const rootDir = path.resolve(__dirname, "..")
 const MiniCssExtractPlugin = require("mini-css-extract-plugin");
 const ManifestPlugin = require("webpack-manifest-plugin");
 
 module.exports = {
   entry: {
-    main: "./frontend/javascript/index.js"
+    main: path.resolve(rootDir, "frontend", "javascript", "index.js")
   },
   devtool: "source-map",
   // Set some or all of these to true if you want more verbose logging:
@@ -15,18 +26,18 @@ module.exports = {
     children: false,
   },
   output: {
-    path: path.resolve(__dirname, "output", "_bridgetown", "static", "js"),
+    path: path.resolve(rootDir, "output", "_bridgetown", "static", "js"),
     filename: "[name].[contenthash].js",
   },
   resolve: {
     extensions: [".js", ".jsx"],
     modules: [
-      path.resolve(__dirname, 'frontend', 'javascript'),
-      path.resolve(__dirname, 'frontend', 'styles'),
-      path.resolve('./node_modules')
+      path.resolve(rootDir, 'frontend', 'javascript'),
+      path.resolve(rootDir, 'frontend', 'styles'),
+      path.resolve(rootDir, 'node_modules')
     ],
     alias: {
-      bridgetownComponents: path.resolve(__dirname, "src", "_components")
+      bridgetownComponents: path.resolve(rootDir, "src", "_components")
     }
   },
   plugins: [
@@ -34,7 +45,7 @@ module.exports = {
       filename: "../css/[name].[contenthash].css",
     }),
     new ManifestPlugin({
-      fileName: path.resolve(__dirname, ".bridgetown-webpack", "manifest.json"),
+      fileName: path.resolve(rootDir, ".bridgetown-webpack", "manifest.json"),
     }),
   ],
   module: {
@@ -54,11 +65,12 @@ module.exports = {
                   helpers: false,
                 },
               ],
+              ["@babel/plugin-proposal-private-methods", { "loose": true }],
             ],
           },
         },
       },
-      <% if options["use-postcss"] %>
+      <% if self.config.uses_postcss? %>
       {
         test: /\.(s[ac]|c)ss$/,
         use: [
@@ -72,7 +84,7 @@ module.exports = {
           },
           "postcss-loader"
         ],
-      },      
+      },
       <% else %>
       {
         test: /\.(s[ac]|c)ss$/,
@@ -87,9 +99,11 @@ module.exports = {
           {
             loader: "sass-loader",
             options: {
+              implementation: require("sass"),
               sassOptions: {
+                fiber: false,
                 includePaths: [
-                  path.resolve(__dirname, "src/_components")
+                  path.resolve(rootDir, "src/_components")
                 ],
               },
             },
@@ -117,4 +131,4 @@ module.exports = {
       },
     ],
   },
-};
+};

data/lib/bridgetown-core/component.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  class Component
+    extend Forwardable
+
+    def_delegators :@view_context, :helpers, :liquid_render, :partial
+
+    # @return [Bridgetown::Site]
+    attr_reader :site # will be nil unless you explicitly set a `@site` ivar
+
+    # @return [Bridgetown::RubyTemplateView, Bridgetown::Component]
+    attr_reader :view_context
+
+    class << self
+      attr_accessor :source_location
+
+      def inherited(child)
+        # Code cribbed from ViewComponent by GitHub:
+        # Derive the source location of the component Ruby file from the call stack
+        child.source_location = caller_locations(1, 10).reject do |l|
+          l.label == "inherited"
+        end[0].absolute_path
+
+        super
+      end
+
+      # Return the appropriate template renderer for a given extension.
+      # TODO: make this extensible
+      #
+      # @param ext [String] erb, slim, etc.
+      def renderer_for_ext(ext, &block)
+        @_tmpl ||= case ext
+                   when "erb"
+                     include ERBCapture
+                     Tilt::ErubiTemplate.new(component_template_path,
+                                             outvar: "@_erbout",
+                                             bufval: "Bridgetown::OutputBuffer.new",
+                                             engine_class: Bridgetown::ERBEngine,
+                                             &block)
+                   when "serb" # requires serbea
+                     include Serbea::Helpers
+                     Tilt::SerbeaTemplate.new(component_template_path, &block)
+                   when "slim" # requires bridgetown-slim
+                     Slim::Template.new(component_template_path, &block)
+                   when "haml" # requires bridgetown-haml
+                     Tilt::HamlTemplate.new(component_template_path, &block)
+                   else
+                     raise NameError
+                   end
+      rescue NameError, LoadError
+        raise "No component rendering engine could be found for .#{ext} templates"
+      end
+
+      # Find the first matching template path based on source location and extension.
+      #
+      # @return [String]
+      def component_template_path
+        @_tmpl_path ||= begin
+          stripped_path = File.join(
+            File.dirname(source_location),
+            File.basename(source_location, ".*")
+          )
+          supported_template_extensions.each do |ext|
+            test_path = "#{stripped_path}.#{ext}"
+            break test_path if File.exist?(test_path)
+
+            test_path = "#{stripped_path}.html.#{ext}"
+            break test_path if File.exist?(test_path)
+          end
+        end
+
+        unless @_tmpl_path.is_a?(String)
+          raise "#{name}: no matching template could be found in #{File.dirname(source_location)}"
+        end
+
+        @_tmpl_path
+      end
+
+      # Read the template file.
+      #
+      # @return [String]
+      def component_template_content
+        @_tmpl_content ||= File.read(component_template_path)
+      end
+
+      # A list of extensions supported by the renderer
+      # TODO: make this extensible
+      #
+      # @return [Array<String>]
+      def supported_template_extensions
+        %w(erb serb slim haml)
+      end
+    end
+
+    # If a content block was originally passed into via `render`, capture its output.
+    #
+    # @return [String] or nil
+    def content
+      @_content ||= begin
+        view_context.capture(self, &@_content_block) if @_content_block
+      end
+    end
+
+    # Provide a render helper for evaluation within the component context.
+    #
+    # @param item [Object] a component supporting `render_in` or a partial name
+    # @param options [Hash] passed to the `partial` helper if needed
+    # @return [String]
+    def render(item, options = {}, &block)
+      if item.respond_to?(:render_in)
+        result = ""
+        capture do # this ensures no leaky interactions between BT<=>VC blocks
+          result = item.render_in(self, &block)
+        end
+        result&.html_safe
+      else
+        partial(item, options, &block)&.html_safe
+      end
+    end
+
+    # This is where the magic happens. Render the component within a view context.
+    #
+    # @param view_context [Bridgetown::RubyTemplateView]
+    def render_in(view_context, &block)
+      @view_context = view_context
+      @_content_block = block
+
+      if render?
+        before_render
+        template
+      else
+        ""
+      end
+    rescue StandardError => e
+      Bridgetown.logger.error "Component error:",
+                              "#{self.class} encountered an error while "\
+                              "rendering `#{self.class.component_template_path}'"
+      raise e
+    end
+
+    # Subclasses can override this method to return a string from their own
+    # template handling.
+    def template
+      call || _renderer.render(self)
+    end
+
+    # Typically not used but here as a compatibility nod toward ViewComponent.
+    def call
+      nil
+    end
+
+    # Subclasses can override this method to perform tasks before a render.
+    def before_render; end
+
+    # Subclasses can override this method to determine if the component should
+    # be rendered based on initialized data or other logic.
+    def render?
+      true
+    end
+
+    def _renderer
+      @_renderer ||= begin
+        ext = File.extname(self.class.component_template_path).delete_prefix(".")
+        self.class.renderer_for_ext(ext) { self.class.component_template_content }
+      end
+    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
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      helpers.respond_to?(method.to_sym, include_private) || super
+    end
+    # rubocop:enable Style/MissingRespondToMissing
+  end
+end

data/lib/bridgetown-core/concerns/front_matter_importer.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module FrontMatterImporter
+    # Requires klass#content and klass#front_matter_line_count accessors
+    def self.included(klass)
+      klass.include Bridgetown::Utils::RubyFrontMatterDSL
+    end
+
+    YAML_HEADER = %r!\A---\s*\n!.freeze
+    YAML_BLOCK = %r!\A(---\s*\n.*?\n?)^((---|\.\.\.)\s*$\n?)!m.freeze
+    RUBY_HEADER = %r!\A[~`#\-]{3,}(?:ruby|<%|{%)\s*\n!.freeze
+    RUBY_BLOCK =
+      %r!#{RUBY_HEADER.source}(.*?\n?)^((?:%>|%})?[~`#\-]{3,}\s*$\n?)!m.freeze
+
+    def read_front_matter(file_path) # rubocop:todo Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength
+      file_contents = File.read(
+        file_path, **Bridgetown::Utils.merged_file_read_opts(Bridgetown::Current.site, {})
+      )
+      yaml_content = file_contents.match(YAML_BLOCK)
+      if !yaml_content && Bridgetown::Current.site.config.should_execute_inline_ruby?
+        ruby_content = file_contents.match(RUBY_BLOCK)
+      end
+
+      if yaml_content
+        self.content = yaml_content.post_match
+        self.front_matter_line_count = yaml_content[1].lines.size - 1
+        YAMLParser.load(yaml_content[1])
+      elsif ruby_content
+        # rbfm header + content underneath
+        self.content = ruby_content.post_match
+        self.front_matter_line_count = ruby_content[1].lines.size
+        process_ruby_data(ruby_content[1], file_path, 2)
+      elsif Bridgetown::Utils.has_rbfm_header?(file_path)
+        process_ruby_data(File.read(file_path).lines[1..-1].join("\n"), file_path, 2)
+      elsif is_a?(Layout)
+        self.content = file_contents
+        {}
+      else
+        yaml_data = YAMLParser.load_file(file_path)
+        yaml_data.is_a?(Array) ? { rows: yaml_data } : yaml_data
+      end
+    end
+
+    def process_ruby_data(rubycode, file_path, starting_line)
+      ruby_data = instance_eval(rubycode, file_path.to_s, starting_line)
+      ruby_data.is_a?(Array) ? { rows: ruby_data } : ruby_data.to_h
+    rescue StandardError => e
+      raise "Ruby code isn't returning an array, or object which responds to `to_h' (#{e.message})"
+    end
+  end
+end