bridgetown-core 0.15.0.beta1 → 0.16.0.beta1

data/lib/bridgetown-core/plugin_manager.rb

@@ -3,6 +3,7 @@
 module Bridgetown
   class PluginManager
     PLUGINS_GROUP = :bridgetown_plugins
+    YARN_DEPENDENCY_REGEXP = %r!(.+)@([^@]*)$!.freeze
 
     attr_reader :site
 
@@ -67,30 +68,43 @@ module Bridgetown
     # If that exact package hasn't been installed, execute yarn add
     #
     # Returns nothing.
-    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
     def self.install_yarn_dependencies(required_gems)
       return unless File.exist?("package.json")
 
       package_json = JSON.parse(File.read("package.json"))
 
       required_gems.each do |loaded_gem|
-        next unless loaded_gem.to_spec&.metadata&.dig("yarn-add")
-
-        yarn_add_dependency = loaded_gem.to_spec.metadata["yarn-add"].split("@")
-        next unless yarn_add_dependency.length == 2
-
-        # check matching version number is see if it's already installed
-        if package_json["dependencies"]
-          current_package = package_json["dependencies"].dig(yarn_add_dependency.first)
-          next unless current_package.nil? || current_package != yarn_add_dependency.last
-        end
+        yarn_dependency = find_yarn_dependency(loaded_gem)
+        next unless add_yarn_dependency?(yarn_dependency, package_json)
 
         # all right, time to install the package
-        cmd = "yarn add #{yarn_add_dependency.join("@")}"
+        cmd = "yarn add #{yarn_dependency.join("@")}"
         system cmd
       end
     end
-    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+
+    def self.find_yarn_dependency(loaded_gem)
+      yarn_dependency = loaded_gem.to_spec&.metadata&.dig("yarn-add")&.match(YARN_DEPENDENCY_REGEXP)
+      return nil if yarn_dependency&.length != 3 || yarn_dependency[2] == ""
+
+      yarn_dependency[1..2]
+    end
+
+    def self.add_yarn_dependency?(yarn_dependency, package_json)
+      return false if yarn_dependency.nil?
+
+      # check matching version number is see if it's already installed
+      if package_json["dependencies"]
+        current_version = package_json["dependencies"].dig(yarn_dependency.first)
+        package_requires_updating?(current_version, yarn_dependency.last)
+      else
+        true
+      end
+    end
+
+    def self.package_requires_updating?(current_version, dep_version)
+      current_version.nil? || current_version != dep_version && !current_version.include?("/")
+    end
 
     # Require all .rb files
     #

data/lib/bridgetown-core/regenerator.rb

@@ -163,7 +163,7 @@ module Bridgetown
     end
 
     def regenerate_page?(document)
-      document.asset_file? || document.data["regenerate"] ||
+      document.data["regenerate"] ||
         source_modified_or_dest_missing?(
           site.in_source_dir(document.relative_path), document.destination(@site.dest)
         )

data/lib/bridgetown-core/renderer.rb

@@ -53,18 +53,19 @@ module Bridgetown
 
     # Prepare payload and render the document
     #
-    # Returns String rendered document output
+    # Returns nothing
     def run
       Bridgetown.logger.debug "Rendering:", document.relative_path
 
       assign_pages!
+      # TODO: this can be eliminated I think:
       assign_current_document!
       assign_highlighter_options!
       assign_layout_data!
 
       document.trigger_hooks(:pre_render, payload)
-
-      render_document
+      document.output = render_document
+      document.trigger_hooks(:post_render)
     end
 
     # Render the document.
@@ -83,7 +84,7 @@ module Bridgetown
       end
 
       Bridgetown.logger.debug "Rendering Markup:", document.relative_path
-      output = convert(output.to_s)
+      output = convert(output.to_s, document)
       document.content = output
 
       if document.place_in_layout?
@@ -140,9 +141,13 @@ module Bridgetown
     # Convert the document using the converters which match this renderer's document.
     #
     # Returns String the converted content.
-    def convert(content)
+    def convert(content, document)
       converters.reduce(content) do |output, converter|
-        converter.convert output
+        if converter.method(:convert).arity == 1
+          converter.convert output
+        else
+          converter.convert output, document
+        end
       rescue StandardError => e
         Bridgetown.logger.error "Conversion error:",
                                 "#{converter.class} encountered an error while "\
@@ -202,17 +207,38 @@ module Bridgetown
     # Render layout content into document.output
     #
     # Returns String rendered content
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
     def render_layout(output, layout, liquid_context)
-      payload["content"] = output
-      payload["layout"]  = Utils.deep_merge_hashes(layout.data, payload["layout"] || {})
-
-      render_liquid(
-        layout.content,
-        payload,
-        liquid_context,
-        layout.path
-      )
+      if layout.render_with_liquid?
+        payload["content"] = output
+        payload["layout"]  = Utils.deep_merge_hashes(layout.data, payload["layout"] || {})
+
+        render_liquid(
+          layout.content,
+          payload,
+          liquid_context,
+          layout.path
+        )
+      else
+        layout_converters ||= site.converters.select { |c| c.matches(layout.ext) }.sort
+
+        layout_content = layout.content.dup
+        layout_converters.reduce(layout_content) do |layout_output, converter|
+          next(layout_output) unless converter.method(:convert).arity == 2
+
+          layout.current_document = document
+          layout.current_document_output = output
+          converter.convert layout_output, layout
+        rescue StandardError => e
+          Bridgetown.logger.error "Conversion error:",
+                                  "#{converter.class} encountered an error while "\
+                                  "converting '#{document.relative_path}':"
+          Bridgetown.logger.error("", e.to_s)
+          raise e
+        end
+      end
     end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
     def add_regenerator_dependencies(layout)
       return unless document.write?

data/lib/bridgetown-core/ruby_template_view.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Bridgetown
+  class RubyTemplateView
+    class Helpers
+      include Bridgetown::Filters
+    end
+
+    attr_reader :layout, :page, :site, :content
+
+    def initialize(convertible)
+      if convertible.is_a?(Layout)
+        @layout = convertible
+        @page = layout.current_document
+        @content = layout.current_document_output
+      else
+        @page = convertible
+      end
+      @site = page.site
+    end
+
+    def partial(_partial_name, _options = {})
+      raise "Must be implemented in a subclass"
+    end
+
+    def site_drop
+      site.site_payload.site
+    end
+
+    def liquid_render(component, options = {})
+      render_statement = _render_statement(component, options)
+
+      template = site.liquid_renderer.file(
+        "#{page.path}.#{Digest::SHA2.hexdigest(render_statement)}"
+      ).parse(render_statement)
+      template.warnings.each do |e|
+        Bridgetown.logger.warn "Liquid Warning:",
+                               LiquidRenderer.format_error(e, path || document.relative_path)
+      end
+      template.render!(options.deep_stringify_keys, _liquid_context)
+    end
+
+    def helpers
+      @helpers ||= Helpers.new
+    end
+
+    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
+
+    private
+
+    def _render_statement(component, options)
+      render_statement = ["{% render \"#{component}\""]
+      unless options.empty?
+        render_statement << ", " + options.keys.map { |k| "#{k}: #{k}" }.join(", ")
+      end
+      render_statement << " %}"
+      render_statement.join
+    end
+
+    def _liquid_context
+      {
+        registers: {
+          site: site,
+          page: page,
+          cached_partials: Bridgetown::Renderer.cached_partials,
+        },
+        strict_filters: site.config["liquid"]["strict_filters"],
+        strict_variables: site.config["liquid"]["strict_variables"],
+      }
+    end
+  end
+end

data/lib/bridgetown-core/tags/class_map.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Bridgetown
+  module Tags
+    # A ClassMap class is meant to take a hash and append styles based on if the
+    # value is truthy or falsy
+    #
+    # @example
+    #   center-var = true
+    #   small-var = nil
+    #
+    #   # input
+    #   <div class="{% class_map has-centered-text: center-var, is-small: small-var %}">
+    #     Text
+    #   </div>
+    #
+    #   # output
+    #   <div class="has-centered-text">
+    #     Text
+    #   </div>
+    class ClassMap < Liquid::Tag
+      # @see https://api.rubyonrails.org/classes/ActiveModel/Type/Boolean.html
+      FALSE_VALUES = [
+        nil, "nil", "NIL", false, 0, "0", :"0", "f", :f, "F", :F, "false",
+        false, "FALSE", :FALSE,
+      ].to_set.freeze
+
+      # @param tag_name [String] The name to use for the tag
+      # @param input [String] The input to the tag
+      # @param tokens [Hash] A hash of config tokens for Liquid.
+      #
+      #
+      # @return [ClassMap] Returns a ClassMap object
+      def initialize(tag_name, input, tokens)
+        super
+        @input = input
+      end
+
+      def render(context)
+        class_map(@input, context)
+      end
+
+      private
+
+      def class_map(string, context)
+        ary = []
+
+        string.split(%r!,\s+!).each do |item|
+          kv_pair = item.split(%r!:\s+!)
+          klass = kv_pair[0]
+          variable = kv_pair[1]
+
+          # Check if a user wants the opposite of the variable
+          if variable[0] == "!"
+            check_opposite = true
+            variable.slice!(1..-1)
+          end
+
+          variable = find_variable(context, variable)
+
+          if check_opposite
+            ary.push(klass) if FALSE_VALUES.include?(variable)
+          else
+            ary.push(klass) unless FALSE_VALUES.include?(variable)
+          end
+        end
+
+        ary.join(" ")
+
+      # Gracefully handle if syntax is improper
+      rescue NoMethodError
+        "invalid-class-map"
+      end
+
+      def find_variable(context, variable)
+        lookup = context
+
+        variable.split(".").each do |value|
+          lookup = lookup[value.strip]
+        end
+
+        lookup || nil
+      end
+    end
+  end
+end
+
+Liquid::Template.register_tag("class_map", Bridgetown::Tags::ClassMap)

data/lib/bridgetown-core/tags/include.rb

@@ -212,7 +212,9 @@ module Bridgetown
             else
               File.join(site.config["collections_dir"], page_payload["path"])
             end
+          # rubocop:disable Performance/DeleteSuffix
           resource_path.sub!(%r!/#excerpt\z!, "")
+          # rubocop:enable Performance/DeleteSuffix
           site.in_source_dir File.dirname(resource_path)
         end
       end

data/lib/bridgetown-core/tags/render_content.rb

@@ -3,9 +3,12 @@
 module Bridgetown
   module Tags
     class BlockRenderTag < Liquid::Block
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
       def render(context)
         context.stack({}) do
-          content = super.gsub(%r!^[ \t]+!, "") # unindent the incoming text
+          # unindent the incoming text
+          content = Bridgetown::Utils.reindent_for_markdown(super)
+
           regions = gather_content_regions(context)
 
           site = context.registers[:site]
@@ -17,7 +20,15 @@ module Bridgetown
           unless regions.empty?
             regions.each do |region_name, region_content|
               region_name = region_name.sub("content_with_region_", "")
-              context[region_name] = converter.convert(region_content.gsub(%r!^[ \t]+!, ""))
+
+              if region_name.end_with? ":markdown"
+                region_name.sub!(%r!:markdown$!, "")
+                context[region_name] = converter.convert(
+                  Bridgetown::Utils.reindent_for_markdown(region_content)
+                )
+              else
+                context[region_name] = region_content
+              end
               render_params.push "#{region_name}: #{region_name}"
             end
           end
@@ -26,6 +37,7 @@ module Bridgetown
             .render_tag(context, +"")
         end
       end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
       private
 

data/lib/bridgetown-core/tags/webpack_path.rb

@@ -2,38 +2,70 @@
 
 module Bridgetown
   module Tags
+    # A helper class to help find the path to webpack asset inside of a webpack
+    # manifest file.
     class WebpackPath < Liquid::Tag
       include Bridgetown::Filters::URLFilters
 
-      def initialize(tag_name, asset_type, tokens)
+      # @param tag_name [String] Name of the tag
+      # @param asset_type [String] The type of asset to parse (js, css)
+      # @param options [Hash] An options hash
+      # @return WebpackPath
+      # @see {https://www.rdoc.info/github/Shopify/liquid/Liquid/Tag#initialize-instance_method}
+      def initialize(tag_name, asset_type, options)
         super
 
         # js or css
         @asset_type = asset_type.strip
       end
 
+      # Render the contents of a webpack manifest file
+      # @param context [String] Root directory that contains the manifest file
+      #
+      # @return [String] Returns "MISSING_WEBPACK_MANIFEST" if the manifest
+      # file isnt found
+      # @return [nil] Returns nil if the asset isnt found
+      # @return [String] Returns the path to the asset if no issues parsing
+      #
+      # @raise [WebpackAssetError] if unable to find css or js in the manifest
+      # file
       def render(context)
         @context = context
         site = context.registers[:site]
 
+        manifest_file = site.in_root_dir(".bridgetown-webpack", "manifest.json")
+
+        parse_manifest_file(manifest_file)
+      end
+
+      private
+
+      def parse_manifest_file(manifest_file)
+        return "MISSING_WEBPACK_MANIFEST" unless File.exist?(manifest_file)
+
+        manifest = JSON.parse(File.read(manifest_file))
         frontend_path = relative_url("_bridgetown/static")
 
-        manifest_file = site.in_root_dir(".bridgetown-webpack", "manifest.json")
-        if File.exist?(manifest_file)
-          manifest = JSON.parse(File.read(manifest_file))
-          if @asset_type == "js"
-            js_path = manifest["main.js"].split("/").last
-            [frontend_path, "js", js_path].join("/")
-          elsif @asset_type == "css"
-            css_path = manifest["main.css"].split("/").last
-            [frontend_path, "css", css_path].join("/")
-          else
-            Bridgetown.logger.error("Unknown Webpack asset type", @asset_type)
-            nil
-          end
-        else
-          "MISSING_WEBPACK_MANIFEST"
+        known_assets = %w(js css)
+
+        if known_assets.include?(@asset_type)
+          asset_path = manifest["main.#{@asset_type}"]
+
+          log_webpack_asset_error(@asset_type) if asset_path.nil?
+
+          asset_path = asset_path.split("/").last
+          return [frontend_path, @asset_type, asset_path].join("/")
         end
+
+        Bridgetown.logger.error("Unknown Webpack asset type", @asset_type)
+        nil
+      end
+
+      def log_webpack_asset_error(asset_type)
+        error_message = "There was an error parsing your #{asset_type} files. \
+          Please check your #{asset_type} for any errors."
+
+        Bridgetown.logger.warn(Errors::WebpackAssetError, error_message)
       end
     end
   end