bridgetown-core 0.15.0.beta2 → 0.16.0.beta2

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,98 @@
+# frozen_string_literal: true
+
+require "digest"
+require "active_support/core_ext/hash/keys"
+
+module Bridgetown
+  class RubyTemplateView
+    class Helpers
+      include Bridgetown::Filters
+
+      Context = Struct.new(:registers)
+
+      def initialize(site)
+        @site = site
+
+        # duck typing for Liquid context
+        @context = Context.new({ site: @site })
+      end
+
+      def webpack_path(asset_type)
+        Bridgetown::Utils.parse_webpack_manifest_file(@site, asset_type.to_s)
+      end
+    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(@site)
+    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,35 @@
 
 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 [void]
+      # @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 an asset path based on the Webpack manifest file
+      # @param context [Liquid::Context] Context passed to the tag
+      #
+      # @return [String] Returns "MISSING_WEBPACK_MANIFEST" if the manifest
+      # file isn't found
+      # @return [String] Returns a blank string if the asset isn't 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]
-
-        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"
-        end
+        Bridgetown::Utils.parse_webpack_manifest_file(site, @asset_type) || ""
       end
     end
   end

data/lib/bridgetown-core/utils.rb

@@ -287,6 +287,103 @@ module Bridgetown
       merged
     end
 
+    # Returns a string that's been reindented so that Markdown's four+ spaces =
+    # code doesn't get triggered for nested Liquid components
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
+    def reindent_for_markdown(input)
+      lines = input.lines
+      return input if lines.first.nil?
+
+      starting_indentation = lines.find { |line| line != "\n" }&.match(%r!^ +!)
+      return input unless starting_indentation
+
+      starting_indent_length = starting_indentation[0].length
+
+      skip_pre_lines = false
+      lines.map do |line|
+        continue_processing = !skip_pre_lines
+
+        if skip_pre_lines
+          skip_pre_lines = false if line.include?("</pre>")
+        end
+        if line.include?("<pre")
+          skip_pre_lines = true
+          continue_processing = false
+        end
+
+        if continue_processing
+          line_indentation = line.match(%r!^ +!).yield_self do |indent|
+            indent.nil? ? "" : indent[0]
+          end
+          new_indentation = line_indentation.rjust(starting_indent_length, " ")
+
+          if %r!^ +!.match?(line)
+            line
+              .sub(%r!^ {1,#{starting_indent_length}}!, new_indentation)
+              .sub(%r!^#{new_indentation}!, "")
+          else
+            line
+          end
+        else
+          line
+        end
+      end.join("")
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
+
+    # Return an asset path based on the Webpack manifest file
+    # @param site [Bridgetown::Site] The current site object
+    # @param asset_type [String] js or css
+    #
+    # @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 parse_webpack_manifest_file(site, asset_type)
+      manifest_file = site.in_root_dir(".bridgetown-webpack", "manifest.json")
+      return "MISSING_WEBPACK_MANIFEST" unless File.exist?(manifest_file)
+
+      manifest = JSON.parse(File.read(manifest_file))
+
+      known_assets = %w(js css)
+      if known_assets.include?(asset_type)
+        asset_path = manifest["main.#{asset_type}"]
+
+        log_webpack_asset_error(asset_type) && return if asset_path.nil?
+
+        asset_path = asset_path.split("/").last
+        return [static_frontend_path(site), asset_type, asset_path].join("/")
+      end
+
+      Bridgetown.logger.error("Unknown Webpack asset type", asset_type)
+      nil
+    end
+
+    def static_frontend_path(site)
+      path_parts = [site.config["baseurl"].to_s.chomp("/"), "_bridgetown/static"]
+      path_parts[0] = "/#{path_parts[0]}" unless path_parts[0].empty?
+      Addressable::URI.parse(path_parts.join("/")).normalize.to_s
+    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
+
+    def default_github_branch_name(repo_url)
+      repo_match = Bridgetown::Commands::Actions::GITHUB_REPO_REGEX.match(repo_url)
+      api_endpoint = "https://api.github.com/repos/#{repo_match[1]}"
+      JSON.parse(Faraday.get(api_endpoint).body)["default_branch"] || "master"
+    rescue StandardError => e
+      Bridgetown.logger.warn("Unable to connect to GitHub API: #{e.message}")
+      "master"
+    end
+
     private
 
     def merge_values(target, overwrite)