bridgetown-core 0.7.0 → 0.7.1

data/lib/bridgetown-core/static_file.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  class StaticFile
+    extend Forwardable
+
+    attr_reader :relative_path, :extname, :name, :data
+
+    def_delegator :to_liquid, :to_json, :to_json
+
+    class << self
+      # The cache of last modification times [path] -> mtime.
+      def mtimes
+        @mtimes ||= {}
+      end
+
+      def reset_cache
+        @mtimes = nil
+      end
+    end
+
+    # Initialize a new StaticFile.
+    #
+    # site - The Site.
+    # base - The String path to the <source>.
+    # dir  - The String path between <source> and the file.
+    # name - The String filename of the file.
+    # rubocop: disable Metrics/ParameterLists
+    def initialize(site, base, dir, name, collection = nil)
+      @site = site
+      @base = base
+      @dir  = dir
+      @name = name
+      @collection = collection
+      @relative_path = File.join(*[@dir, @name].compact)
+      @extname = File.extname(@name)
+      @data = @site.frontmatter_defaults.all(relative_path, type)
+    end
+    # rubocop: enable Metrics/ParameterLists
+
+    # Returns source file path.
+    def path
+      @path ||= begin
+        # Static file is from a collection inside custom collections directory
+        if !@collection.nil? && !@site.config["collections_dir"].empty?
+          File.join(*[@base, @site.config["collections_dir"], @dir, @name].compact)
+        else
+          File.join(*[@base, @dir, @name].compact)
+        end
+      end
+    end
+
+    # Obtain destination path.
+    #
+    # dest - The String path to the destination dir.
+    #
+    # Returns destination file path.
+    def destination(dest)
+      dest = @site.in_dest_dir(dest)
+      @site.in_dest_dir(dest, Bridgetown::URL.unescape_path(url))
+    end
+
+    def destination_rel_dir
+      if @collection
+        File.dirname(url)
+      else
+        @dir
+      end
+    end
+
+    def modified_time
+      @modified_time ||= File.stat(path).mtime
+    end
+
+    # Returns last modification time for this file.
+    def mtime
+      modified_time.to_i
+    end
+
+    # Is source path modified?
+    #
+    # Returns true if modified since last write.
+    def modified?
+      self.class.mtimes[path] != mtime
+    end
+
+    # Whether to write the file to the filesystem
+    #
+    # Returns true unless the defaults for the destination path from
+    # bridgetown.config.yml contain `published: false`.
+    def write?
+      publishable = defaults.fetch("published", true)
+      return publishable unless @collection
+
+      publishable && @collection.write?
+    end
+
+    # Write the static file to the destination directory (if modified).
+    #
+    # dest - The String path to the destination dir.
+    #
+    # Returns false if the file was not modified since last time (no-op).
+    def write(dest)
+      dest_path = destination(dest)
+      return false if File.exist?(dest_path) && !modified?
+
+      self.class.mtimes[path] = mtime
+
+      FileUtils.mkdir_p(File.dirname(dest_path))
+      FileUtils.rm(dest_path) if File.exist?(dest_path)
+      copy_file(dest_path)
+
+      true
+    end
+
+    def to_liquid
+      @to_liquid ||= Drops::StaticFileDrop.new(self)
+    end
+
+    # Generate "basename without extension" and strip away any trailing periods.
+    # NOTE: `String#gsub` removes all trailing periods (in comparison to `String#chomp`)
+    def basename
+      @basename ||= File.basename(name, extname).gsub(%r!\.*\z!, "")
+    end
+
+    def placeholders
+      {
+        :collection => @collection.label,
+        :path       => cleaned_relative_path,
+        :output_ext => "",
+        :name       => "",
+        :title      => "",
+      }
+    end
+
+    # Similar to Bridgetown::Document#cleaned_relative_path.
+    # Generates a relative path with the collection's directory removed when applicable
+    #   and additionally removes any multiple periods in the string.
+    #
+    # NOTE: `String#gsub!` removes all trailing periods (in comparison to `String#chomp!`)
+    #
+    # Examples:
+    #   When `relative_path` is "_methods/site/my-cool-avatar...png":
+    #     cleaned_relative_path
+    #     # => "/site/my-cool-avatar"
+    #
+    # Returns the cleaned relative path of the static file.
+    def cleaned_relative_path
+      @cleaned_relative_path ||= begin
+        cleaned = relative_path[0..-extname.length - 1]
+        cleaned.gsub!(%r!\.*\z!, "")
+        cleaned.sub!(@collection.relative_directory, "") if @collection
+        cleaned
+      end
+    end
+
+    # Applies a similar URL-building technique as Bridgetown::Document that takes
+    # the collection's URL template into account. The default URL template can
+    # be overriden in the collection's configuration in bridgetown.config.yml.
+    def url
+      @url ||= begin
+        base = if @collection.nil?
+                 cleaned_relative_path
+               else
+                 Bridgetown::URL.new(
+                   :template     => @collection.url_template,
+                   :placeholders => placeholders
+                 )
+               end.to_s.chomp("/")
+        base << extname
+      end
+    end
+
+    # Returns the type of the collection if present, nil otherwise.
+    def type
+      @type ||= @collection.nil? ? nil : @collection.label.to_sym
+    end
+
+    # Returns the front matter defaults defined for the file's URL and/or type
+    # as defined in bridgetown.config.yml.
+    def defaults
+      @defaults ||= @site.frontmatter_defaults.all url, type
+    end
+
+    # Returns a debug string on inspecting the static file.
+    # Includes only the relative path of the object.
+    def inspect
+      "#<#{self.class} @relative_path=#{relative_path.inspect}>"
+    end
+
+    private
+
+    def copy_file(dest_path)
+      if Bridgetown.env == "production"
+        FileUtils.cp(path, dest_path)
+      else
+        FileUtils.copy_entry(path, dest_path)
+      end
+
+      unless File.symlink?(dest_path)
+        File.utime(self.class.mtimes[path], self.class.mtimes[path], dest_path)
+      end
+    end
+  end
+end

data/lib/bridgetown-core/tags/component.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Tags
+    class BlockComponentTag < Liquid::Block
+      def initialize(tag_name, markup, tokens)
+        super
+
+        filename, @extra_params = markup.strip.split(" ", 2)
+        @component_path = "_components/#{filename.strip}.html"
+
+        @tag_name = tag_name
+      end
+
+      def render(context)
+        markdown_content = super
+
+        site = context.registers[:site]
+        converter = site.find_converter_instance(Bridgetown::Converters::Markdown)
+        markdownified_content = converter.convert(markdown_content)
+
+        context.stack do
+          context["componentcontent"] = markdownified_content
+          include_params = "#{@component_path} content=componentcontent"
+          include_params = "#{include_params} #{@extra_params}" if @extra_params
+          include_tag = IncludeTag.parse("include", include_params, [], @parse_context)
+          include_tag.render(context)
+        end
+      end
+    end
+  end
+end
+
+Liquid::Template.register_tag("component", Bridgetown::Tags::BlockComponentTag)

data/lib/bridgetown-core/tags/highlight.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Tags
+    class HighlightBlock < Liquid::Block
+      include Liquid::StandardFilters
+
+      # The regular expression syntax checker. Start with the language specifier.
+      # Follow that by zero or more space separated options that take one of three
+      # forms: name, name=value, or name="<quoted list>"
+      #
+      # <quoted list> is a space-separated list of numbers
+      SYNTAX = %r!^([a-zA-Z0-9.+#_-]+)((\s+\w+(=(\w+|"([0-9]+\s)*[0-9]+"))?)*)$!.freeze
+
+      def initialize(tag_name, markup, tokens)
+        super
+        if markup.strip =~ SYNTAX
+          @lang = Regexp.last_match(1).downcase
+          @highlight_options = parse_options(Regexp.last_match(2))
+        else
+          raise SyntaxError, <<~MSG
+            Syntax Error in tag 'highlight' while parsing the following markup:
+
+            #{markup}
+
+            Valid syntax: highlight <lang> [linenos]
+          MSG
+        end
+      end
+
+      LEADING_OR_TRAILING_LINE_TERMINATORS = %r!\A(\n|\r)+|(\n|\r)+\z!.freeze
+
+      def render(context)
+        prefix = context["highlighter_prefix"] || ""
+        suffix = context["highlighter_suffix"] || ""
+        code = super.to_s.gsub(LEADING_OR_TRAILING_LINE_TERMINATORS, "")
+
+        output =
+          case context.registers[:site].highlighter
+          when "rouge"
+            render_rouge(code)
+          when "pygments"
+            render_pygments(code, context)
+          else
+            render_codehighlighter(code)
+          end
+
+        rendered_output = add_code_tag(output)
+        prefix + rendered_output + suffix
+      end
+
+      private
+
+      OPTIONS_REGEX = %r!(?:\w="[^"]*"|\w=\w|\w)+!.freeze
+
+      def parse_options(input)
+        options = {}
+        return options if input.empty?
+
+        # Split along 3 possible forms -- key="<quoted list>", key=value, or key
+        input.scan(OPTIONS_REGEX) do |opt|
+          key, value = opt.split("=")
+          # If a quoted list, convert to array
+          if value&.include?('"')
+            value.delete!('"')
+            value = value.split
+          end
+          options[key.to_sym] = value || true
+        end
+
+        options[:linenos] = "inline" if options[:linenos] == true
+        options
+      end
+
+      def render_pygments(code, _context)
+        Bridgetown.logger.warn "Warning:", "Highlight Tag no longer supports" \
+                                " rendering with Pygments."
+        Bridgetown.logger.warn "", "Using the default highlighter, Rouge, instead."
+        render_rouge(code)
+      end
+
+      def render_rouge(code)
+        require "rouge"
+        formatter = ::Rouge::Formatters::HTMLLegacy.new(
+          :line_numbers => @highlight_options[:linenos],
+          :wrap         => false,
+          :css_class    => "highlight",
+          :gutter_class => "gutter",
+          :code_class   => "code"
+        )
+        lexer = ::Rouge::Lexer.find_fancy(@lang, code) || Rouge::Lexers::PlainText
+        formatter.format(lexer.lex(code))
+      end
+
+      def render_codehighlighter(code)
+        h(code).strip
+      end
+
+      def add_code_tag(code)
+        code_attributes = [
+          "class=\"language-#{@lang.to_s.tr("+", "-")}\"",
+          "data-lang=\"#{@lang}\"",
+        ].join(" ")
+        "<figure class=\"highlight\"><pre><code #{code_attributes}>"\
+        "#{code.chomp}</code></pre></figure>"
+      end
+    end
+  end
+end
+
+Liquid::Template.register_tag("highlight", Bridgetown::Tags::HighlightBlock)

data/lib/bridgetown-core/tags/include.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Tags
+    class IncludeTag < Liquid::Tag
+      VALID_SYNTAX = %r!
+        ([\w-]+)\s*=\s*
+        (?:"([^"\\]*(?:\\.[^"\\]*)*)"|'([^'\\]*(?:\\.[^'\\]*)*)'|([\w\.-]+))
+      !x.freeze
+      VARIABLE_SYNTAX = %r!
+        (?<variable>[^{]*(\{\{\s*[\w\-\.]+\s*(\|.*)?\}\}[^\s{}]*)+)
+        (?<params>.*)
+      !mx.freeze
+
+      FULL_VALID_SYNTAX = %r!\A\s*(?:#{VALID_SYNTAX}(?=\s|\z)\s*)*\z!.freeze
+      VALID_FILENAME_CHARS = %r!^[\w/\.-]+$!.freeze
+      INVALID_SEQUENCES = %r![./]{2,}!.freeze
+
+      def initialize(tag_name, markup, tokens)
+        super
+        matched = markup.strip.match(VARIABLE_SYNTAX)
+        if matched
+          @file = matched["variable"].strip
+          @params = matched["params"].strip
+        else
+          @file, @params = markup.strip.split(%r!\s+!, 2)
+        end
+        validate_params if @params
+        @tag_name = tag_name
+      end
+
+      def syntax_example
+        "{% #{@tag_name} file.ext param='value' param2='value' %}"
+      end
+
+      def parse_params(context)
+        params = {}
+        markup = @params
+
+        while (match = VALID_SYNTAX.match(markup))
+          markup = markup[match.end(0)..-1]
+
+          value = if match[2]
+                    match[2].gsub('\\"', '"')
+                  elsif match[3]
+                    match[3].gsub("\\'", "'")
+                  elsif match[4]
+                    context[match[4]]
+                  end
+
+          params[match[1]] = value
+        end
+        params
+      end
+
+      def validate_file_name(file)
+        if INVALID_SEQUENCES.match?(file) || !VALID_FILENAME_CHARS.match?(file)
+          raise ArgumentError, <<~MSG
+            Invalid syntax for include tag. File contains invalid characters or sequences:
+
+              #{file}
+
+            Valid syntax:
+
+              #{syntax_example}
+
+          MSG
+        end
+      end
+
+      def validate_params
+        unless FULL_VALID_SYNTAX.match?(@params)
+          raise ArgumentError, <<~MSG
+            Invalid syntax for include tag:
+
+            #{@params}
+
+            Valid syntax:
+
+            #{syntax_example}
+
+          MSG
+        end
+      end
+
+      # Grab file read opts in the context
+      def file_read_opts(context)
+        context.registers[:site].file_read_opts
+      end
+
+      # Render the variable if required
+      def render_variable(context)
+        Liquid::Template.parse(@file).render(context) if VARIABLE_SYNTAX.match?(@file)
+      end
+
+      def tag_includes_dirs(context)
+        context.registers[:site].includes_load_paths.freeze
+      end
+
+      def locate_include_file(context, file)
+        includes_dirs = tag_includes_dirs(context)
+        # TODO: component folder should be configured separately
+        if file.start_with?("_components")
+          first_dir = includes_dirs.first
+          path = PathManager.join(first_dir.sub(%r!/_includes$!, ""), file)
+          return path if valid_include_file?(path, first_dir.to_s)
+        else
+          includes_dirs.each do |dir|
+            path = PathManager.join(dir, file)
+            return path if valid_include_file?(path, dir.to_s)
+          end
+        end
+        raise IOError, could_not_locate_message(file, includes_dirs)
+      end
+
+      def render(context)
+        site = context.registers[:site]
+
+        file = render_variable(context) || @file
+        validate_file_name(file)
+
+        path = locate_include_file(context, file)
+        return unless path
+
+        add_include_to_dependency(site, path, context)
+
+        partial = load_cached_partial(path, context)
+
+        context.stack do
+          context["include"] = parse_params(context) if @params
+          begin
+            partial.render!(context)
+          rescue Liquid::Error => e
+            e.template_name = path
+            e.markup_context = "included " if e.markup_context.nil?
+            raise e
+          end
+        end
+      end
+
+      def add_include_to_dependency(site, path, context)
+        if context.registers[:page]&.key?("path")
+          site.regenerator.add_dependency(
+            site.in_source_dir(context.registers[:page]["path"]),
+            path
+          )
+        end
+      end
+
+      def load_cached_partial(path, context)
+        context.registers[:cached_partials] ||= {}
+        cached_partial = context.registers[:cached_partials]
+
+        if cached_partial.key?(path)
+          cached_partial[path]
+        else
+          unparsed_file = context.registers[:site]
+            .liquid_renderer
+            .file(path)
+          begin
+            cached_partial[path] = unparsed_file.parse(read_file(path, context))
+          rescue Liquid::Error => e
+            e.template_name = path
+            e.markup_context = "included " if e.markup_context.nil?
+            raise e
+          end
+        end
+      end
+
+      def valid_include_file?(path, _dir)
+        File.file?(path)
+      end
+
+      def realpath_prefixed_with?(path, dir)
+        File.exist?(path) && File.realpath(path).start_with?(dir)
+      rescue StandardError
+        false
+      end
+
+      # This method allows to modify the file content by inheriting from the class.
+      def read_file(file, context)
+        File.read(file, **file_read_opts(context))
+      end
+
+      private
+
+      # TODO: update this to support components as well
+      def could_not_locate_message(file, includes_dirs)
+        "Could not locate the included file '#{file}' in any of #{includes_dirs}." \
+          " Ensure it exists in one of those directories."
+      end
+    end
+
+    class IncludeRelativeTag < IncludeTag
+      def tag_includes_dirs(context)
+        Array(page_path(context)).freeze
+      end
+
+      def page_path(context)
+        if context.registers[:page].nil?
+          context.registers[:site].source
+        else
+          site = context.registers[:site]
+          page_payload = context.registers[:page]
+          resource_path = \
+            if page_payload["collection"].nil?
+              page_payload["path"]
+            else
+              File.join(site.config["collections_dir"], page_payload["path"])
+            end
+          resource_path.sub!(%r!/#excerpt\z!, "")
+          site.in_source_dir File.dirname(resource_path)
+        end
+      end
+    end
+  end
+end
+
+Liquid::Template.register_tag("include", Bridgetown::Tags::IncludeTag)
+Liquid::Template.register_tag("include_relative", Bridgetown::Tags::IncludeRelativeTag)