bridgetown-core 0.7.0 → 0.7.1

data/lib/bridgetown-core/converter.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  class Converter < Plugin
+    # Public: Get or set the highlighter prefix. When an argument is specified,
+    # the prefix will be set. If no argument is specified, the current prefix
+    # will be returned.
+    #
+    # highlighter_prefix - The String prefix (default: nil).
+    #
+    # Returns the String prefix.
+    def self.highlighter_prefix(highlighter_prefix = nil)
+      unless defined?(@highlighter_prefix) && highlighter_prefix.nil?
+        @highlighter_prefix = highlighter_prefix
+      end
+      @highlighter_prefix
+    end
+
+    # Public: Get or set the highlighter suffix. When an argument is specified,
+    # the suffix will be set. If no argument is specified, the current suffix
+    # will be returned.
+    #
+    # highlighter_suffix - The String suffix (default: nil).
+    #
+    # Returns the String suffix.
+    def self.highlighter_suffix(highlighter_suffix = nil)
+      unless defined?(@highlighter_suffix) && highlighter_suffix.nil?
+        @highlighter_suffix = highlighter_suffix
+      end
+      @highlighter_suffix
+    end
+
+    # Initialize the converter.
+    #
+    # Returns an initialized Converter.
+    def initialize(config = {})
+      @config = config
+    end
+
+    # Get the highlighter prefix.
+    #
+    # Returns the String prefix.
+    def highlighter_prefix
+      self.class.highlighter_prefix
+    end
+
+    # Get the highlighter suffix.
+    #
+    # Returns the String suffix.
+    def highlighter_suffix
+      self.class.highlighter_suffix
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Converters
+    # Identity converter. Returns same content as given.
+    # For more info on converters see https://bridgetownrb.com/docs/plugins/converters/
+    class Identity < Converter
+      priority :lowest
+
+      # Public: Does the given extension match this converter's list of acceptable extensions?
+      # Takes one argument: the file's extension (including the dot).
+      #
+      # _ext - The String extension to check (not relevant here)
+      #
+      # Returns true since it always matches.
+      def matches(_ext)
+        true
+      end
+
+      # Public: The extension to be given to the output file (including the dot).
+      #
+      # ext - The String extension or original file.
+      #
+      # Returns The String output file extension.
+      def output_ext(ext)
+        ext
+      end
+
+      # Logic to do the content conversion.
+      #
+      # content - String content of file (without front matter).
+      #
+      # Returns a String of the converted content.
+      def convert(content)
+        content
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Converters
+    # Markdown converter.
+    # For more info on converters see https://bridgetownrb.com/docs/plugins/converters/
+    class Markdown < Converter
+      highlighter_prefix "\n"
+      highlighter_suffix "\n"
+
+      def setup
+        return if @setup ||= false
+
+        unless (@parser = get_processor)
+          Bridgetown.logger.error "Markdown processor:", "#{@config["markdown"].inspect} \
+                                  is not a valid Markdown processor."
+          Bridgetown.logger.error "", "Available processors are: #{valid_processors.join(", ")}"
+          Bridgetown.logger.error ""
+          raise Errors::FatalException, "Invalid Markdown processor given: #{@config["markdown"]}"
+        end
+
+        @cache = Bridgetown::Cache.new("Bridgetown::Converters::Markdown")
+        @setup = true
+      end
+
+      # RuboCop does not allow reader methods to have names starting with `get_`
+      # To ensure compatibility, this check has been disabled on this method
+      #
+      # rubocop:disable Naming/AccessorMethodName
+      def get_processor
+        case @config["markdown"].downcase
+        when "kramdown" then KramdownParser.new(@config)
+        else
+          custom_processor
+        end
+      end
+      # rubocop:enable Naming/AccessorMethodName
+
+      # Public: Provides you with a list of processors comprised of the ones we support internally
+      # and the ones that you have provided to us
+      #
+      # Returns an array of symbols.
+      def valid_processors
+        [:kramdown] + third_party_processors
+      end
+
+      # Public: A list of processors that you provide via plugins.
+      #
+      # Returns an array of symbols
+      def third_party_processors
+        self.class.constants - [:KramdownParser, :PRIORITIES]
+      end
+
+      # Does the given extension match this converter's list of acceptable extensions?
+      # Takes one argument: the file's extension (including the dot).
+      #
+      # ext - The String extension to check.
+      #
+      # Returns true if it matches, false otherwise.
+      def matches(ext)
+        extname_list.include?(ext.downcase)
+      end
+
+      # Public: The extension to be given to the output file (including the dot).
+      #
+      # ext - The String extension or original file.
+      #
+      # Returns The String output file extension.
+      def output_ext(_ext)
+        ".html"
+      end
+
+      # Logic to do the content conversion.
+      #
+      # content - String content of file (without front matter).
+      #
+      # Returns a String of the converted content.
+      def convert(content)
+        setup
+        @cache.getset(content) do
+          @parser.convert(content)
+        end
+      end
+
+      def extname_list
+        @extname_list ||= @config["markdown_ext"].split(",").map! { |e| ".#{e.downcase}" }
+      end
+
+      private
+
+      def custom_processor
+        converter_name = @config["markdown"]
+        self.class.const_get(converter_name).new(@config) if custom_class_allowed?(converter_name)
+      end
+
+      # Private: Determine whether a class name is an allowed custom
+      #   markdown class name.
+      #
+      # parser_name - the name of the parser class
+      #
+      # Returns true if the parser name contains only alphanumeric characters and is defined
+      # within Bridgetown::Converters::Markdown
+      def custom_class_allowed?(parser_name)
+        parser_name !~ %r![^A-Za-z0-9_]! && self.class.constants.include?(parser_name.to_sym)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,132 @@
+# Frozen-string-literal: true
+
+module Kramdown
+  # A Kramdown::Document subclass meant to optimize memory usage from initializing
+  # a kramdown document for parsing.
+  #
+  # The optimization is by using the same options Hash (and its derivatives) for
+  # converting all Markdown documents in a Bridgetown site.
+  class BridgetownDocument < Document
+    class << self
+      attr_reader :options, :parser
+
+      # The implementation is basically the core logic in +Kramdown::Document#initialize+
+      #
+      # rubocop:disable Naming/MemoizedInstanceVariableName
+      def setup(options)
+        @cache ||= {}
+
+        # reset variables on a subsequent set up with a different options Hash
+        unless @cache[:id] == options.hash
+          @options = @parser = nil
+          @cache[:id] = options.hash
+        end
+
+        @options ||= Options.merge(options).freeze
+        @parser  ||= begin
+          parser_name = (@options[:input] || "kramdown").to_s
+          parser_name = parser_name[0..0].upcase + parser_name[1..-1]
+          try_require("parser", parser_name)
+
+          if Parser.const_defined?(parser_name)
+            Parser.const_get(parser_name)
+          else
+            raise Kramdown::Error, "kramdown has no parser to handle the specified " \
+                                   "input format: #{@options[:input]}"
+          end
+        end
+      end
+      # rubocop:enable Naming/MemoizedInstanceVariableName
+
+      private
+
+      def try_require(type, name)
+        require "kramdown/#{type}/#{Utils.snake_case(name)}"
+      rescue LoadError
+        false
+      end
+    end
+
+    def initialize(source, options = {})
+      BridgetownDocument.setup(options)
+
+      @options = BridgetownDocument.options
+      @root, @warnings = BridgetownDocument.parser.parse(source, @options)
+    end
+
+    # Use Kramdown::Converter::Html class to convert this document into HTML.
+    #
+    # The implementation is basically an optimized version of core logic in
+    # +Kramdown::Document#method_missing+ from kramdown-2.1.0.
+    def to_html
+      output, warnings = Kramdown::Converter::Html.convert(@root, @options)
+      @warnings.concat(warnings)
+      output
+    end
+  end
+end
+
+#
+
+module Bridgetown
+  module Converters
+    class Markdown
+      class KramdownParser
+        def initialize(config)
+          @main_fallback_highlighter = config["highlighter"] || "rouge"
+          @config = config["kramdown"] || {}
+          @highlighter = nil
+          setup
+          load_dependencies
+        end
+
+        # Setup and normalize the configuration:
+        #   * Create Kramdown if it doesn't exist.
+        #   * Set syntax_highlighter
+        #   * Make sure `syntax_highlighter_opts` exists.
+        def setup
+          @config["syntax_highlighter"] ||= highlighter
+          @config["syntax_highlighter_opts"] ||= {}
+          @config["syntax_highlighter_opts"]["guess_lang"] = @config["guess_lang"]
+        end
+
+        def convert(content)
+          document = Kramdown::BridgetownDocument.new(content, @config)
+          html_output = document.to_html
+          if @config["show_warnings"]
+            document.warnings.each do |warning|
+              Bridgetown.logger.warn "Kramdown warning:", warning
+            end
+          end
+          html_output
+        end
+
+        private
+
+        def load_dependencies
+          require "kramdown-parser-gfm" if @config["input"] == "GFM"
+
+          # `mathjax` emgine is bundled within kramdown-2.x and will be handled by
+          # kramdown itself.
+          if (math_engine = @config["math_engine"]) && math_engine != "mathjax"
+            Bridgetown::External.require_with_graceful_fail("kramdown-math-#{math_engine}")
+          end
+        end
+
+        # config[kramdown][syntax_higlighter] >
+        #   config[highlighter]
+        def highlighter
+          return @highlighter if @highlighter
+
+          if @config["syntax_highlighter"]
+            return @highlighter = @config[
+              "syntax_highlighter"
+            ]
+          end
+
+          @highlighter = @main_fallback_highlighter
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Kramdown
+  module Parser
+    class SmartyPants < Kramdown::Parser::Kramdown
+      def initialize(source, options)
+        super
+        @block_parsers = [:block_html, :content]
+        @span_parsers =  [:smart_quotes, :html_entity, :typographic_syms, :span_html]
+      end
+
+      def parse_content
+        add_text @src.scan(%r!\A.*\n!)
+      end
+      define_parser(:content, %r!\A!)
+    end
+  end
+end
+
+module Bridgetown
+  module Converters
+    # SmartyPants converter.
+    # For more info on converters see https://bridgetownrb.com/docs/plugins/converters/
+    class SmartyPants < Converter
+      priority :low
+
+      def initialize(config)
+        Bridgetown::External.require_with_graceful_fail "kramdown" unless defined?(Kramdown)
+        @config = config["kramdown"].dup || {}
+        @config[:input] = :SmartyPants
+      end
+
+      # Does the given extension match this converter's list of acceptable extensions?
+      # Takes one argument: the file's extension (including the dot).
+      #
+      # ext - The String extension to check.
+      #
+      # Returns true if it matches, false otherwise.
+      def matches(_ext)
+        false
+      end
+
+      # Public: The extension to be given to the output file (including the dot).
+      #
+      # ext - The String extension or original file.
+      #
+      # Returns The String output file extension.
+      def output_ext(_ext)
+        nil
+      end
+
+      # Logic to do the content conversion.
+      #
+      # content - String content of file (without front matter).
+      #
+      # Returns a String of the converted content.
+      def convert(content)
+        document = Kramdown::Document.new(content, @config)
+        html_output = document.to_html.chomp
+        if @config["show_warnings"]
+          document.warnings.each do |warning|
+            Bridgetown.logger.warn "Kramdown warning:", warning.sub(%r!^Warning:\s+!, "")
+          end
+        end
+        html_output
+      end
+    end
+  end
+end

data/lib/bridgetown-core/convertible.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+# Convertible provides methods for converting a pagelike item
+# from a certain type of markup into actual content
+#
+# Requires
+#   self.site -> Bridgetown::Site
+#   self.content
+#   self.content=
+#   self.data=
+#   self.ext=
+#   self.output=
+#   self.name
+#   self.path
+#   self.type -> :page or :post
+
+module Bridgetown
+  module Convertible
+    # Returns the contents as a String.
+    def to_s
+      content || ""
+    end
+
+    # Whether the file is published or not, as indicated in YAML front-matter
+    def published?
+      !(data.key?("published") && data["published"] == false)
+    end
+
+    # Read the YAML frontmatter.
+    #
+    # base - The String path to the dir containing the file.
+    # name - The String filename of the file.
+    # opts - optional parameter to File.read, default at site configs
+    #
+    # Returns nothing.
+    # rubocop:disable Metrics/AbcSize
+    def read_yaml(base, name, opts = {})
+      filename = File.join(base, name)
+
+      begin
+        self.content = File.read(@path || site.in_source_dir(base, name),
+                                 **Utils.merged_file_read_opts(site, opts))
+        if content =~ Document::YAML_FRONT_MATTER_REGEXP
+          self.content = $POSTMATCH
+          self.data = SafeYAML.load(Regexp.last_match(1))
+        end
+      rescue Psych::SyntaxError => e
+        Bridgetown.logger.warn "YAML Exception reading #{filename}: #{e.message}"
+        raise e if site.config["strict_front_matter"]
+      rescue StandardError => e
+        Bridgetown.logger.warn "Error reading file #{filename}: #{e.message}"
+        raise e if site.config["strict_front_matter"]
+      end
+
+      self.data ||= {}
+
+      validate_data! filename
+      validate_permalink! filename
+
+      self.data
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def validate_data!(filename)
+      unless self.data.is_a?(Hash)
+        raise Errors::InvalidYAMLFrontMatterError,
+              "Invalid YAML front matter in #{filename}"
+      end
+    end
+
+    def validate_permalink!(filename)
+      if self.data["permalink"]&.to_s&.empty?
+        raise Errors::InvalidPermalinkError, "Invalid permalink in #{filename}"
+      end
+    end
+
+    # Transform the contents based on the content type.
+    #
+    # Returns the transformed contents.
+    def transform
+      _renderer.convert(content)
+    end
+
+    # Determine the extension depending on content_type.
+    #
+    # Returns the String extension for the output file.
+    #   e.g. ".html" for an HTML output file.
+    def output_ext
+      _renderer.output_ext
+    end
+
+    # Determine which converter to use based on this convertible's
+    # extension.
+    #
+    # Returns the Converter instance.
+    def converters
+      _renderer.converters
+    end
+
+    # Render Liquid in the content
+    #
+    # content - the raw Liquid content to render
+    # payload - the payload for Liquid
+    # info    - the info for Liquid
+    #
+    # Returns the converted content
+    def render_liquid(content, payload, info, path)
+      _renderer.render_liquid(content, payload, info, path)
+    end
+
+    # Convert this Convertible's data to a Hash suitable for use by Liquid.
+    #
+    # Returns the Hash representation of this Convertible.
+    def to_liquid(attrs = nil)
+      further_data = \
+        (attrs || self.class::ATTRIBUTES_FOR_LIQUID).each_with_object({}) do |attribute, hsh|
+          hsh[attribute] = send(attribute)
+        end
+
+      defaults = site.frontmatter_defaults.all(relative_path, type)
+      Utils.deep_merge_hashes defaults, Utils.deep_merge_hashes(data, further_data)
+    end
+
+    # The type of a document,
+    #   i.e., its classname downcase'd and to_sym'd.
+    #
+    # Returns the type of self.
+    def type
+      :pages if is_a?(Page)
+    end
+
+    # returns the owner symbol for hook triggering
+    def hook_owner
+      :pages if is_a?(Page)
+    end
+
+    # TODO: Depricated
+    # Used to determine CoffeeScript and Sass/SCSS files.
+    def asset_file?
+      false
+    end
+
+    # Determine whether the file should be rendered with Liquid.
+    #
+    # Returns true if the file has Liquid Tags or Variables, false otherwise.
+    def render_with_liquid?
+      return false if data["render_with_liquid"] == false
+
+      Bridgetown::Utils.has_liquid_construct?(content)
+    end
+
+    # Determine whether the file should be placed into layouts.
+    #
+    # Returns false if the document is an asset file or if the front matter
+    #   specifies `layout: none`
+    def place_in_layout?
+      !(asset_file? || no_layout?)
+    end
+
+    # Checks if the layout specified in the document actually exists
+    #
+    # layout - the layout to check
+    #
+    # Returns true if the layout is invalid, false if otherwise
+    def invalid_layout?(layout)
+      !data["layout"].nil? && layout.nil? && !(is_a? Bridgetown::Excerpt)
+    end
+
+    # Recursively render layouts
+    #
+    # layouts - a list of the layouts
+    # payload - the payload for Liquid
+    # info    - the info for Liquid
+    #
+    # Returns nothing
+    def render_all_layouts(layouts, payload, info)
+      _renderer.layouts = layouts
+      self.output = _renderer.place_in_layouts(output, payload, info)
+    ensure
+      @_renderer = nil # this will allow the modifications above to disappear
+    end
+
+    # Add any necessary layouts to this convertible document.
+    #
+    # payload - The site payload Drop or Hash.
+    # layouts - A Hash of {"name" => "layout"}.
+    #
+    # Returns nothing.
+    def do_layout(payload, layouts)
+      self.output = _renderer.tap do |renderer|
+        renderer.layouts = layouts
+        renderer.payload = payload
+      end.run
+
+      Bridgetown.logger.debug "Post-Render Hooks:", relative_path
+      Bridgetown::Hooks.trigger hook_owner, :post_render, self
+    ensure
+      @_renderer = nil # this will allow the modifications above to disappear
+    end
+
+    # Write the generated page file to the destination directory.
+    #
+    # dest - The String path to the destination dir.
+    #
+    # Returns nothing.
+    def write(dest)
+      path = destination(dest)
+      FileUtils.mkdir_p(File.dirname(path))
+      Bridgetown.logger.debug "Writing:", path
+      File.write(path, output, :mode => "wb")
+      Bridgetown::Hooks.trigger hook_owner, :post_write, self
+    end
+
+    # Accessor for data properties by Liquid.
+    #
+    # property - The String name of the property to retrieve.
+    #
+    # Returns the String value or nil if the property isn't included.
+    def [](property)
+      if self.class::ATTRIBUTES_FOR_LIQUID.include?(property)
+        send(property)
+      else
+        data[property]
+      end
+    end
+
+    private
+
+    def _renderer
+      @_renderer ||= Bridgetown::Renderer.new(site, self)
+    end
+
+    def no_layout?
+      data["layout"] == "none"
+    end
+  end
+end