bridgetown-core 0.16.0 → 0.18.2

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

@@ -63,7 +63,7 @@ module Bridgetown
     # Returns a Hash containing the data. An empty hash is returned if
     #   no data was read.
     def data
-      @data ||= ActiveSupport::HashWithIndifferentAccess.new
+      @data ||= HashWithDotAccess::Hash.new
     end
 
     # Merge some data in with this document's data.
@@ -170,7 +170,7 @@ module Bridgetown
     #
     # Returns the permalink or nil if no permalink was set in the data.
     def permalink
-      data && data.is_a?(Hash) && data["permalink"]
+      data&.permalink
     end
 
     # The computed URL for the document. See `Bridgetown::URL#to_s` for more details.
@@ -295,7 +295,7 @@ module Bridgetown
 
     def previous_doc
       pos = collection.docs.index { |post| post.equal?(self) }
-      collection.docs[pos - 1] if pos && pos.positive?
+      collection.docs[pos - 1] if pos&.positive?
     end
 
     def trigger_hooks(hook_name, *args)
@@ -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

@@ -8,7 +8,7 @@ module Bridgetown
       mutable false
 
       def_delegator  :@obj, :data
-      def_delegators :@obj, :time, :pages, :static_files, :tags, :categories
+      def_delegators :@obj, :locale, :time, :pages, :static_files, :tags, :categories
 
       private def_delegator :@obj, :config, :fallback_data
 
@@ -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

@@ -7,6 +7,7 @@ module Bridgetown
     include URLFilters
     include GroupingFilters
     include DateFilters
+    include ConditionHelpers
 
     # Convert a Markdown string into HTML output.
     #
@@ -78,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
@@ -119,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.
@@ -137,6 +152,14 @@ module Bridgetown
       input.split.length
     end
 
+    # Calculates the average reading time of the supplied content.
+    # @param input [String] the String of content to analyze.
+    # @return [Float] the number of minutes required to read the content.
+    def reading_time(input, round_to = 0)
+      wpm = @context.registers[:site].config[:reading_time_wpm] || 250
+      (number_of_words(input).to_f / wpm).ceil(round_to)
+    end
+
     # Join an array of things into a string by separating with commas and the
     # word "and" for the last one.
     #
@@ -307,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.
@@ -423,54 +453,6 @@ module Bridgetown
         end
       end
     end
-
-    # -----------   The following set of code was *adapted* from Liquid::If
-    # -----------   ref: https://git.io/vp6K6
-
-    # Parse a string to a Liquid Condition
-    def parse_condition(exp)
-      parser    = Liquid::Parser.new(exp)
-      condition = parse_binary_comparison(parser)
-
-      parser.consume(:end_of_string)
-      condition
-    end
-
-    # Generate a Liquid::Condition object from a Liquid::Parser object additionally processing
-    # the parsed expression based on whether the expression consists of binary operations with
-    # Liquid operators `and` or `or`
-    #
-    #  - parser: an instance of Liquid::Parser
-    #
-    # Returns an instance of Liquid::Condition
-    def parse_binary_comparison(parser)
-      condition = parse_comparison(parser)
-      first_condition = condition
-      while (binary_operator = parser.id?("and") || parser.id?("or"))
-        child_condition = parse_comparison(parser)
-        condition.send(binary_operator, child_condition)
-        condition = child_condition
-      end
-      first_condition
-    end
-
-    # Generates a Liquid::Condition object from a Liquid::Parser object based on whether the parsed
-    # expression involves a "comparison" operator (e.g. <, ==, >, !=, etc)
-    #
-    #  - parser: an instance of Liquid::Parser
-    #
-    # Returns an instance of Liquid::Condition
-    def parse_comparison(parser)
-      left_operand = Liquid::Expression.parse(parser.expression)
-      operator     = parser.consume?(:comparison)
-
-      # No comparison-operator detected. Initialize a Liquid::Condition using only left operand
-      return Liquid::Condition.new(left_operand) unless operator
-
-      # Parse what remained after extracting the left operand and the `:comparison` operator
-      # and initialize a Liquid::Condition object using the operands and the comparison-operator
-      Liquid::Condition.new(left_operand, operator, Liquid::Expression.parse(parser.expression))
-    end
   end
 end
 

data/lib/bridgetown-core/filters/condition_helpers.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Filters
+    module ConditionHelpers
+      # -----------   The following set of code was *adapted* from Liquid::If
+      # -----------   ref: https://git.io/vp6K6
+
+      # Parse a string to a Liquid Condition
+      def parse_condition(exp)
+        parser    = Liquid::Parser.new(exp)
+        condition = parse_binary_comparison(parser)
+
+        parser.consume(:end_of_string)
+        condition
+      end
+
+      # Generate a Liquid::Condition object from a Liquid::Parser object additionally processing
+      # the parsed expression based on whether the expression consists of binary operations with
+      # Liquid operators `and` or `or`
+      #
+      #  - parser: an instance of Liquid::Parser
+      #
+      # Returns an instance of Liquid::Condition
+      def parse_binary_comparison(parser)
+        condition = parse_comparison(parser)
+        first_condition = condition
+        while (binary_operator = parser.id?("and") || parser.id?("or"))
+          child_condition = parse_comparison(parser)
+          condition.send(binary_operator, child_condition)
+          condition = child_condition
+        end
+        first_condition
+      end
+
+      # Generates a Liquid::Condition object from a Liquid::Parser object based
+      # on whether the parsed expression involves a "comparison" operator
+      # (e.g. <, ==, >, !=, etc)
+      #
+      #  - parser: an instance of Liquid::Parser
+      #
+      # Returns an instance of Liquid::Condition
+      def parse_comparison(parser)
+        left_operand = Liquid::Expression.parse(parser.expression)
+        operator     = parser.consume?(:comparison)
+
+        # No comparison-operator detected. Initialize a Liquid::Condition using only left operand
+        return Liquid::Condition.new(left_operand) unless operator
+
+        # Parse what remained after extracting the left operand and the `:comparison` operator
+        # and initialize a Liquid::Condition object using the operands and the comparison-operator
+        Liquid::Condition.new(left_operand, operator, Liquid::Expression.parse(parser.expression))
+      end
+    end
+  end
+end