jekyll-highlight-param 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b73acabebbdec05a36634b8804d60f07a2cd5f82961e371b7a8b691b0254e794
-  data.tar.gz: c562dbad209384989a885701b814d4d9d9bed98289039dafd40340cd36fe55d4
+  metadata.gz: ee62e924028e4852ec50e55d532ee86339f7794e676126ec21abee8853277d47
+  data.tar.gz: '08ab4c9ec59a4742f367e929d59c7d59575599b477377cf7937cfb0ff88cc700'
 SHA512:
-  metadata.gz: 19d3c9f2c8412d9f06ee559029626326059a64fd561a79600d4323bd5387c79e8b13ad27d845f8b72f8eaf2ca4417eca83028cb2f5589c5d2b38fe08786be2f2
-  data.tar.gz: f3a8d2aff0127d44f5225f181ec891771fe830619a8014b38a3158d64a38a8b6551eae11274377d1b4f0848a900191d95ed9b76f3b5d1b3590aeecca64927eed
+  metadata.gz: a5c1ca294060894d593b72e3e2aa544972ea2cb7f6cdf9df0b2564069d52f50f42cdeeb77c81f77f00656ae7750282cc29e4278931576c698fda3e19e72e5a38
+  data.tar.gz: c1e99c02e6f95d9c226e903be96f7ec1a265f0a522eb85ba918f9cc55554a7d6b2844ef5172cf769a0ef041b53fe175cc0f9e126d9c42d83ece53ce548faec19

data/.ruby-version

@@ -0,0 +1 @@
+2.6.6

data/README.md

@@ -1 +1,114 @@
 # jekyll-highlight-param
+
+[![Gem Version](https://badge.fury.io/rb/jekyll-highlight-param.svg)](https://badge.fury.io/rb/jekyll-highlight-param)
+
+A Liquid tag plugin for Jekyll that replaces the built in `{% highlight %}` tag, and allows passing the language to highlight in as a parameter.
+
+_An issue for making this change a part of the mainline Jekyll Highlight tag can be found [here](https://github.com/jekyll/jekyll/issues/8290)._ 
+
+_**It appears v0.0.1 did not actually work as intended, and was simply failing gracefully by detecting the language from the code itself. A better job of detecting errors and alerting the user was devised in v0.0.2.**_
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+group :jekyll_plugins do
+    gem 'jekyll-highlight-param', :github => 'UriShX/jekyll-highlight-param'
+end
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install jekyll-highlight-param
+
+Then add the following to your site's `_config.yml`:
+
+```yaml
+plugins:
+  - jekyll-highlight-param
+```
+
+💡 If you are using a Jekyll version less than 3.5.0, use the `gems` key instead of `plugins`.
+
+## Usage
+
+### Basic usage
+Basic usage is the same as Jekyll's `{% highlight %}` tag, i.e.:
+
+```liquid
+{% highlight_param ruby %}
+def foo
+  puts 'foo'
+end
+{% endhighlight_param %}
+```
+
+### Using variables names for the language
+
+_Please note: Since v0.0.2 passing variables to the `highlight_param` tag is done in a similar way to the syntax for passing variables to other tags, such as `link`. This is a breaking change from v0.0.1._
+
+The name of the language you for the code to be highlighted can be specified as a variable instead of specifying the language directly in the template. For example, suppose you defined a variable in your page's front matter like this:
+
+```yaml
+---
+title: My page
+my_code: footer_company_a.html
+my_lang: liquid
+---
+```
+
+You could then reference that variable in your highlight:
+
+```liquid
+{% if page.my_variable %}
+  {% capture my_code %}
+    {% include {{ page.code }} %}
+  {% endcapture %}
+  {% highlight_param {{ page.my_lang }} %}
+    {{ my_code | strip }}
+  {% endhighlight_param %}
+{% endif %}
+```
+
+In this example, the capture will store the include file `_includes/footer_company_a.html`, then the highlight will would match the display to match the syntax of `liquid`.
+
+### Line numbers
+
+You could also pass a line numbers argument, as in the original `{% highlight %}` tag, both as parameter and as a variable. Line numbers are enabled when passing the `linenos` argument, and disabled as default.
+
+```liquid
+{% highlight_param ruby linenos %}
+def foo
+  puts 'foo'
+end
+{% endhighlight_param %}
+```
+or:
+
+```yaml
+---
+title: My page
+line_numbers: linenos
+---
+```
+
+```liquid
+{% highlight_param ruby {{ page.line_numbers }} %}
+def foo
+  puts 'foo'
+end
+{% endhighlight_param %}
+```
+
+## Contributing
+
+1. Fork it.
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/lib/jekyll-highlight-param.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-require "rouge"
 
 module Jekyll
   module Tags
@@ -11,20 +10,55 @@ module Jekyll
       # 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
+      # 
+      # Both the language specifier and the options can be passed as liquid variables,
+      # please consult the documentation at https://github.com/UriShX/jekyll-highlight-param/blob/master/README.md#usage.
+      PARAM_SYNTAX = %r!(\w+([.]\w+)*)!x.freeze
+      LANG_SYNTAX = %r!([a-zA-Z0-9.+#_-]+)!x.freeze
+      OPTIONS_SYNTAX = %r!(\s+\w+(=(\w+|"([0-9]+\s)*[0-9]+")?)*)!.freeze
+      VARIABLE_SYNTAX = %r!
+        ^(
+          \{\{\s*
+          (?<lang_var>#{PARAM_SYNTAX})
+          \s*\}\}|
+          (?<lang>#{LANG_SYNTAX})
+        )
+        \s*
+        ((?<fault1>[}]+\s*|)
+        (
+          \{\{\s*
+          (?<params_var>(#{PARAM_SYNTAX}))
+          \s*\}\}|
+          (?<params>(#{OPTIONS_SYNTAX}+))
+        )
+        (?<fault2>.*))?
+      !mx.freeze
+
+      def isNilOrEmpty(var)
+        if var.nil?
+          return true
+        elsif var.strip.empty?
+          return true
+        else
+          return false
+        end
+      end
 
       def initialize(tag_name, markup, tokens)
         super
-        if markup.strip =~ SYNTAX
-          @lang = Regexp.last_match(1)
-          @highlight_options = parse_options(Regexp.last_match(2))
-        else
+        markup  = markup.strip
+        @matched = markup.match(VARIABLE_SYNTAX)
+        # print @matched.captures.to_s + "\n"
+        if !@matched or !isNilOrEmpty(@matched["fault1"]) or !isNilOrEmpty(@matched["fault2"])
           raise SyntaxError, <<~MSG
-            Syntax Error in tag 'highlight' while parsing the following markup:
+            Syntax Error in tag '#{tag_name}' while parsing the following markup:
 
             #{markup}
 
-            Valid syntax: highlight <lang> [linenos]
+            Valid syntax: #{tag_name} <lang> [linenos]
+                      \tOR: #{tag_name} {{ lang_variable }} [linenos]
+                      \tOR: #{tag_name} <lang> {{ [linenos_variable(s)] }}
+                      \tOR: #{tag_name} {{ lang_variable }} {{ [linenos_variable(s)] }}
           MSG
         end
       end
@@ -36,18 +70,36 @@ module Jekyll
         suffix = context["highlighter_suffix"] || ""
         code = super.to_s.gsub(LEADING_OR_TRAILING_LINE_TERMINATORS, "")
 
-        
-        # if ::Rouge::Lexer.find(@lang.downcase) != nil
-        #   @lang = @lang.downcase
-        # else
-        begin
-          ::Rouge::Lexer.find((context[@lang]).downcase) != nil
-          @lang = (context[@lang]).downcase
-        rescue
-          @lang = @lang.downcase
+        if @matched["lang_var"]
+          @lang = context[@matched["lang_var"]].downcase
+          @lang.match(LANG_SYNTAX)
+          unless $& == @lang
+            raise ArgumentError, <<~MSG
+              Language characters can only include Alphanumeric and the following characters, without spaces: . + # _ -
+              Your passed language variable: #{@lang}
+              MSG
+          end
+        elsif @matched["lang"]
+          @lang = @matched["lang"].downcase
+        else
+          raise SyntaxError, <<~MSG
+            Unknown Syntax Error in tag 'highlight_param'.
+            Please review tag documentation.
+            MSG
         end
-        # end
-        
+
+        # puts @lang
+
+        if @matched["params_var"]
+          @highlight_options = parse_options(@matched["params_var"])
+        elsif @matched["params"]
+          @highlight_options = parse_options(@matched["params"])
+        else
+          @highlight_options = parse_options("")
+        end
+
+        # puts @highlight_options
+
         output =
           case context.registers[:site].highlighter
           when "rouge"
@@ -68,7 +120,7 @@ module Jekyll
 
       def parse_options(input)
         options = {}
-        return options if input.empty?
+        return options if isNilOrEmpty(input)
 
         # Split along 3 possible forms -- key="<quoted list>", key=value, or key
         input.scan(OPTIONS_REGEX) do |opt|
@@ -92,6 +144,7 @@ module Jekyll
       end
 
       def render_rouge(code)
+        require "rouge"
         formatter = ::Rouge::Formatters::HTMLLegacy.new(
           :line_numbers => @highlight_options[:linenos],
           :wrap         => false,
@@ -99,7 +152,13 @@ module Jekyll
           :gutter_class => "gutter",
           :code_class   => "code"
         )
-        lexer = ::Rouge::Lexer.find_fancy(@lang, code) || Rouge::Lexers::PlainText
+        if LANG_SYNTAX.match?(@lang)
+          lexer = ::Rouge::Lexer.find_fancy(@lang, code) || Rouge::Lexers::PlainText
+        else
+          raise SyntaxError, <<~MSG
+          Can't find language variable #{@matched["lang_var"]}
+          MSG
+        end
         formatter.format(lexer.lex(code))
       end
 
@@ -119,4 +178,4 @@ module Jekyll
   end
 end
 
-Liquid::Template.register_tag("highlight_param", Jekyll::Tags::HighlightBlockParam)
+Liquid::Template.register_tag("highlight_param", Jekyll::Tags::HighlightBlockParam)

data/lib/jekyll/tags/include.rb

@@ -0,0 +1,270 @@
+# frozen_string_literal: true
+
+module Jekyll
+  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
+        markup  = markup.strip
+        matched = markup.match(VARIABLE_SYNTAX)
+        if matched
+          @file = matched["variable"].strip
+          @params = matched["params"].strip
+        else
+          @file, @params = markup.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 = {}
+        @params.scan(VALID_SYNTAX) do |key, d_quoted, s_quoted, variable|
+          value = if d_quoted
+                    d_quoted.include?('\\"') ? d_quoted.gsub('\\"', '"') : d_quoted
+                  elsif s_quoted
+                    s_quoted.include?("\\'") ? s_quoted.gsub("\\'", "'") : s_quoted
+                  elsif variable
+                    context[variable]
+                  end
+
+          params[key] = 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, safe)
+        includes_dirs = tag_includes_dirs(context)
+        includes_dirs.each do |dir|
+          path = PathManager.join(dir, file)
+          return path if valid_include_file?(path, dir.to_s, safe)
+        end
+        raise IOError, could_not_locate_message(file, includes_dirs, safe)
+      end
+
+      def render(context)
+        site = context.registers[:site]
+
+        file = render_variable(context) || @file
+        validate_file_name(file)
+
+        path = locate_include_file(context, file, site.safe)
+        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, safe)
+        !outside_site_source?(path, dir, safe) && File.file?(path)
+      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, **file_read_opts(context))
+      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
+
+    # Do not inherit from this class.
+    # TODO: Merge into the `Jekyll::Tags::IncludeTag` in v5.0
+    class OptimizedIncludeTag < IncludeTag
+      def render(context)
+        @site ||= context.registers[:site]
+
+        file = render_variable(context) || @file
+        validate_file_name(file)
+
+        @site.inclusions[file] ||= locate_include_file(file)
+        inclusion = @site.inclusions[file]
+
+        add_include_to_dependency(inclusion, context) if @site.incremental?
+
+        context.stack do
+          context["include"] = parse_params(context) if @params
+          inclusion.render(context)
+        end
+      end
+
+      private
+
+      def locate_include_file(file)
+        @site.includes_load_paths.each do |dir|
+          path = PathManager.join(dir, file)
+          return Inclusion.new(@site, dir, file) if valid_include_file?(path, dir)
+        end
+        raise IOError, could_not_locate_message(file, @site.includes_load_paths, @site.safe)
+      end
+
+      def valid_include_file?(path, dir)
+        File.file?(path) && !outside_scope?(path, dir)
+      end
+
+      def outside_scope?(path, dir)
+        @site.safe && !realpath_prefixed_with?(path, dir)
+      end
+
+      def realpath_prefixed_with?(path, dir)
+        File.realpath(path).start_with?(dir)
+      rescue StandardError
+        false
+      end
+
+      def add_include_to_dependency(inclusion, context)
+        return unless context.registers[:page]&.key?("path")
+
+        @site.regenerator.add_dependency(
+          @site.in_source_dir(context.registers[:page]["path"]),
+          inclusion.path
+        )
+      end
+    end
+
+    class IncludeRelativeTag < IncludeTag
+      def tag_includes_dirs(context)
+        Array(page_path(context)).freeze
+      end
+
+      def page_path(context)
+        page, site = context.registers.values_at(:page, :site)
+        return site.source unless page
+
+        site.in_source_dir File.dirname(resource_path(page, site))
+      end
+
+      private
+
+      def resource_path(page, site)
+        path = page["path"]
+        path = File.join(site.config["collections_dir"], path) if page["collection"]
+        path.sub(%r!/#excerpt\z!, "")
+      end
+    end
+  end
+end
+
+Liquid::Template.register_tag("include", Jekyll::Tags::OptimizedIncludeTag)
+Liquid::Template.register_tag("include_relative", Jekyll::Tags::IncludeRelativeTag)

data/lib/jekyll/tags/link.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module Tags
+    class Link < Liquid::Tag
+      include Jekyll::Filters::URLFilters
+
+      class << self
+        def tag_name
+          name.split("::").last.downcase
+        end
+      end
+
+      def initialize(tag_name, relative_path, tokens)
+        super
+
+        @relative_path = relative_path.strip
+      end
+
+      def render(context)
+        @context = context
+        site = context.registers[:site]
+        relative_path = Liquid::Template.parse(@relative_path).render(context)
+        relative_path_with_leading_slash = PathManager.join("", relative_path)
+
+        site.each_site_file do |item|
+          return relative_url(item) if item.relative_path == relative_path
+          # This takes care of the case for static files that have a leading /
+          return relative_url(item) if item.relative_path == relative_path_with_leading_slash
+        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)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jekyll-highlight-param
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Uri Shani
@@ -39,7 +39,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.6'
 description: A Liquid tag plugin for Jekyll that replaces the built in highlight tag,
-  and allows passing the language to highlight in as a parameter.
+  and allows passing the language to highlight in as a liquid variable.
 email:
 - usdogi@gmail.com
 executables: []
@@ -47,10 +47,12 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".ruby-version"
 - README.md
-- jekyll-highlight-param.gemspec
 - lib/jekyll-highlight-param.rb
-homepage: https://github.com/UriShX/jekyll-highlight-param
+- lib/jekyll/tags/include.rb
+- lib/jekyll/tags/link.rb
+homepage: https://github.com/urishx/jekyll-highlight-param
 licenses:
 - MIT
 metadata: {}
@@ -72,5 +74,5 @@ requirements: []
 rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
-summary: Jekyll syntax highlighter that accepts parameter for the language
+summary: Jekyll syntax highlighter that accepts variable for the language
 test_files: []

data/jekyll-highlight-param.gemspec

@@ -1,23 +0,0 @@
-# coding: utf-8
-# frozen_string_literal: true
-lib = File.expand_path("../lib", __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-
-Gem::Specification.new do |spec|
-  spec.name                     = "jekyll-highlight-param"
-  spec.version                  = "0.0.1"
-  spec.date                     = "2020-09-23"
-  spec.authors                  = ["Uri Shani"]
-  spec.email                    = ["usdogi@gmail.com"]  
-  spec.summary                  = "Jekyll syntax highlighter that accepts parameter for the language"
-  spec.description              = "A Liquid tag plugin for Jekyll that replaces the built in highlight tag, and allows passing the language to highlight in as a parameter."
-  spec.homepage                 = "https://github.com/UriShX/jekyll-highlight-param"
-  spec.license                  = "MIT"
-  spec.required_ruby_version    = ">= 2.0.0"
-
-  spec.files                    = `git ls-files -z`.split("\x0")  
-  spec.require_paths            = ["lib"]
-
-  spec.add_development_dependency "jekyll", ">= 3.6.3"
-  spec.add_development_dependency "bundler", "~> 1.6"  
-end