bridgetown-core 0.16.0.beta2 → 0.18.1

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
@@ -20,13 +21,13 @@ module Bridgetown
     # Read all the files in <source>/<dir>/<magic_dir> and create a new
     # Document object with each one insofar as it matches the regexp matcher.
     #
-    # dir - The String relative path of the directory to read.
+    # @param dir [String] relative path of the directory to read.
     #
-    # Returns nothing.
+    # @return [Array<Document, StaticFile>]
     def read_publishable(dir, magic_dir, matcher)
       read_content(dir, magic_dir, matcher)
-        .tap { |entries| entries.select { |entry| entry.respond_to?(:read) }.each(&:read) }
-        .select { |entry| processable?(entry) }
+        .tap { |items| items.select { |item| item.respond_to?(:read) }.each(&:read) }
+        .select { |item| item_added_to_site?(item) }
     end
 
     # Read all the content files from <source>/<dir>/magic_dir
@@ -69,26 +70,39 @@ module Bridgetown
       )
     end
 
-    def processable?(doc)
-      return true if doc.is_a?(StaticFile)
+    def processable?(item)
+      return true if item.is_a?(StaticFile)
 
-      if doc.content.nil?
-        Bridgetown.logger.debug "Skipping:", "Content in #{doc.relative_path} is nil"
+      if item.content.nil?
+        Bridgetown.logger.debug "Skipping:", "Content in #{item.relative_path} is nil"
         false
-      elsif !doc.content.valid_encoding?
-        Bridgetown.logger.debug "Skipping:", "#{doc.relative_path} is not valid UTF-8"
+      elsif !item.content.valid_encoding?
+        Bridgetown.logger.debug "Skipping:", "#{item.relative_path} is not valid UTF-8"
         false
       else
-        publishable?(doc)
+        publishable?(item)
       end
     end
 
-    def publishable?(doc)
-      site.publisher.publish?(doc).tap do |will_publish|
-        if !will_publish && site.publisher.hidden_in_the_future?(doc)
-          Bridgetown.logger.warn "Skipping:", "#{doc.relative_path} has a future date"
+    def publishable?(item)
+      site.publisher.publish?(item).tap do |will_publish|
+        if !will_publish && site.publisher.hidden_in_the_future?(item)
+          Bridgetown.logger.warn "Skipping:", "#{item.relative_path} has a future date"
         end
       end
     end
+
+    def item_added_to_site?(item)
+      return false unless processable?(item)
+
+      if item.is_a?(Document)
+        site.posts.docs << item
+      elsif item.is_a?(StaticFile)
+        site.posts.files << item
+        site.static_files << item
+      end
+
+      true
+    end
   end
 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/renderer.rb

@@ -3,37 +3,10 @@
 module Bridgetown
   class Renderer
     attr_reader :document, :site
-    attr_writer :layouts, :payload
 
-    class << self
-      attr_accessor :cached_partials
-    end
-
-    def initialize(site, document, site_payload = nil)
+    def initialize(site, document)
       @site     = site
       @document = document
-      @payload  = site_payload
-      @layouts  = nil
-      self.class.cached_partials ||= {}
-    end
-
-    # Fetches the payload used in Liquid rendering.
-    # It can be written with #payload=(new_payload)
-    # Falls back to site.site_payload if no payload is set.
-    #
-    # Returns a Bridgetown::Drops::UnifiedPayloadDrop
-    def payload
-      @payload ||= site.site_payload
-    end
-
-    # The list of layouts registered for this Renderer.
-    # It can be written with #layouts=(new_layouts)
-    # Falls back to site.layouts if no layouts are registered.
-    #
-    # Returns a Hash of String => Bridgetown::Layout identified
-    # as basename without the extension name.
-    def layouts
-      @layouts || site.layouts
     end
 
     # Determine which converters to use based on this document's
@@ -41,7 +14,13 @@ module Bridgetown
     #
     # Returns Array of Converter instances.
     def converters
-      @converters ||= site.converters.select { |c| c.matches(document.extname) }.sort
+      @converters ||= site.converters.select do |converter|
+        if converter.method(:matches).arity == 1
+          converter.matches(document.extname)
+        else
+          converter.matches(document.extname, document)
+        end
+      end.sort
     end
 
     # Determine the extname the outputted file should have
@@ -51,93 +30,42 @@ module Bridgetown
       @output_ext ||= (permalink_ext || converter_output_ext)
     end
 
-    # Prepare payload and render the document
+    # Run hooks and render the document
     #
     # 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)
+      document.trigger_hooks :pre_render
       document.output = render_document
-      document.trigger_hooks(:post_render)
+      document.trigger_hooks :post_render
     end
 
     # Render the document.
     #
     # Returns String rendered document output
-    # rubocop: disable Metrics/AbcSize
     def render_document
-      liquid_context = provide_liquid_context
-
       execute_inline_ruby!
 
       output = document.content
-      if document.render_with_liquid?
-        Bridgetown.logger.debug "Rendering Liquid:", document.relative_path
-        output = render_liquid(output, payload, liquid_context, document.path)
-      end
-
       Bridgetown.logger.debug "Rendering Markup:", document.relative_path
       output = convert(output.to_s, document)
       document.content = output
 
       if document.place_in_layout?
         Bridgetown.logger.debug "Rendering Layout:", document.relative_path
-        output = place_in_layouts(output, payload, liquid_context)
+        output = place_in_layouts(output)
       end
 
       output
     end
 
-    def provide_liquid_context
-      {
-        registers: {
-          site: site,
-          page: payload["page"],
-          cached_partials: self.class.cached_partials,
-        },
-        strict_filters: liquid_options["strict_filters"],
-        strict_variables: liquid_options["strict_variables"],
-      }
-    end
-
     def execute_inline_ruby!
       return unless site.config.should_execute_inline_ruby?
 
       Bridgetown::Utils::RubyExec.search_data_for_ruby_code(document, self)
     end
 
-    # rubocop: enable Metrics/AbcSize
-
-    # Render the given content with the payload and context
-    #
-    # content -
-    # payload -
-    # context    -
-    # path    - (optional) the path to the file, for use in ex
-    #
-    # Returns String the content, rendered by Liquid.
-    def render_liquid(content, payload, liquid_context, path = nil)
-      template = site.liquid_renderer.file(path).parse(content)
-      template.warnings.each do |e|
-        Bridgetown.logger.warn "Liquid Warning:",
-                               LiquidRenderer.format_error(e, path || document.relative_path)
-      end
-      template.render!(payload, liquid_context)
-    # rubocop: disable Lint/RescueException
-    rescue Exception => e
-      Bridgetown.logger.error "Liquid Exception:",
-                              LiquidRenderer.format_error(e, path || document.relative_path)
-      raise e
-    end
-    # rubocop: enable Lint/RescueException
-
     # Convert the document using the converters which match this renderer's document.
     #
     # Returns String the converted content.
@@ -157,30 +85,18 @@ module Bridgetown
       end
     end
 
-    # Checks if the layout specified in the document actually exists
-    #
-    # layout - the layout to check
-    #
-    # Returns Boolean true if the layout is invalid, false if otherwise
-    def invalid_layout?(layout)
-      !document.data["layout"].nil? && layout.nil? && !(document.is_a? Bridgetown::Excerpt)
-    end
-
     # Render layouts and place document content inside.
     #
     # Returns String rendered content
-    def place_in_layouts(content, payload, liquid_context)
+    def place_in_layouts(content)
       output = content.dup
-      layout = layouts[document.data["layout"].to_s]
+      layout = site.layouts[document.data["layout"]]
       validate_layout(layout)
 
       used = Set.new([layout])
 
-      # Reset the payload layout data to ensure it starts fresh for each page.
-      payload["layout"] = nil
-
       while layout
-        output = render_layout(output, layout, liquid_context)
+        output = render_layout(output, layout)
         add_regenerator_dependencies(layout)
 
         next unless (layout = site.layouts[layout.data["layout"]])
@@ -198,47 +114,45 @@ module Bridgetown
     # layout - the layout to check
     # Returns nothing
     def validate_layout(layout)
-      return unless invalid_layout?(layout)
+      return unless document.data["layout"].present? &&
+        layout.nil? &&
+        !(document.is_a? Bridgetown::Excerpt)
 
       Bridgetown.logger.warn "Build Warning:", "Layout '#{document.data["layout"]}' requested " \
         "in #{document.relative_path} does not exist."
     end
 
+    def converters_for_layout(layout)
+      site.converters.select do |converter|
+        if converter.method(:matches).arity == 1
+          converter.matches(layout.ext)
+        else
+          converter.matches(layout.ext, layout)
+        end
+      end.sort
+    end
+
     # Render layout content into document.output
     #
     # Returns String rendered content
-    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-    def render_layout(output, layout, liquid_context)
-      if layout.render_with_liquid?
-        payload["content"] = output
-        payload["layout"]  = Utils.deep_merge_hashes(layout.data, payload["layout"] || {})
+    def render_layout(output, layout)
+      layout_converters = converters_for_layout(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_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
+        layout.current_document = document
+        layout.current_document_output = output
+        converter.convert layout_output, layout
       end
+    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
-    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
     def add_regenerator_dependencies(layout)
       return unless document.write?
@@ -249,34 +163,6 @@ module Bridgetown
       )
     end
 
-    # Set page content to payload and assign pager if document has one.
-    #
-    # Returns nothing
-    def assign_pages!
-      payload["page"] = document.to_liquid
-      payload["paginator"] = (document.pager.to_liquid if document.respond_to?(:pager))
-    end
-
-    # Set related posts to payload if document is a post.
-    #
-    # Returns nothing
-    def assign_current_document!
-      payload["site"].current_document = document
-    end
-
-    # Set highlighter prefix and suffix
-    #
-    # Returns nothing
-    def assign_highlighter_options!
-      payload["highlighter_prefix"] = converters.first.highlighter_prefix
-      payload["highlighter_suffix"] = converters.first.highlighter_suffix
-    end
-
-    def assign_layout_data!
-      layout = layouts[document.data["layout"]]
-      payload["layout"] = Utils.deep_merge_hashes(layout.data, payload["layout"] || {}) if layout
-    end
-
     def permalink_ext
       document_permalink = document.permalink
       if document_permalink && !document_permalink.end_with?("/")
@@ -298,9 +184,5 @@ module Bridgetown
         c.output_ext(document.extname)
       end.compact
     end
-
-    def liquid_options
-      @liquid_options ||= site.config["liquid"]
-    end
   end
 end

data/lib/bridgetown-core/ruby_template_view.rb

@@ -5,24 +5,9 @@ require "active_support/core_ext/hash/keys"
 
 module Bridgetown
   class RubyTemplateView
-    class Helpers
-      include Bridgetown::Filters
+    require "bridgetown-core/helpers"
 
-      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
+    attr_reader :layout, :page, :paginator, :site, :content
 
     def initialize(convertible)
       if convertible.is_a?(Layout)
@@ -30,8 +15,10 @@ module Bridgetown
         @page = layout.current_document
         @content = layout.current_document_output
       else
+        @layout = convertible.site.layouts[convertible.data["layout"]]
         @page = convertible
       end
+      @paginator = page.paginator if page.respond_to?(:paginator)
       @site = page.site
     end
 
@@ -39,11 +26,20 @@ module Bridgetown
       raise "Must be implemented in a subclass"
     end
 
+    def render(item, options = {}, &block)
+      if item.respond_to?(:render_in)
+        item.render_in(self, &block)
+      else
+        partial(item, options, &block)
+      end
+    end
+
     def site_drop
       site.site_payload.site
     end
 
-    def liquid_render(component, options = {})
+    def liquid_render(component, options = {}, &block)
+      options[:_block_content] = capture(&block) if block && respond_to?(:capture)
       render_statement = _render_statement(component, options)
 
       template = site.liquid_renderer.file(
@@ -57,7 +53,7 @@ module Bridgetown
     end
 
     def helpers
-      @helpers ||= Helpers.new(@site)
+      @helpers ||= Helpers.new(self, site)
     end
 
     def method_missing(method, *args, &block)
@@ -75,11 +71,19 @@ module Bridgetown
     private
 
     def _render_statement(component, options)
-      render_statement = ["{% render \"#{component}\""]
+      render_statement = if options[:_block_content]
+                           ["{% rendercontent \"#{component}\""]
+                         else
+                           ["{% render \"#{component}\""]
+                         end
       unless options.empty?
         render_statement << ", " + options.keys.map { |k| "#{k}: #{k}" }.join(", ")
       end
       render_statement << " %}"
+      if options[:_block_content]
+        render_statement << options[:_block_content]
+        render_statement << "{% endrendercontent %}"
+      end
       render_statement.join
     end
 
@@ -87,8 +91,8 @@ module Bridgetown
       {
         registers: {
           site: site,
-          page: page,
-          cached_partials: Bridgetown::Renderer.cached_partials,
+          page: page.to_liquid,
+          cached_partials: Bridgetown::Converters::LiquidTemplates.cached_partials,
         },
         strict_filters: site.config["liquid"]["strict_filters"],
         strict_variables: site.config["liquid"]["strict_variables"],