bridgetown-core 0.17.1 → 0.18.0

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Converters
+    class LiquidTemplates < Converter
+      priority :highest
+      input :liquid
+
+      attr_reader :site, :document, :layout
+
+      class << self
+        attr_accessor :cached_partials
+      end
+
+      # rubocop: disable Metrics/AbcSize
+      # rubocop: disable Metrics/MethodLength
+
+      # Logic to do the Liquid content conversion.
+      #
+      # @param content [String] Content of the file (without front matter).
+      # @params convertible [Bridgetown::Page, Bridgetown::Document, Bridgetown::Layout]
+      #   The instantiated object which is processing the file.
+      #
+      # @return [String] The converted content.
+      def convert(content, convertible)
+        self.class.cached_partials ||= {}
+
+        @site = convertible.site
+        if convertible.is_a?(Bridgetown::Layout)
+          @document = convertible.current_document
+          @layout = convertible
+          configure_payload(layout.current_document_output)
+        else
+          @document = convertible
+          @layout = site.layouts[document.data["layout"]]
+          configure_payload
+        end
+
+        template = site.liquid_renderer.file(convertible.path).parse(content)
+        template.warnings.each do |e|
+          Bridgetown.logger.warn "Liquid Warning:",
+                                 LiquidRenderer.format_error(e, convertible.path)
+        end
+        template.render!(payload, liquid_context)
+      # rubocop: disable Lint/RescueException
+      rescue Exception => e
+        Bridgetown.logger.error "Liquid Exception:",
+                                LiquidRenderer.format_error(e, convertible.path)
+        raise e
+      end
+      # rubocop: enable Lint/RescueException
+      # rubocop: enable Metrics/MethodLength
+      # rubocop: enable Metrics/AbcSize
+
+      def matches(ext, convertible)
+        return true if convertible.render_with_liquid?
+
+        super(ext)
+      end
+
+      def output_ext(ext)
+        ext == ".liquid" ? ".html" : ext
+      end
+
+      # Fetches the payload used in Liquid rendering.
+      # Falls back to site.site_payload if no payload is set.
+      #
+      # Returns a Bridgetown::Drops::UnifiedPayloadDrop
+      def payload
+        @payload ||= site.site_payload
+      end
+
+      # Set page content to payload and assign paginator if document has one.
+      #
+      # Returns nothing
+      def configure_payload(content = nil)
+        payload["page"] = document.to_liquid
+        payload["paginator"] = document.respond_to?(:paginator) ? document.paginator.to_liquid : nil
+        payload["layout"] = @layout ? @layout.data : {}
+        payload["content"] = content
+      end
+
+      def liquid_context
+        {
+          registers: {
+            site: site,
+            page: payload["page"],
+            cached_partials: self.class.cached_partials,
+          },
+          strict_filters: site.config["liquid"]["strict_filters"],
+          strict_variables: site.config["liquid"]["strict_variables"],
+        }
+      end
+    end
+  end
+end

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

@@ -5,9 +5,6 @@ module Bridgetown
     # Markdown converter.
     # For more info on converters see https://bridgetownrb.com/docs/plugins/converters/
     class Markdown < Converter
-      highlighter_prefix "\n"
-      highlighter_suffix "\n"
-
       def initialize(config = {})
         super
 

data/lib/bridgetown-core/document.rb

@@ -330,24 +330,6 @@ module Bridgetown
       data.key?(method.to_s) || super
     end
 
-    def populate_categories
-      categories = Array(data["categories"]) + Utils.pluralized_array_from_hash(
-        data, "category", "categories"
-      )
-      categories.map!(&:to_s)
-      categories.flatten!
-      categories.uniq!
-
-      merge_data!({ "categories" => categories })
-    end
-
-    def populate_tags
-      tags = Utils.pluralized_array_from_hash(data, "tag", "tags")
-      tags.flatten!
-
-      merge_data!({ "tags" => tags })
-    end
-
     private
 
     def merge_categories!(other)
@@ -384,6 +366,7 @@ module Bridgetown
       populate_title
       populate_categories
       populate_tags
+      determine_locale
       generate_excerpt
     end
 
@@ -418,6 +401,36 @@ module Bridgetown
       data["ext"]   ||= ext
     end
 
+    def populate_categories
+      categories = Array(data["categories"]) + Utils.pluralized_array_from_hash(
+        data, "category", "categories"
+      )
+      categories.map!(&:to_s)
+      categories.flatten!
+      categories.uniq!
+
+      merge_data!({ "categories" => categories })
+    end
+
+    def populate_tags
+      tags = Utils.pluralized_array_from_hash(data, "tag", "tags")
+      tags.flatten!
+
+      merge_data!({ "tags" => tags })
+    end
+
+    def determine_locale
+      unless data["locale"]
+        # if locale key isn't directly set, look for alternative front matter
+        # or look at the filename pattern: slug.locale.ext
+        alernative = data["language"] || data["lang"] ||
+          basename_without_ext.split(".")[1..-1].last
+
+        data["locale"] = alernative if !alernative.nil? &&
+          site.config[:available_locales].include?(alernative)
+      end
+    end
+
     def modify_date(date)
       if !data["date"] || data["date"].to_i == site.time.to_i
         merge_data!({ "date" => date }, source: "filename")

data/lib/bridgetown-core/drops/site_drop.rb

@@ -50,6 +50,10 @@ module Bridgetown
         @documents ||= @obj.documents
       end
 
+      def contents
+        @contents ||= @obj.contents
+      end
+
       def metadata
         @site_metadata ||= @obj.data["site_metadata"]
       end

data/lib/bridgetown-core/drops/unified_payload_drop.rb

@@ -6,7 +6,6 @@ module Bridgetown
       mutable true
 
       attr_accessor :page, :layout, :content, :paginator
-      attr_accessor :highlighter_prefix, :highlighter_suffix
 
       def bridgetown
         BridgetownDrop.global

data/lib/bridgetown-core/drops/url_drop.rb

@@ -19,14 +19,19 @@ module Bridgetown
       end
 
       def title
-        Utils.slugify(@obj.data["slug"], mode: "pretty", cased: true) ||
-          Utils.slugify(@obj.basename_without_ext, mode: "pretty", cased: true)
+        Utils.slugify(qualified_slug_data, mode: "pretty", cased: true)
       end
 
       def slug
-        Utils.slugify(@obj.data["slug"]) || Utils.slugify(@obj.basename_without_ext)
+        Utils.slugify(qualified_slug_data)
       end
 
+      def locale
+        locale_data = @obj.data["locale"]
+        @obj.site.config["available_locales"].include?(locale_data) ? locale_data : nil
+      end
+      alias_method :lang, :locale
+
       def categories
         category_set = Set.new
         Array(@obj.data["categories"]).each do |category|
@@ -128,6 +133,17 @@ module Bridgetown
 
       private
 
+      def qualified_slug_data
+        slug_data = @obj.data["slug"] || @obj.basename_without_ext
+        if @obj.data["locale"]
+          slug_data.split(".").tap do |segments|
+            segments.pop if segments.length > 1 && segments.last == @obj.data["locale"]
+          end.join(".")
+        else
+          slug_data
+        end
+      end
+
       def fallback_data
         @fallback_data ||= {}
       end

data/lib/bridgetown-core/excerpt.rb

@@ -83,7 +83,7 @@ module Bridgetown
 
     def output
       @output || (
-        Renderer.new(doc.site, self, site.site_payload).run
+        Renderer.new(doc.site, self).run
         @output
       )
     end

data/lib/bridgetown-core/filters.rb

@@ -79,16 +79,15 @@ module Bridgetown
     # XML escape a string for use. Replaces any special characters with
     # appropriate HTML entity replacements.
     #
-    # input - The String to escape.
-    #
     # Examples
     #
     #   xml_escape('foo "bar" <baz>')
     #   # => "foo &quot;bar&quot; &lt;baz&gt;"
     #
-    # Returns the escaped String.
+    # @param input [String] The String to escape.
+    # @return [String] the escaped String.
     def xml_escape(input)
-      input.to_s.encode(xml: :attr).gsub(%r!\A"|"\Z!, "")
+      Utils.xml_escape(input)
     end
 
     # CGI escape a string for use in a URL. Replaces any special characters
@@ -120,6 +119,21 @@ module Bridgetown
       Addressable::URI.normalize_component(input)
     end
 
+    # Obfuscate an email, telephone number etc.
+    #
+    # @param input[String] the String containing the contact information (email, phone etc.)
+    # @param prefix[String] the URL scheme to prefix (default "mailto")
+    # @return [String] a link unreadable for bots but will be recovered on focus or mouseover
+    def obfuscate_link(input, prefix = "mailto")
+      link = "<a href=\"#{prefix}:#{input}\">#{input}</a>"
+      script = "<script type=\"text/javascript\">document.currentScript.insertAdjacentHTML("
+      script += "beforebegin', '#{rot47(link)}'.replace(/[!-~]/g,"
+      script += "function(c){{var j=c.charCodeAt(0);if((j>=33)&&(j<=126)){"
+      script += "return String.fromCharCode(33+((j+ 14)%94));}"
+      script += "else{return String.fromCharCode(j);}}}));</script>"
+      script
+    end
+
     # Replace any whitespace in the input string with a single space
     #
     # input - The String on which to operate.
@@ -316,15 +330,22 @@ module Bridgetown
 
     # Convert an object into its String representation for debugging
     #
-    # input - The Object to be converted
+    # @param input [Object] The Object to be converted
     #
-    # Returns a String representation of the object.
-    def inspect(input)
+    # @return [String] the representation of the object.
+    def inspect(input = nil)
+      return super() if input.nil?
+
       xml_escape(input.inspect)
     end
 
     private
 
+    # Perform a rot47 rotation for obfuscation
+    def rot47(input)
+      input.tr "!-~", "P-~!-O"
+    end
+
     # Sort the input Enumerable by the given property.
     # If the property doesn't exist, return the sort order respective of
     # which item doesn't have the property.

data/lib/bridgetown-core/generators/prototype_generator.rb

@@ -10,6 +10,9 @@ module Bridgetown
   class PrototypeGenerator < Generator
     priority :low
 
+    # @return [Bridgetown::Site]
+    attr_reader :site
+
     @matching_templates = []
 
     def self.add_matching_template(template)
@@ -17,6 +20,7 @@ module Bridgetown
     end
 
     class << self
+      # @return [Array<Page>]
       attr_reader :matching_templates
     end
 
@@ -44,7 +48,13 @@ module Bridgetown
       end
     end
 
+    # Check incoming prototype configuration and normalize options.
+    #
+    # @param prototype_page [PrototypePage]
+    #
+    # @return [String, nil]
     def validate_search_term(prototype_page)
+      # @type [String]
       search_term = prototype_page.data["prototype"]["term"]
       return nil unless search_term.is_a?(String)
 
@@ -52,6 +62,8 @@ module Bridgetown
         @configured_collection = prototype_page.data["prototype"]["collection"]
       end
 
+      return nil unless site.collections[@configured_collection]
+
       # Categories and Tags are unique in that singular and plural front matter
       # can be present for each
       search_term.sub(%r!^category$!, "categories").sub(%r!^tag$!, "tags")
@@ -59,71 +71,75 @@ module Bridgetown
 
     def generate_new_page_from_prototype(prototype_page, search_term, term)
       new_page = PrototypePage.new(prototype_page, @configured_collection, search_term, term)
-      @site.pages << new_page
+      site.pages << new_page
       new_page
     end
 
-    # TODO: this would be a great use of .try
-    # document.try(:collection).try(:label) == @configured_collection
+    # Provide a list of all relevent indexed values for the given term.
+    #
+    # @param search_term [String]
+    #
+    # @return [Array<String>]
     def terms_matching_pages(search_term)
-      selected_docs = @site.documents.select do |document|
-        document.respond_to?(:collection) && document.collection.label == @configured_collection
-      end
-
       Bridgetown::Paginate::PaginationIndexer.index_documents_by(
-        selected_docs, search_term
+        site.collections[@configured_collection].docs, search_term
       ).keys
     end
   end
 
   class PrototypePage < Page
-    def initialize(prototype_page, collection, search_term, term)
-      @site = prototype_page.site
+    # @return [Page]
+    attr_reader :prototyped_page
+
+    def initialize(prototyped_page, collection, search_term, term)
+      @prototyped_page = prototyped_page
+      @site = prototyped_page.site
       @url = ""
       @name = "index.html"
-      @path = prototype_page.path
+      @path = prototyped_page.path
 
       process(@name)
 
-      self.data = Bridgetown::Utils.deep_merge_hashes prototype_page.data, {}
-      self.content = prototype_page.content
+      self.data = Bridgetown::Utils.deep_merge_hashes prototyped_page.data, {}
+      self.content = prototyped_page.content
 
       # Perform some validation that is also performed in Bridgetown::Page
-      validate_data! prototype_page.path
-      validate_permalink! prototype_page.path
+      validate_data! prototyped_page.path
+      validate_permalink! prototyped_page.path
 
-      @dir = Pathname.new(prototype_page.relative_path).dirname.to_s
+      @dir = Pathname.new(prototyped_page.relative_path).dirname.to_s
       @path = site.in_source_dir(@dir, @name)
 
-      process_prototype_page_data(prototype_page, collection, search_term, term)
+      process_prototype_page_data(collection, search_term, term)
 
       Bridgetown::Hooks.trigger :pages, :post_init, self
     end
 
-    def process_prototype_page_data(prototype_page, collection, search_term, term)
+    def process_prototype_page_data(collection, search_term, term)
       # Fill in pagination details to be handled later by Bridgetown::Paginate
       data["pagination"] = Bridgetown::Utils.deep_merge_hashes(
-        prototype_page.data["pagination"].to_h, {
+        prototyped_page.data["pagination"].to_h, {
           "enabled"     => true,
           "collection"  => collection,
           "where_query" => [search_term, term],
         }
       )
       # Use the original prototype page term so we get "tag" back, not "tags":
-      data[prototype_page.data["prototype"]["term"]] = term
+      data[prototyped_page.data["prototype"]["term"]] = term
       # Process title and slugs/URLs:
-      process_title_data_placeholder(prototype_page, search_term, term)
+      process_title_data_placeholder(search_term, term)
       process_title_simple_placeholders(term)
       slugify_term(term)
     end
 
-    def process_title_data_placeholder(prototype_page, search_term, term)
-      if prototype_page["prototype"]["data"]
+    # rubocop:disable Metrics/AbcSize
+    def process_title_data_placeholder(search_term, term)
+      if prototyped_page.data["prototype"]["data"]
         if data["title"]&.include?(":prototype-data-label")
-          related_data = @site.data[prototype_page["prototype"]["data"]].dig(term)
+          related_data = site.data[prototyped_page.data["prototype"]["data"]].dig(term)
           if related_data
             data["#{search_term}_data"] = related_data
-            data_label = related_data[prototype_page["prototype"]["data_label"]]
+            data_label = related_data[prototyped_page.data["prototype"]["data_label"]]
             data["title"] = data["title"].gsub(
               ":prototype-data-label", data_label
             )
@@ -131,6 +147,7 @@ module Bridgetown
         end
       end
     end
+    # rubocop:enable Metrics/AbcSize
 
     def process_title_simple_placeholders(term)
       if data["title"]&.include?(":prototype-term-titleize")