liquidoc 0.12.0.pre.rc5 → 0.12.0.pre.rc6

data/lib/liquid/filters/url_filters.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module Filters
+    module URLFilters
+      # Produces an absolute URL based on site.url and site.baseurl.
+      #
+      # input - the URL to make absolute.
+      #
+      # Returns the absolute URL as a String.
+      def absolute_url(input)
+        return if input.nil?
+        input = input.url if input.respond_to?(:url)
+        return input if Addressable::URI.parse(input.to_s).absolute?
+        site = @context.registers[:site]
+        return relative_url(input) if site.config["url"].nil?
+        Addressable::URI.parse(
+          site.config["url"].to_s + relative_url(input)
+        ).normalize.to_s
+      end
+
+      # Produces a URL relative to the domain root based on site.baseurl
+      # unless it is already an absolute url with an authority (host).
+      #
+      # input - the URL to make relative to the domain root
+      #
+      # Returns a URL relative to the domain root as a String.
+      def relative_url(input)
+        return if input.nil?
+        input = input.url if input.respond_to?(:url)
+        return input if Addressable::URI.parse(input.to_s).absolute?
+
+        parts = [sanitized_baseurl, input]
+        Addressable::URI.parse(
+          parts.compact.map { |part| ensure_leading_slash(part.to_s) }.join
+        ).normalize.to_s
+      end
+
+      # Strips trailing `/index.html` from URLs to create pretty permalinks
+      #
+      # input - the URL with a possible `/index.html`
+      #
+      # Returns a URL with the trailing `/index.html` removed
+      def strip_index(input)
+        return if input.nil? || input.to_s.empty?
+        input.sub(%r!/index\.html?$!, "/")
+      end
+
+      private
+
+      def sanitized_baseurl
+        site = @context.registers[:site]
+        site.config["baseurl"].to_s.chomp("/")
+      end
+
+      def ensure_leading_slash(input)
+        return input if input.nil? || input.empty? || input.start_with?("/")
+        "/#{input}"
+      end
+
+    end
+  end
+end

data/lib/liquid/tags/highlight.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Jekyll
+  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]+"))?)*)$!
+
+      def initialize(tag_name, markup, tokens)
+        super
+        "WORKS!"
+      end
+
+      def render(context)
+        prefix = context["highlighter_prefix"] || ""
+        suffix = context["highlighter_suffix"] || ""
+        code = super.to_s.gsub(%r!\A(\n|\r)+|(\n|\r)+\z!, "")
+
+        is_safe = !!context.registers[:site].safe
+
+        output =
+          case context.registers[:site].highlighter
+          when "pygments"
+            render_pygments(code, is_safe)
+          when "rouge"
+            render_rouge(code)
+          else
+            render_codehighlighter(code)
+          end
+
+        rendered_output = add_code_tag(output)
+        prefix + rendered_output + suffix
+      end
+
+      def sanitized_opts(opts, is_safe)
+        if is_safe
+          Hash[[
+            [:startinline, opts.fetch(:startinline, nil)],
+            [:hl_lines,    opts.fetch(:hl_lines, nil)],
+            [:linenos,     opts.fetch(:linenos, nil)],
+            [:encoding,    opts.fetch(:encoding, "utf-8")],
+            [:cssclass,    opts.fetch(:cssclass, nil)],
+          ].reject { |f| f.last.nil? }]
+        else
+          opts
+        end
+      end
+
+      private
+
+      OPTIONS_REGEX = %r!(?:\w="[^"]*"|\w=\w|\w)+!
+
+      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 && 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, is_safe)
+        Jekyll::External.require_with_graceful_fail("pygments") unless defined?(Pygments)
+
+        highlighted_code = Pygments.highlight(
+          code,
+          :lexer   => @lang,
+          :options => sanitized_opts(@highlight_options, is_safe)
+        )
+
+        if highlighted_code.nil?
+          Jekyll.logger.error <<-MSG
+There was an error highlighting your code:
+
+#{code}
+
+While attempting to convert the above code, Pygments.rb returned an unacceptable value.
+This is usually a timeout problem solved by running `jekyll build` again.
+MSG
+          raise ArgumentError, "Pygments.rb returned an unacceptable value "\
+          "when attempting to highlight some code."
+        end
+
+        highlighted_code.sub('<div class="highlight"><pre>', "").sub("</pre></div>", "")
+      end
+
+      def render_rouge(code)
+        formatter = Jekyll::Utils::Rouge.html_formatter(
+          :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", Jekyll::Tags::HighlightBlock)

data/lib/liquid/tags/jekyll.rb

@@ -0,0 +1,219 @@
+# (C) Jekyll, this file contains some of Jekyll's custom Liquid filters
+# It is placed in lib/liquid/jekyll for this reason, even though the module/class
+# path is Jekyll::Tags::, so as not to conflict with the Liquid:: path.
+
+# frozen_string_literal: true
+
+module Jekyll
+  module Tags
+    class IncludeTagError < StandardError
+      attr_accessor :path
+
+      def initialize(msg, path)
+        super(msg)
+        @path = path
+      end
+    end
+
+    class IncludeTag < Liquid::Tag
+      # matches proper params format only
+      # 1(key-formatted str) = (2(double-quoted str) or 3(single-quoted str) 4(var-formatted str))
+      VALID_SYNTAX = %r!
+        ([\w-]+)\s*=\s*
+        (?:"([^"\\]*(?:\\.[^"\\]*)*)"|'([^'\\]*(?:\\.[^'\\]*)*)'|([a-z][\w'"\[\]\.-]*))
+      !x
+      # extracts filename as #{variable} and k/v pairs as #{params}
+      VARIABLE_SYNTAX = %r!
+        (?<variable>[^{]*(\{\{\s*[\w\-\.]+\s*(\|.*)?\}\}[^\s{}]*)+)
+        (?<params>.*)
+      !mx
+
+      FULL_VALID_SYNTAX = %r!\A\s*(?:#{VALID_SYNTAX}(?=\s|\z)\s*)*\z!
+      VALID_FILENAME_CHARS = %r!^[\w/\.-]+$!
+      INVALID_SEQUENCES = %r![./]{2,}!
+
+      def initialize(tag_name, markup, tokens)
+        super
+        matched = markup.strip.match(VARIABLE_SYNTAX)
+        if matched # include passes filename as variable
+          @file = matched["variable"].strip # The file to include (as a var)
+          @params = matched["params"].strip # The paired vars to load
+        else # if the filename isn't a variable, just grab the first arg as filename and rest as params
+          @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))
+          # run until syntax no longer matches parameters
+          markup = markup[match.end(0)..-1]
+          # set val by which group matched in VALID_SYNTAX
+          # either a quoted string (2,3) or a variable (4)
+          value = if match[2]
+                    match[2].gsub(%r!\\"!, '"')
+                  elsif match[3]
+                    match[3].gsub(%r!\\'!, "'")
+                  elsif match[4] # val is resolved context var
+                    context[match[4]]
+                  end
+          params[match[1]] = value # inserts param
+        end
+        params # returns hash for the include scope
+      end
+
+      def validate_file_name(file)
+        if file =~ INVALID_SEQUENCES || file !~ VALID_FILENAME_CHARS
+          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 @params =~ FULL_VALID_SYNTAX
+          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
+
+      # Express the filename from the variable
+      # Passes along the context in which it was called, from the parent file
+      def render_variable(context)
+        Liquid::Template.parse(@file).render(context) if @file =~ VARIABLE_SYNTAX
+      end
+
+      # Array of directories where includes are stored
+      def tag_includes_dirs(context)
+        # context[:includes_dirs]
+        ['_templates','_templates/liquid','_templates/liquid/ops','theme/_includes','_theme/layouts']
+      end
+
+      # Traverse includes dirs, setting paths for includes
+      def locate_include_file(context, file, safe)
+        includes_dirs = ['_templates','_templates/liquid','_templates/liquid/ops','_templates/ops','theme/_includes','theme/_layouts']
+        includes_dirs.each do |dir|
+          path = File.join(dir.to_s, file.to_s)
+          return path if File.exist?(path)
+        end
+        raise IOError, could_not_locate_message(file, includes_dirs, safe)
+      end
+
+      # recall/render the included partial and place it in the parent doc
+      def render(context)
+        file = render_variable(context) || @file # use parsed variable filename unless passed explicit filename
+        validate_file_name(file)
+        path = locate_include_file(context, file, true) # ensure file exists in safe path
+        return unless path
+        # # ???????
+        # add_include_to_dependency(site, path, context)
+        #
+        # Load the partial if it's identical to one we've already loaded ???
+        partial = File.read(path) # reads the template file
+        partial = Liquid::Template.parse(partial) # compiles template
+        # setup and perform render
+        context.stack do
+          # create a hash object for any passed k/v pair args
+          # by parsing passed parameters using the parent file's scope
+          context["include"] = parse_params(context) if @params
+          begin # render the include for output
+            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] && 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[:globals]
+            .liquid_renderer
+            .file(path)
+          begin
+            # Cache a version of the
+            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 outside_site_source?(path, dir, safe)
+        safe && !realpath_prefixed_with?(path, dir)
+      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)
+      end
+
+      private
+
+      def could_not_locate_message(file, includes_dirs, safe)
+        message = "Could not locate the included file '#{file}' in any of "\
+          "#{includes_dirs}. Ensure it exists in one of those directories and"
+        message + if safe
+                    " is not a symlink as those are not allowed in safe mode."
+                  else
+                    ", if it is a symlink, does not point outside your site source."
+                  end
+      end
+    end
+
+  end # Tags
+
+end
+
+Liquid::Template.register_tag("include", Jekyll::Tags::IncludeTag)

data/lib/liquid/tags/link.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module Tags
+    class Link < Liquid::Tag
+      class << self
+        def tag_name
+          self.name.split("::").last.downcase
+        end
+      end
+
+      def initialize(tag_name, relative_path, tokens)
+        super
+
+        @relative_path = relative_path.strip
+      end
+
+      def render(context)
+        site = context.registers[:site]
+
+        site.each_site_file do |item|
+          return item.url if item.relative_path == @relative_path
+          # This takes care of the case for static files that have a leading /
+          return item.url if item.relative_path == "/#{@relative_path}"
+        end
+
+        raise ArgumentError, <<-MSG
+Could not find document '#{@relative_path}' in tag '#{self.class.tag_name}'.
+
+Make sure the document exists and the path is correct.
+MSG
+      end
+    end
+  end
+end
+
+Liquid::Template.register_tag(Jekyll::Tags::Link.tag_name, Jekyll::Tags::Link)

data/lib/liquid/tags/post_url.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module Tags
+    class PostComparer
+      MATCHER = %r!^(.+/)*(\d+-\d+-\d+)-(.*)$!
+
+      attr_reader :path, :date, :slug, :name
+
+      def initialize(name)
+        @name = name
+
+        all, @path, @date, @slug = *name.sub(%r!^/!, "").match(MATCHER)
+        unless all
+          raise Jekyll::Errors::InvalidPostNameError,
+            "'#{name}' does not contain valid date and/or title."
+        end
+
+        escaped_slug = Regexp.escape(slug)
+        @name_regex = %r!^_posts/#{path}#{date}-#{escaped_slug}\.[^.]+|
+          ^#{path}_posts/?#{date}-#{escaped_slug}\.[^.]+!x
+      end
+
+      def post_date
+        @post_date ||= Utils.parse_date(date,
+          "\"#{date}\" does not contain valid date and/or title.")
+      end
+
+      def ==(other)
+        other.relative_path.match(@name_regex)
+      end
+
+      def deprecated_equality(other)
+        slug == post_slug(other) &&
+          post_date.year  == other.date.year &&
+          post_date.month == other.date.month &&
+          post_date.day   == other.date.day
+      end
+
+      private
+      # Construct the directory-aware post slug for a Jekyll::Post
+      #
+      # other - the Jekyll::Post
+      #
+      # Returns the post slug with the subdirectory (relative to _posts)
+      def post_slug(other)
+        path = other.basename.split("/")[0...-1].join("/")
+        if path.nil? || path == ""
+          other.data["slug"]
+        else
+          path + "/" + other.data["slug"]
+        end
+      end
+    end
+
+    class PostUrl < Liquid::Tag
+      def initialize(tag_name, post, tokens)
+        super
+        @orig_post = post.strip
+        begin
+          @post = PostComparer.new(@orig_post)
+        rescue StandardError => e
+          raise Jekyll::Errors::PostURLError, <<-MSG
+Could not parse name of post "#{@orig_post}" in tag 'post_url'.
+
+Make sure the post exists and the name is correct.
+
+#{e.class}: #{e.message}
+MSG
+        end
+      end
+
+      def render(context)
+        site = context.registers[:site]
+
+        site.posts.docs.each do |p|
+          return p.url if @post == p
+        end
+
+        # New matching method did not match, fall back to old method
+        # with deprecation warning if this matches
+
+        site.posts.docs.each do |p|
+          next unless @post.deprecated_equality p
+          Jekyll::Deprecator.deprecation_message "A call to "\
+            "'{% post_url #{@post.name} %}' did not match " \
+            "a post using the new matching method of checking name " \
+            "(path-date-slug) equality. Please make sure that you " \
+            "change this tag to match the post's name exactly."
+          return p.url
+        end
+
+        raise Jekyll::Errors::PostURLError, <<-MSG
+Could not find post "#{@orig_post}" in tag 'post_url'.
+
+Make sure the post exists and the name is correct.
+MSG
+      end
+    end
+  end
+end
+
+Liquid::Template.register_tag("post_url", Jekyll::Tags::PostUrl)

data/lib/liquidoc/version.rb

@@ -1,3 +1,3 @@
 module Liquidoc
-  VERSION = "0.12.0-rc5"
+  VERSION = "0.12.0-rc6"
 end