bridgetown-core 0.20.0 → 0.21.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c58653595832ef2fb9e6bbea3f147a0b3be9edae554d169e974570b84565a507
-  data.tar.gz: 7af409e9a01570321171cf1afc562c00cacdcc6e0dce98f2b8eac4988a60e8d6
+  metadata.gz: 02c8827143ec0abe2adfa081ef1fe7723d8d000c4ecec5c6da1ddaa2ef9a8cdf
+  data.tar.gz: 2c81ef34075b80ce956f43b57b01b400852d4a30e3eca8587785febc5c82a850
 SHA512:
-  metadata.gz: b21d9c304dd99dd306b70e97e172d1ec172f0d1fa48034610cc3d9e6bc9c40b98e7fe10479226103cb2ff501c22c7c2841f20630235262cc7214661be62bcf3e
-  data.tar.gz: cab7afb0f441e412850ce648d6e7ca9a3996f106b0800c31ef24a0cf63af9db770498f307da275860c0572d6d6f2a5f1e56570d10349bb11cd4f17f96b3266ee
+  metadata.gz: f86157dcd3f2fb1139e490fcc1341e2508f4811bda806171e2374e4753cf14c6c121abbb2ceeb6536a925bfd1d1ecba44c6d35fb6ebd6c0bcad3b4ace8d73912
+  data.tar.gz: 9262363b23785be1ad111a611d7660201dd3e948e331fdcf5395afd8fde91f1cb075ba13d1729fcd537cd15e3d209c8016145af04c13f054f87bb37d46406617

data/lib/bridgetown-core.rb

@@ -38,6 +38,7 @@ require "active_support/core_ext/object/deep_dup"
 require "active_support/core_ext/object/inclusion"
 require "active_support/core_ext/string/inflections"
 require "active_support/core_ext/string/inquiry"
+require "active_support/core_ext/string/output_safety"
 require "active_support/core_ext/string/starts_ends_with"
 require "active_support/current_attributes"
 require "active_support/descendants_tracker"
@@ -80,6 +81,7 @@ end
 module Bridgetown
   autoload :Cleaner,             "bridgetown-core/cleaner"
   autoload :Collection,          "bridgetown-core/collection"
+  autoload :Component,           "bridgetown-core/component"
   autoload :Configuration,       "bridgetown-core/configuration"
   autoload :DataAccessible,      "bridgetown-core/concerns/data_accessible"
   autoload :Deprecator,          "bridgetown-core/deprecator"
@@ -91,6 +93,7 @@ module Bridgetown
   # TODO: this is a poorly named, unclear class. Relocate to Utils:
   autoload :External,            "bridgetown-core/external"
   autoload :FrontmatterDefaults, "bridgetown-core/frontmatter_defaults"
+  autoload :FrontMatterImporter, "bridgetown-core/concerns/front_matter_importer"
   autoload :Hooks,               "bridgetown-core/hooks"
   autoload :Layout,              "bridgetown-core/layout"
   autoload :LayoutPlaceable,     "bridgetown-core/concerns/layout_placeable"

data/lib/bridgetown-core/collection.rb

@@ -78,7 +78,8 @@ module Bridgetown
         if site.uses_resource?
           next if File.basename(file_path).starts_with?("_")
 
-          if label == "data" || Utils.has_yaml_header?(full_path)
+          if label == "data" || Utils.has_yaml_header?(full_path) ||
+              Utils.has_rbfm_header?(full_path)
             read_resource(full_path)
           else
             read_static_file(file_path, full_path)
@@ -256,7 +257,7 @@ module Bridgetown
           sanitized_segment = sanitize_filename.(File.basename(segment, ".*"))
           hsh = nested.empty? ? data_contents : data_contents.dig(*nested)
           hsh[sanitized_segment] = if index == segments.length - 1
-                                     data_resource.data.array || data_resource.data
+                                     data_resource.data.rows || data_resource.data
                                    else
                                      {}
                                    end
@@ -279,6 +280,16 @@ module Bridgetown
       data_contents
     end
 
+    # Read in resource from repo path
+    # @param full_path [String]
+    def read_resource(full_path)
+      id = "repo://#{label}.collection/" + Addressable::URI.escape(
+        Pathname(full_path).relative_path_from(Pathname(site.source)).to_s
+      )
+      resource = Bridgetown::Model::Base.find(id).to_resource.read!
+      resources << resource if site.unpublished || resource.published?
+    end
+
     private
 
     def container
@@ -290,14 +301,6 @@ module Bridgetown
       docs << doc if site.unpublished || doc.published?
     end
 
-    def read_resource(full_path)
-      id = "file://#{label}.collection/" + Addressable::URI.escape(
-        Pathname(full_path).relative_path_from(Pathname(site.source)).to_s
-      )
-      resource = Bridgetown::Model::Base.find(id).to_resource.read!
-      resources << resource if site.unpublished || resource.published?
-    end
-
     def sort_docs!
       if metadata["sort_by"].is_a?(String)
         sort_docs_by_key!

data/lib/bridgetown-core/component.rb

@@ -0,0 +1,178 @@
+# 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)
+        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
+        stripped_path = File.join(
+          File.dirname(source_location),
+          File.basename(source_location, ".*")
+        )
+        supported_template_extensions.each do |ext|
+          test_path = "#{stripped_path}.#{ext}"
+          return test_path if File.exist?(test_path)
+
+          test_path = "#{stripped_path}.html.#{ext}"
+          return test_path if File.exist?(test_path)
+        end
+
+        raise "No matching templates could be found in #{File.dirname(source_location)}"
+      end
+
+      # Read the template file.
+      #
+      # @return [String]
+      def component_template_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
+      # TODO: figure out a way to compile templates for increased performance
+      @_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
+        SafeYAML.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 = SafeYAML.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

data/lib/bridgetown-core/concerns/site/content.rb

@@ -173,9 +173,8 @@ class Bridgetown::Site
       documents.select(&:write?)
     end
 
-    # Get all documents.
-    # @return [Array<Document>] an array of documents from the
-    # configuration
+    # Get all loaded resources.
+    # @return [Array<Bridgetown::Resource::Base>] an array of resources
     def resources
       collections.each_with_object(Set.new) do |(_, collection), set|
         set.merge(collection.resources)

data/lib/bridgetown-core/concerns/site/writable.rb

@@ -21,7 +21,7 @@ class Bridgetown::Site
     end
 
     # Yields all content objects while looping through {#pages},
-    #   {#static_files_to_write}, and {#docs_to_write}.
+    #   {#static_files_to_write}, {#docs_to_write}, {#resources_to_write}.
     #
     # @yieldparam item [Document, Page, StaticFile]
     #

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

@@ -3,10 +3,6 @@
 module Bridgetown
   # TODO: to be retired once the Resource engine is made official
   module Validatable
-    # FIXME: there should be ONE TRUE METHOD to read the YAML frontmatter
-    # in the entire project. Both this and the equivalent Document method
-    # should be extracted and generalized.
-    #
     # Read the YAML frontmatter.
     #
     # base - The String path to the dir containing the file.

data/lib/bridgetown-core/configuration.rb

@@ -74,15 +74,16 @@ module Bridgetown
       },
 
       "kramdown"             => {
-        "auto_ids"      => true,
-        "toc_levels"    => (1..6).to_a,
-        "entity_output" => "as_char",
-        "smart_quotes"  => "lsquo,rsquo,ldquo,rdquo",
-        "input"         => "GFM",
-        "hard_wrap"     => false,
-        "guess_lang"    => true,
-        "footnote_nr"   => 1,
-        "show_warnings" => false,
+        "auto_ids"                => true,
+        "toc_levels"              => (1..6).to_a,
+        "entity_output"           => "as_char",
+        "smart_quotes"            => "lsquo,rsquo,ldquo,rdquo",
+        "input"                   => "GFM",
+        "hard_wrap"               => false,
+        "guess_lang"              => true,
+        "footnote_nr"             => 1,
+        "show_warnings"           => false,
+        "include_extraction_tags" => false,
       },
     }.each_with_object(Configuration.new) { |(k, v), hsh| hsh[k] = v.freeze }.freeze
 

data/lib/bridgetown-core/converter.rb

@@ -53,6 +53,15 @@ module Bridgetown
       ".html"
     end
 
+    def line_start(convertible)
+      if convertible.is_a?(Bridgetown::Resource::Base) &&
+          convertible.model.origin.respond_to?(:front_matter_line_count)
+        convertible.model.origin.front_matter_line_count + 4
+      else
+        1
+      end
+    end
+
     def inspect
       "#<#{self.class}#{self.class.extname_list ? " #{self.class.extname_list.join(", ")}" : nil}>"
     end

data/lib/bridgetown-core/converters/erb_templates.rb

@@ -3,14 +3,26 @@
 require "tilt/erubi"
 
 module Bridgetown
-  class ERBBuffer < String
-    def concat_to_s(input)
-      concat input.to_s
+  class OutputBuffer < ActiveSupport::SafeBuffer
+    def initialize(*)
+      super
+      encode!
     end
 
-    alias_method :safe_append=, :concat_to_s
-    alias_method :append=, :concat_to_s
-    alias_method :safe_expr_append=, :concat_to_s
+    def <<(value)
+      return self if value.nil?
+
+      super(value.to_s)
+    end
+    alias_method :append=, :<<
+
+    def safe_expr_append=(val)
+      return self if val.nil? # rubocop:disable Lint/ReturnInVoidContext
+
+      safe_concat val.to_s
+    end
+
+    alias_method :safe_append=, :safe_concat
   end
 
   class ERBEngine < Erubi::Engine
@@ -22,24 +34,47 @@ module Bridgetown
       @src << ";" unless code[Erubi::RANGE_LAST] == "\n"
     end
 
+    def add_text(text)
+      return if text.empty?
+
+      src << bufvar << ".safe_append='"
+      src << text.gsub(%r{['\\]}, '\\\\\&')
+      src << "'.freeze;"
+    end
+
     # pulled from Rails' ActionView
     BLOCK_EXPR = %r!\s*((\s+|\))do|\{)(\s*\|[^|]*\|)?\s*\Z!.freeze
 
     def add_expression(indicator, code)
+      src << bufvar << if (indicator == "==") || @escape
+                         ".safe_expr_append="
+                       else
+                         ".append="
+                       end
+
       if BLOCK_EXPR.match?(code)
-        src << "#{@bufvar}.append= " << code
+        src << " " << code
       else
-        super
+        src << "(" << code << ");"
       end
     end
+  end
 
-    # Don't allow == to output escaped strings, as that's the opposite of Rails
-    def add_expression_result_escaped(code)
-      add_expression_result(code)
+  module ERBCapture
+    def capture(*args)
+      previous_buffer_state = @_erbout
+      @_erbout = OutputBuffer.new
+      result = yield(*args)
+      result = @_erbout.presence || result
+      @_erbout = previous_buffer_state
+
+      result.is_a?(String) ? ERB::Util.h(result) : result
     end
   end
 
   class ERBView < RubyTemplateView
+    include ERBCapture
+
     def h(input)
       Erubi.h(input)
     end
@@ -55,30 +90,10 @@ module Bridgetown
       Tilt::ErubiTemplate.new(
         site.in_source_dir(site.config[:partials_dir], "#{partial_name}.erb"),
         outvar: "@_erbout",
-        bufval: "Bridgetown::ERBBuffer.new",
+        bufval: "Bridgetown::OutputBuffer.new",
         engine_class: ERBEngine
       ).render(self, options)
     end
-
-    def markdownify(input = nil, &block)
-      content = Bridgetown::Utils.reindent_for_markdown(
-        block.nil? ? input.to_s : capture(&block)
-      )
-      converter = site.find_converter_instance(Bridgetown::Converters::Markdown)
-      result = converter.convert(content).strip
-      result.respond_to?(:html_safe) ? result.html_safe : result
-    end
-
-    def capture(*args, &block)
-      return capture_in_view_component(*args, &block) if @in_view_component
-
-      previous_buffer_state = @_erbout
-      @_erbout = ERBBuffer.new
-      result = yield(*args)
-      @_erbout = previous_buffer_state
-
-      result.respond_to?(:html_safe) ? result.html_safe : result
-    end
   end
 
   module Converters
@@ -100,14 +115,15 @@ module Bridgetown
 
         erb_renderer = Tilt::ErubiTemplate.new(
           convertible.relative_path,
+          line_start(convertible),
           outvar: "@_erbout",
-          bufval: "Bridgetown::ERBBuffer.new",
+          bufval: "Bridgetown::OutputBuffer.new",
           engine_class: ERBEngine
         ) { content }
 
         if convertible.is_a?(Bridgetown::Layout)
           erb_renderer.render(erb_view) do
-            convertible.current_document_output
+            convertible.current_document_output.html_safe
           end
         else
           erb_renderer.render(erb_view)