bridgetown-core 0.15.0.beta4 → 0.17.0

data/lib/bridgetown-core/plugin_manager.rb

@@ -68,12 +68,20 @@ module Bridgetown
     # If that exact package hasn't been installed, execute yarn add
     #
     # Returns nothing.
-    def self.install_yarn_dependencies(required_gems)
+    def self.install_yarn_dependencies(required_gems, single_gemname = nil)
       return unless File.exist?("package.json")
 
       package_json = JSON.parse(File.read("package.json"))
 
-      required_gems.each do |loaded_gem|
+      gems_to_search = if single_gemname
+                         required_gems.select do |loaded_gem|
+                           loaded_gem.to_spec&.name == single_gemname.to_s
+                         end
+                       else
+                         required_gems
+                       end
+
+      gems_to_search.each do |loaded_gem|
         yarn_dependency = find_yarn_dependency(loaded_gem)
         next unless add_yarn_dependency?(yarn_dependency, package_json)
 

data/lib/bridgetown-core/reader.rb

@@ -13,6 +13,7 @@ module Bridgetown
     # Returns nothing.
     # rubocop:disable Metrics/AbcSize
     def read
+      @site.defaults_reader.read
       @site.layouts = LayoutReader.new(site).read
       read_directories
       read_included_excludes

data/lib/bridgetown-core/readers/collection_reader.rb

@@ -5,6 +5,7 @@ module Bridgetown
     SPECIAL_COLLECTIONS = %w(posts data).freeze
 
     attr_reader :site, :content
+
     def initialize(site)
       @site = site
       @content = {}

data/lib/bridgetown-core/readers/data_reader.rb

@@ -3,6 +3,7 @@
 module Bridgetown
   class DataReader
     attr_reader :site, :content
+
     def initialize(site)
       @site = site
       @content = ActiveSupport::HashWithIndifferentAccess.new

data/lib/bridgetown-core/readers/defaults_reader.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  class DefaultsReader
+    attr_reader :site, :path_defaults
+
+    def initialize(site)
+      @site = site
+      @path_defaults = ActiveSupport::HashWithIndifferentAccess.new
+    end
+
+    def read
+      return unless File.directory?(site.source)
+
+      entries = Dir.chdir(site.source) do
+        Dir["**/_defaults.{yaml,yml,json}"]
+      end
+
+      entries.each do |entry|
+        path = @site.in_source_dir(entry)
+        @path_defaults[File.dirname(path) + File::SEPARATOR] = SafeYAML.load_file(path)
+      end
+
+      @path_defaults
+    end
+  end
+end

data/lib/bridgetown-core/readers/layout_reader.rb

@@ -3,6 +3,7 @@
 module Bridgetown
   class LayoutReader
     attr_reader :site
+
     def initialize(site)
       @site = site
       @layouts = {}

data/lib/bridgetown-core/readers/page_reader.rb

@@ -3,6 +3,7 @@
 module Bridgetown
   class PageReader
     attr_reader :site, :dir, :unfiltered_content
+
     def initialize(site, dir)
       @site = site
       @dir = dir

data/lib/bridgetown-core/readers/post_reader.rb

@@ -3,6 +3,7 @@
 module Bridgetown
   class PostReader
     attr_reader :site, :unfiltered_content
+
     def initialize(site)
       @site = site
     end

data/lib/bridgetown-core/readers/static_file_reader.rb

@@ -3,6 +3,7 @@
 module Bridgetown
   class StaticFileReader
     attr_reader :site, :dir, :unfiltered_content
+
     def initialize(site, dir)
       @site = site
       @dir = dir

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

@@ -58,6 +58,7 @@ module Bridgetown
       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!
@@ -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,102 @@
+# 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
+
+      def t(*args)
+        I18n.send :t, *args
+      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/site.rb

@@ -7,6 +7,7 @@ module Bridgetown
     include Configurable
     include Content
     include Extensible
+    include Localizable
     include Processable
     include Renderable
     include Writable
@@ -25,6 +26,7 @@ module Bridgetown
     # config - A Hash containing site configuration details.
     def initialize(config)
       self.config = config
+      locale
 
       @plugin_manager  = PluginManager.new(self)
       @cleaner         = Cleaner.new(self)

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/find.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Tags
+    class Find < Liquid::Tag
+      include Bridgetown::Filters::ConditionHelpers
+      include Bridgetown::LiquidExtensions
+
+      SYNTAX = %r!^(.*?) (where|in) (.*?),(.*)$!.freeze
+      CONDITIONS_SEP = "~FINDSEP~"
+
+      def initialize(tag_name, markup, tokens)
+        super
+        if markup.strip =~ SYNTAX
+          @new_var_name = Regexp.last_match(1).strip
+          @single_or_group = Regexp.last_match(2)
+          @arr_name = Regexp.last_match(3).strip
+          @conditions = process_conditions(Regexp.last_match(4).strip)
+        else
+          raise SyntaxError, <<~MSG
+            Syntax Error in tag 'find' while parsing the following markup:
+
+            #{markup}
+
+            Valid syntax: find <varname> where|in <array>, <condition(s)>
+          MSG
+        end
+      end
+
+      def render(context)
+        @group = lookup_variable(context, @arr_name)
+        return "" unless @group.respond_to?(:select)
+
+        @group = @group.values if @group.is_a?(Hash)
+
+        expression = @conditions.split(CONDITIONS_SEP).map do |condition|
+          "__find_tag_item__.#{condition.strip}"
+        end.join(" and ")
+        @liquid_condition = parse_condition(expression)
+
+        context[@new_var_name] = if @single_or_group == "where"
+                                   group_evaluate(context)
+                                 else
+                                   single_evaluate(context)
+                                 end
+
+        ""
+      end
+
+      private
+
+      def process_conditions(conditions)
+        processed_conditions = +""
+        in_quotes = false
+
+        conditions.each_char do |c|
+          in_quotes = !in_quotes if c == '"'
+
+          processed_conditions << (c == "," && !in_quotes ? CONDITIONS_SEP : c)
+        end
+
+        processed_conditions
+      end
+
+      def group_evaluate(context)
+        context.stack do
+          @group.select do |object|
+            context["__find_tag_item__"] = object
+            @liquid_condition.evaluate(context)
+          end
+        end || []
+      end
+
+      def single_evaluate(context)
+        context.stack do
+          @group.find do |object|
+            context["__find_tag_item__"] = object
+            @liquid_condition.evaluate(context)
+          end
+        end || nil
+      end
+    end
+  end
+end
+
+Liquid::Template.register_tag("find", Bridgetown::Tags::Find)