jekyll_flexible_include 2.0.14 → 2.0.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 235134772b0ff492ec61e24e71a8094977ae43e740c338dabfd65e92cd8ac416
-  data.tar.gz: c89b5985bde7ec87ef12870cf27369d1f2c6194de9ef8459064675f13402d87f
+  metadata.gz: d8f07914cb71b0dc833f7735175ef18ccde8357e7fcf14014d954cae6e40c5bc
+  data.tar.gz: e077293b1be82f05dedfd02e6326c6c64d4a87895fc4d6f90cc7d532d50df857
 SHA512:
-  metadata.gz: '094fae8fef148dd4801710911d8d0bde33e45a3ef0c7b5f5417e0a5baea1cc8d24d975d3b9e02e76ed96fca375651bd06074bf5a21a72ca1ee3343f960ab9aec'
-  data.tar.gz: 810afd58a9df5f7d7d88f97de0bbbb5547cbe400d0a09a25dff8ada24bdc4ad313cb0a535571388d6990edc125e3fca9d07c3a71bf33f0868a057cc451f47bc6
+  metadata.gz: 2a476f8c116c18590acd67e5be96fb1d10889394f3c278cec7bb43d211be7a8f8dcacc158953c4e9bea3de29b6d32668e8d5500ae24a8a0bd405d091219ac6ff
+  data.tar.gz: 5bd8341a6eb53a35a520791a32d79ec587169650f56d36c3d4b4aa965f6247867037253d83c677cbdae913d79b19d6a18a901a63013cc49fbc526358583bb238

data/.rubocop.yml

@@ -1,16 +1,36 @@
-require: rubocop-jekyll
-inherit_gem:
-  rubocop-jekyll: .rubocop.yml
+require:
+  # - rubocop-jekyll
+  - rubocop-md
+  - rubocop-performance
+  - rubocop-rake
+  - rubocop-rspec
+
+# inherit_gem:
+#   rubocop-jekyll: .rubocop.yml
 
 AllCops:
   Exclude:
-      - vendor/**/*
-      - Gemfile*
+    - demo/_site/**/*
+    - exe/**/*
+    - vendor/**/*
+    - Gemfile*
   NewCops: enable
   TargetRubyVersion: 2.6
 
-# Gemspec/RequireMFA:
-  # Enabled: false
+Gemspec/DeprecatedAttributeAssignment:
+  Enabled: false
+
+Gemspec/RequireMFA:
+  Enabled: false
+
+Layout/InitialIndentation:
+  Exclude:
+    - README.md
+
+Layout/HashAlignment:
+  EnforcedColonStyle: table
+  Exclude:
+    - jekyll_flexible_include_plugin.gemspec
 
 Layout/LineLength:
   Max: 150
@@ -18,20 +38,68 @@ Layout/LineLength:
 Layout/MultilineMethodCallIndentation:
   Enabled: false
 
+Lint/RedundantCopDisableDirective:
+  Exclude:
+    - jekyll_flexible_include_plugin.gemspec
+
+Metrics/AbcSize:
+  Max: 45
+
 Metrics/BlockLength:
-  Enabled: false
+  Exclude:
+    - jekyll_flexible_include_plugin.gemspec
+    - spec/**/*
+
+Metrics/ClassLength:
+  Exclude:
+    - spec/**/*
+
+Metrics/CyclomaticComplexity:
+  Max: 20
+
+Metrics/MethodLength:
+  Max: 40
+
+Metrics/PerceivedComplexity:
+  Max: 15
+
+Naming/FileName:
+  Exclude:
+    - Rakefile
+
+RSpec/ExampleLength:
+  Max: 20
+
+RSpec/MultipleExpectations:
+  Max: 15
 
 Style/CommandLiteral:
   Enabled: false
 
+Style/CommentedKeyword:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/FrozenStringLiteralComment:
+  Enabled: false
+
 Style/PercentLiteralDelimiters:
   Enabled: false
 
 Style/RegexpLiteral:
   Enabled: false
 
+Style/StringConcatenation:
+  Exclude:
+    - spec/**/*
+
 Style/StringLiterals:
   Enabled: false
 
 Style/StringLiteralsInInterpolation:
   Enabled: false
+
+Style/TrailingCommaInHashLiteral:
+  EnforcedStyleForMultiline: comma

data/CHANGELOG.md

@@ -1,18 +1,42 @@
+## 2.0.18 / 2023-03-24
+  * The following are now parsed property:
+    `die_on_file_error`, `die_on_path_denied`, `die_on_run_error`, `die_on_path_denied`, and `die_on_other_error`.
+
+## 2.0.17 / 2023-03-22
+  * Added `repo` and `git_ref` parameters, so files can be retrieved from git repositories at a given commit or tag.
+
+## 2.0.16 / 2023-02-19
+  * Replaced hard-coded CSS in `denied` method with `flexible_error` class in
+    `demo/assets/css/style.css`.
+  * Added `-e` and `-x` options to `demo/_bin/debug`.
+  * Added configuration section `flexible_include` with supported parameters
+    `die_on_file_error`, `die_on_path_denied`, `die_on_run_error`,
+    `die_on_path_denied` and `die_on_other_error`.
+  * Fixed `undefined method 'path'` that occurred when `FLEXIBLE_INCLUDE_PATHS` was specified.
+
+## 2.0.15 / 2023-02-18
+  * Replaced dependency `key-value-parser` with `jekyll_plugin_support`.
+  * Added `demo` website.
+  * Improved the documentation.
+  * Updated Rubocop configuration.
+  * Added `strip` option.
+
 ## 2.0.14 / 2022-09-27
-  * Added `key-value-parser` as a dependency
+  * Added `key-value-parser` as a dependency.
 
 ## 2.0.13 / 2022-04-24
-  * Added `highlight` regex option, for highlighting
-  * Added `number` option, for numbered lines
+  * Added `highlight` regex option, for highlighting.
+  * Added `number` option, for numbered lines.
 
 ## 2.0.12 / 2022-04-22
-  * Exits with an error message if an environment variable included in the value of `FLEXIBLE_INCLUDE_PATHS` is undefined.
+  * Exits with an error message if an environment variable included in the value
+    of `FLEXIBLE_INCLUDE_PATHS` is undefined.
 
 ## 2.0.11 / 2022-04-15
-  * Added & => & to the escaped characters
+  * Added & => & to the escaped characters.
 
 ## 2.0.10 / 2022-04-15
-  * Fixed nil pointer
+  * Fixed nil pointer.
 
 ## 2.0.9 / 2022-04-15
   * Changed how path matching was implemented.
@@ -40,10 +64,11 @@
   * Updated to `jekyll_plugin_logger` v2.1.0
 
 ## 2.0.0 / 2022-03-11
-  * Made into a Ruby gem and published on RubyGems.org as [jekyll_flexible_include](https://rubygems.org/gems/jekyll_flexible_include).
-  * `bin/attach` script added for debugging
-  * Rubocop standards added
-  * Proper versioning and CHANGELOG.md added
+  * Made into a Ruby gem and published on RubyGems.org as
+    [jekyll_flexible_include](https://rubygems.org/gems/jekyll_flexible_include).
+  * `bin/attach` script added for debugging.
+  * Rubocop standards added.
+  * Proper versioning and CHANGELOG.md added.
 
 ## 1.1.1 / 2021-05-01
   * Handles spaces in filenames properly.
@@ -52,14 +77,14 @@
   * Added `do_not_escape` optional parameter.
 
 ## 1.0.0 / 2020-11-28
-  * Mike Slinn took over the project
-  * Now supports relative includes
+  * Mike Slinn took over the project.
+  * Now supports relative includes.
 
 ## 2020-11-28
-  * Renamed include_absolute to flexible_include
+  * Mike Slinn renamed `include_absolute` to `flexible_include`.
 
 ## 2020-08-23
-  * Now supports absolute paths
+  * Now supports absolute paths.
 
 ## 2022-03-11
-  * Project began
+  * Project began.

data/README.md

@@ -2,52 +2,115 @@ Jekyll `flexible_include` Plugin
 [![Gem Version](https://badge.fury.io/rb/jekyll_flexible_include.svg)](https://badge.fury.io/rb/jekyll_flexible_include)
 ===========
 
-`Flexible_include` is a Jekyll plugin that includes the contents of a file or the result of a process into a generated page. `Flexible_include` is useful because Jekyll's built-in `include` tag only supports the including of files residing within the `_includes/` subfolder of a Jekyll project, and because `flexible_include` offers additional ways of including content.
+`Flexible_include` is a Jekyll plugin that includes the contents of a file
+or the result of a process into a generated page.
+`Flexible_include` is useful because Jekyll's built-in `include` tag only
+supports the including of files residing within the `_includes/` subfolder of a Jekyll project,
+and because `flexible_include` offers additional ways of including content.
 
-Originally called  `include_absolute`, this plugin has been renamed to `flexible_include` because it no longer just includes absolute file names.
+Originally called  `include_absolute`,
+this plugin has been renamed to `flexible_include` because it no longer just
+includes absolute file names.
 
 This plugin is available as a [Ruby gem](https://rubygems.org/gems/jekyll_flexible_include).
 More information is available on my website about [my Jekyll plugins](https://www.mslinn.com/blog/2020/10/03/jekyll-plugins.html).
 
 This plugin supports 4 types of includes:
 
+
 ### Include Types
 
 1. Absolute filenames (recognized by filename paths that start with `/`).
-2. Filenames relative to the top-level directory of the Jekyll web site (relative paths **do not** start with `.` or `/`).
+
+2. Filenames relative to the top-level directory of the Jekyll website (relative paths **do not** start with `.` or `/`).
+
 3. Filenames relative to the user home directory (recognized by filename paths starting with `~/`).
+
 4. Executable filenames on the `PATH` (recognized by filename paths that begin with `!`).
 
 
-In addition, filenames that require environment expansion because they contain a <code>$</code> character are
-expanded according to the environment variables defined when <code>jekyll build</code> executes.
+In addition, filenames that require environment expansion because they contain a
+<code>$</code> character are expanded according to the environment variables
+defined when <code>jekyll build</code> executes.
 
 
-### Syntax
-The following are equivalent:
+A file from a git repository can also be included.
+Files can be retrieved from at a given commit or tag.
+Two new options are provided for this purpose:
+  - `repo` - directory where git repo resides; environment variables are expanded; defaults to current directory.
+  - `git_ref` - Git ref of commit or tag to be examined for the file; defaults to `HEAD`.
+
+
+### Configuration
+Configuration parameters can be added to a section in `_config.yml` called `flexible_include`, like this:
+
+```yaml
+flexible_include:
+  die_on_file_error: true
+  die_on_path_denied: true
+  die_on_run_error: true
+  die_on_other_error: true
 ```
+
+The default values for all of these parameters is `false`,
+except for `die_on_other_error`, which defaults to `true`.
+
+ - If `die_on_file_error` is enabled, then an attempt to include a file that fails will cause Jekyll to die with an error message.
+
+ - If `die_on_path_denied` is enabled (see [Restricting Directory Access](#restricting-directory-access)), then an attempt to include a file that should be blocked will cause Jekyll to die with an error message.
+
+ - If `die_on_run_error` is enabled, then an attempt to run a process that fails will cause Jekyll to die with an error message.
+
+ - If `die_on_other_error` is enabled, then any other exception will cause Jekyll to die with an error message.
+
+
+### Syntax
+The following are all equivalent, however, the first two are recommended:
+```html
+{% flexible_include file="path" [ OPTIONS ] %}
+{% flexible_include file='path' [ OPTIONS ] %}
 {% flexible_include path [ OPTIONS ] %}
 {% flexible_include 'path' [ OPTIONS ] %}
 {% flexible_include "path" [ OPTIONS ] %}
 ```
 
-By default, the included file will escape characters <code>&lt;</code>, <code>{</code> and <code>}</code>
-unless <code>do_not_escape</code> is specified.
-Note that the [square brackets] merely indicate optional parameters and are not intended to be written literally.
+Note that the [square brackets] merely indicate optional parameters
+and are not intended to be written literally.
+
 
 ### Options
-  * `do_not_escape` includes the content without HTML escaping it.
-  * `highlight='regex pattern here'` wraps content matching the regex pattern within a `<span class='bg_yellow'></span>` tag.
-  * `pre` causes the included file to be wrapped inside a &lt;pre>&lt;/pre> tag, no label is generated. The &lt;pre>&lt;/pre> tag has an `data-lt-active="false"` attribute, so [LanguageTool](https://forum.languagetool.org/t/avoid-spell-check-on-certain-html-inputs-manually/3944) does not check the spelling or grammar of the contents.
+  * `do_not_escape` keyword option caused the content to be included without HTML escaping it.
+    By default, the included file will escape characters <code>&lt;</code>,
+    <code>{</code> and <code>}</code> unless the <code>do_not_escape</code> keyword option is specified.
+
+  * `highlight='regex pattern here'` wraps content matching the regex pattern within a
+    `<span class='bg_yellow'></span>` tag.
+    Note that the pattern can simply consist of the exact text that you want to highlight.
+
+  * `pre` is a keyword option that causes the included file to be wrapped inside a
+    &lt;pre>&lt;/pre> tag; no label is generated.
+    The &lt;pre>&lt;/pre> tag has an `data-lt-active="false"` attribute, so
+    [LanguageTool](https://forum.languagetool.org/t/avoid-spell-check-on-certain-html-inputs-manually/3944)
+    will not attempt to check the spelling or grammar of the contents.
 
 The following options imply `pre`:
-  * `dark` applies the `dark` class to the generated &lt;pre>&lt;/pre> tag.
+  * `dark` keyword option applies the `dark` class to the generated &lt;pre>&lt;/pre> tag.
     You can define the `dark` and `darkLabel` classes as desired.
     [This CSS is a good starting point.](https://www.mslinn.com/blog/2020/10/03/jekyll-plugins.html#pre_css)
-  * `download` uses the name of the file as a label, and displays it above the &lt;pre>&lt;/pre> tag. Clicking the label causes the file to be downloaded.
-  * `copy_button` draws an icon at the top right of the &lt;pre>&lt;/pre> tag that causes the included contents to be copied to the clipboard.
-  * `label` specifies that an automatically generated label be placed above the contents. There is no need to specify this option if `download` or `copy_button` options are provided.
-  * `label="blah blah"` specifies a label for the contents; this value overrides the default label. The value can be enclosed in single or double quotes.
+
+  * `download` keyword option uses the name of the file as a label,
+    and displays it above the &lt;pre>&lt;/pre> tag.
+    Clicking the label causes the file to be downloaded.
+
+  * `copyButton` keyword option draws an icon at the top right of the &lt;pre>&lt;/pre>
+    tag that causes the included contents to be copied to the clipboard.
+
+  * `label` keyword option specifies that an automatically generated label be placed above the contents.
+    There is no need to specify this option if `download` or `copy_button` options are provided.
+
+  * `label="blah blah"` specifies a label for the contents; this value overrides the default label.
+    The value can be enclosed in single or double quotes.
+
 
 ### Restricting Directory Access
 By default, `flexible_include` can read from all directories according to the permissions of the user account that launched the `jekyll` process.
@@ -57,70 +120,97 @@ Defining an environment variable called `FLEXIBLE_INCLUDE_PATHS` prior to launch
 This environment variable consists of a colon-delimited set of
 [file and directory glob patterns](https://docs.ruby-lang.org/en/2.7.0/Dir.html#method-c-glob).
 For example, the following restricts access to only the files within:
+
  1. The `~/my_dir` directory tree of the account of the user that launched Jekyll.
+
  2. The directory tree rooted at `/var/files`.
+
  3. The directory tree rooted at the expanded value of the `$work` environment variable.
+
 ```shell
 export FLEXIBLE_INCLUDE_PATHS='~/.*:$sites/.*:$work/.*'
 ```
+
 Note that the above matches dot (hidden) files as well as regular files.
 To just match visible files:
+
 ```shell
 export FLEXIBLE_INCLUDE_PATHS='~/my_dir/**/*:/var/files/**/*:$work/**/*'
 ```
 
 #### Note
-The specified directories are traversed when the plugin starts, and the filenames are stored in memory. Directories with lots of files might take a noticable amount to time to enumerate the files.
+The specified directories are traversed when the plugin starts,
+and the filenames are stored in memory.
+Directories with lots of files might take a noticable amount of
+time to enumerate the files.
 
 
 ### Restricting Arbitrary Processes
-By default, `flexible_include` can execute any command. You can disable that by setting the environment variable `DISABLE_FLEXIBLE_INCLUDE` to any non-empty value.
+By default, `flexible_include` can execute any command.
+You can disable that by setting the environment variable `DISABLE_FLEXIBLE_INCLUDE`
+to any non-empty value.
 ```shell
 export DISABLE_FLEXIBLE_INCLUDE=true
 ```
 
-If a potential command execution is intercepted, a big red message will appear on the generated web page that says `Arbitrary command execution denied by DISABLE_FLEXIBLE_INCLUDE value.`, and a red error message will be logged on the console that says something like: `ERROR FlexibleInclude: _posts/2020/2020-10-03-jekyll-plugins.html - Arbitrary command execution denied by DISABLE_FLEXIBLE_INCLUDE value.`
+If a potential command execution is intercepted,
+a big red message will appear on the generated web page that says
+`Arbitrary command execution denied by DISABLE_FLEXIBLE_INCLUDE value.`,
+and a red error message will be logged on the console that says something like:
+`ERROR FlexibleInclude: _posts/2020/2020-10-03-jekyll-plugins.html - Arbitrary command execution denied by DISABLE_FLEXIBLE_INCLUDE value.`
 
 
 ## Installation
+1. Add the following to `Gemfile`, inside the `jekyll_plugins` group:
+   ```ruby
+   group :jekyll_plugins do
+     gem 'jekyll_flexible_include', '~> 2.0.15'
+   end
+   ```
 
-Add the following to `Gemfile`, inside the `jekyll_plugins` group:
-```
-group :jekyll_plugins do
-  gem 'jekyll_flexible_include', '~> 2.0.0'
-end
-```
+2. Add the following to `_config.yml`.
+   This is necessary because the name of the plugin
+   does not match the name of the entry point file:
+   ```yaml
+   plugins:
+     - flexible_include
+   ```
 
-Also add it to `_config.yml`:
-```yaml
-plugins:
-  - flexible_include
-```
+3. Copy `demo/assets/images/clippy.svg` to a directory that resolves to
+   `assets/images/` in your Jekyll website.
 
-And then execute:
+4. Copy the CSS from `demo/assets/css/styles.css` between the comments to your Jekyll project's CSS file:
+   ```css
+   blah blah blah
 
-    $ bundle install
+   /* START OF CSS TO COPY */
+   Copy this stuff
+   /* END OF CSS TO COPY */
 
-Or install it yourself as:
+   blah blah blah
+   ```
 
-    $ gem install jekyll_flexible_include
+5. Install the `jekyll_flexible_include` Ruby gem as usual:
+   ```shell
+   $ bundle install
+   ```
 
 
 ## Examples
 
-1. Include files, escaping any HTML markup so it appears as written; all four types of includes are shown.
+1. Include files, escaping any HTML markup, so it appears as written; all four types of includes are shown.
    ```
    {% flexible_include '../../folder/outside/jekyll/site/foo.html' %}
    {% flexible_include 'folder/within/jekyll/site/bar.js' %}
    {% flexible_include '/etc/passwd' %}
    {% flexible_include '~/.ssh/config' %}
-   {% flexible_include '!jekyll' %}
+   {% flexible_include '!jekyll help' %}
    {% flexible_include '$HOME/.bash_aliases' %}
    ```
 
 2. Include a JSON file (without escaping characters).
    ```
-   {% flexible_include '~/folder/under/home/directory/foo.html' do_not_escape %}
+   {% flexible_include do_not_escape file='~/folder/under/home/directory/foo.html' %}
    ```
 
 ## Additional Information
@@ -132,37 +222,43 @@ More information is available on
 GitHub Pages only allows [these plugins](https://pages.github.com/versions/).
 That means `flexible_include` will not work on GitHub Pages.
 Following is a workaround.
+
 1. Let's assume your git repository that you want to publish as GitHub Pages is called `mysite`.
    This repository cannot be the source of your GitHub Pages because you are using the `flexible_include` plugin.
+
 2. Make a new git repository to hold the generated website. Let's call this git repository `generated_site`.
+
 3. Generate `mysite` locally as usual.
+
 4. Copy the generated HTML in the `mysite/_site/` directory to `generated_site`.
+
 5. Run `git commit` on `generated_site`.
+
 6. Tell GitHub that you want the `generated_site` repository to hold your GitHub pages.
+
 7. A moment later, your website will now be visible as GitHub Pages, with the included content, just as you saw it locally.
 
 
 ## Known Issues
 If the plugin does not work:
-1. Ensure `_config.yml` doesn't have `safe: true`. That prevents all plugins from working.
-2. If you have version older than v2.x.x, delete the file `_plugins/flexible_include.rb` or you will have version conflicts.
 
+1. Ensure `_config.yml` doesn't have `safe: true` set.
+   That prevents all plugins from working.
 
-## Development
+2. If you have version older than v2.x.x,
+   delete the file `_plugins/flexible_include.rb`,
+   or you will have version conflicts.
 
-After checking out the repo, run `bin/setup` to install dependencies.
+
+## Development
+After checking out the repo, run `bin/setup` to install dependencies as binstubs in the `exe` directory.
 
 You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
 ### Build and Install Locally
 To build and install this gem onto your local machine, run:
 ```shell
-$ rake install:local
-```
-
-The following also does the same thing:
-```shell
-$ bundle exec rake install
+$ rake install
 ```
 
 Examine the newly built gem:
@@ -182,11 +278,59 @@ jekyll_flexible_include (2.0.4)
 ```
 
 
+## Demo Website
+A test/demo website is provided in the `demo` directory.
+You can run it under a debugger, or let it run free.
+
+The `demo/_bin/debug` script can set various parameters for the demo.
+View the help information with the `-h` option:
+```shell
+$ demo/_bin/debug -h
+
+debug - Run the demo Jekyll website.
+
+By default the demo Jekyll website runs without restriction under ruby-debug-ide and debase.
+View it at http://localhost:4444
+
+Options:
+  -e  Restrict the allowable directories to read from to the following regexes:
+        jekyll_flexible_include_plugin/.*
+        /dev/.*
+        /proc/.*
+        /run/.*
+
+  -h  Show this error message
+
+  -r  Run freely, without a debugger
+
+  -x  Disable the ability to execute arbitrary commands
+```
+
+
+### Debugging the Demo
+To run under a debugger, for example Visual Studio Code:
+ 1. Set breakpoints.
+
+ 2. Initiate a debug session from the command line:
+    ```shell
+    $ demo/bin/debug
+    ```
+
+  3. Once the `Fast Debugger` signon appears, launch the Visual Studio Code launch configuration called `Attach rdebug-ide`.
+
+  4. View the generated website at [`http://localhost:4444`](http://localhost:4444).
+
+
 ### Build and Push to RubyGems
 To release a new version,
+
   1. Update the version number in `version.rb`.
-  2. Commit all changes to git; if you don't the next step might fail with an unexplainable error message.
-  3. Run the following:
+
+  2. Add a comment to the top of `CHANGELOG.md`.
+
+  3. Commit all changes to git; if you don't the next step will fail.
+
+  4. Run the following:
      ```shell
      $ bundle exec rake release
      ```
@@ -195,12 +339,14 @@ To release a new version,
 
 
 ## Contributing
-
 1. Fork the project
+
 2. Create a descriptively named feature branch
+
 3. Add your feature
+
 4. Submit a pull request
 
-## License
 
+## License
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -1,7 +1,5 @@
-# frozen_string_literal: true
-
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
-task :default => :spec
+task default: :spec

data/jekyll_flexible_include_plugin.gemspec

@@ -1,12 +1,10 @@
-# frozen_string_literal: true
+require_relative 'lib/flexible_include/version'
 
-require_relative "lib/flexible_include/version"
+Gem::Specification.new do |spec| # rubocop:disable Metrics/BlockLength
+  github = 'https://github.com/mslinn/jekyll_flexible_include_plugin'
 
-Gem::Specification.new do |spec|
-  github = "https://github.com/mslinn/jekyll_flexible_include_plugin"
-
-  spec.authors = ["Mike Slinn", "Tan Nhu", "Maarten Brakkee"]
-  spec.bindir = "exe"
+  spec.authors = ['Mike Slinn', 'Tan Nhu', 'Maarten Brakkee']
+  spec.bindir = 'exe'
   spec.description = <<~END_OF_DESC
     Jekyll's built-in include tag only supports including files within the _includes folder.
     This plugin supports 4 types of includes: absolute filenames,
@@ -14,36 +12,29 @@ Gem::Specification.new do |spec|
     filenames relative to the user home directory,
     and executable filenames on the PATH.
   END_OF_DESC
-  spec.email = ["mslinn@mslinn.com"]
-  spec.files = Dir[".rubocop.yml", "LICENSE.*", "Rakefile", "{lib,spec}/**/*", "*.gemspec", "*.md"]
-  spec.homepage = "https://www.mslinn.com/blog/2020/10/03/jekyll-plugins.html#flexibleInclude"
-  spec.license = "MIT"
+  spec.email = ['mslinn@mslinn.com']
+  spec.files = Dir['.rubocop.yml', 'LICENSE.*', 'Rakefile', '{lib,spec}/**/*', '*.gemspec', '*.md']
+  spec.homepage = 'https://www.mslinn.com/blog/2020/10/03/jekyll-plugins.html#flexibleInclude'
+  spec.license = 'MIT'
   spec.metadata = {
-    "allowed_push_host" => "https://rubygems.org",
-    "bug_tracker_uri"   => "#{github}/issues",
-    "changelog_uri"     => "#{github}/CHANGELOG.md",
-    "homepage_uri"      => spec.homepage,
-    "source_code_uri"   => github,
+    'allowed_push_host' => 'https://rubygems.org',
+    'bug_tracker_uri'   => "#{github}/issues",
+    'changelog_uri'     => "#{github}/CHANGELOG.md",
+    'homepage_uri'      => spec.homepage,
+    'source_code_uri'   => github,
   }
-  spec.name = "jekyll_flexible_include"
+  spec.name = 'jekyll_flexible_include'
   spec.post_install_message = <<~END_MESSAGE
 
     Thanks for installing #{spec.name}!
 
   END_MESSAGE
-  spec.require_paths = ["lib"]
-  spec.required_ruby_version = ">= 2.6.0"
-  spec.summary = "Jekyll plugin supports various ways to include content into the generated site."
+  spec.require_paths = ['lib']
+  spec.required_ruby_version = '>= 2.6.0'
+  spec.summary = 'Jekyll plugin supports various ways to include content into the generated site.'
   spec.test_files = spec.files.grep(%r!^(test|spec|features)/!)
   spec.version = JekyllFlexibleIncludePluginVersion::VERSION
 
-  spec.add_dependency "jekyll", ">= 3.5.0"
-  spec.add_dependency "jekyll_plugin_logger", '~> 2.1.0'
-  spec.add_dependency "key-value-parser"
-
-  # spec.add_development_dependency "debase"
-  # spec.add_development_dependency "rubocop-jekyll"
-  # spec.add_development_dependency "rubocop-rake"
-  # spec.add_development_dependency "rubocop-rspec"
-  # spec.add_development_dependency "ruby-debug-ide"
+  spec.add_dependency 'jekyll_plugin_support', '~> 0.5.1'
+  spec.add_dependency 'rugged'
 end

data/lib/flexible_include/version.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module JekyllFlexibleIncludePluginVersion
-  VERSION = "2.0.14"
+  VERSION = '2.0.18'.freeze
 end

data/lib/flexible_include.rb

@@ -1,170 +1,224 @@
-# frozen_string_literal: true
-
-require "benchmark"
-require "jekyll"
-require "jekyll_plugin_logger"
-require "securerandom"
-require_relative "flexible_include/version"
-require_relative "jekyll_tag_helper"
+require 'benchmark'
+require 'jekyll_plugin_support'
+require 'securerandom'
+require_relative 'flexible_include/version'
 
 module JekyllFlexibleIncludeName
-  PLUGIN_NAME = "flexible_include"
-end
-
-class FlexibleError < StandardError
+  PLUGIN_NAME = 'flexible_include'.freeze
 end
 
-class FlexibleInclude < Liquid::Tag
-  FlexibleIncludeError = Class.new(Liquid::Error)
-
-  @read_regexes = nil
+module FlexibleClassMethods
+  def access_allowed(path)
+    return true unless @read_regexes
 
-  def self.normalize_path(path)
-    JekyllTagHelper.expand_env(path, die_if_undefined: true)
-                   .gsub("~", Dir.home)
+    @read_regexes.find { |regex| regex.match(normalize_path(path)) }
   end
 
-  # If FLEXIBLE_INCLUDE_PATHS='~/lib/.*:.*:$WORK/.*'
-  # Then @read_regexes will be set to regexes of ["/home/my_user_id/lib/.*", "/pwd/.*", "/work/envar/path/.*"]
-  def self.security_check
-    @execution_denied = ENV['DISABLE_FLEXIBLE_INCLUDE']
-
-    unless @read_regexes
-      flexible_include_paths = ENV['FLEXIBLE_INCLUDE_PATHS']
-      read_paths = normalize_path(flexible_include_paths) if flexible_include_paths
-      if read_paths
-        @read_regexes = read_paths.split(":").map do |path|
-          abs_path = path.start_with?('/') ? path : (Pathname.new(Dir.pwd) + path).to_s
-          Regexp.new(abs_path)
-        end
-      end
-    end
+  def self.escape_html(string)
+    string.gsub("&", "&amp;")
+          .gsub("{", "&#123;")
+          .gsub("}", "&#125;")
+          .gsub("<", "&lt;")
   end
 
-  def self.access_allowed(path)
-    return true unless @read_regexes
-
-    @read_regexes.find { |regex| regex.match(normalize_path(path)) }
+  def normalize_path(path)
+    JekyllPluginHelper.expand_env(path, die_if_undefined: true)
+                      .gsub('~', Dir.home)
   end
 
-  def self.number_content(content)
+  def number_content(content)
     lines = content.split("\n")
     digits = lines.length.to_s.length
     i = 0
     numbered_content = lines.map do |line|
       i += 1
-      number = i.to_s.rjust(digits, " ")
+      number = i.to_s.rjust(digits, ' ')
       "<span class='unselectable numbered_line'> #{number}: </span>#{line}"
     end
-    result = numbered_content.join("\n")
-    result += "\n" unless result.end_with?("\n")
+    result = numbered_content.join "\n"
+    result += "\n" unless result.end_with? "\n"
     result
   end
 
-  # @param tag_name [String] the name of the tag, which we already know.
-  # @param markup [String] the arguments from the tag, as a single string.
-  # @param parse_context [Liquid::ParseContext] hash that stores Liquid options.
-  #        By default it has two keys: :locale and :line_numbers, the first is a Liquid::I18n object, and the second,
-  #        a boolean parameter that determines if error messages should display the line number the error occurred.
-  #        This argument is used mostly to display localized error messages on Liquid built-in Tags and Filters.
-  #        See https://github.com/Shopify/liquid/wiki/Liquid-for-Programmers#create-your-own-tags
-  def initialize(tag_name, markup, _parse_context)
-    super
-    @logger = PluginMetaLogger.instance.new_logger(self, PluginMetaLogger.instance.config)
-    @helper = JekyllTagHelper.new(tag_name, markup, @logger)
+  # If FLEXIBLE_INCLUDE_PATHS='~/lib/.*:.*:$WORK/.*'
+  # Then @read_regexes will be set to regexes of ['/home/my_user_id/lib/.*', '/pwd/.*', '/work/envar/path/.*']
+  def security_check
+    @execution_denied = ENV.fetch('DISABLE_FLEXIBLE_INCLUDE', nil)
 
-    self.class.security_check
-  end
+    return if @read_regexes
 
-  # @param liquid_context [Liquid::Context]
-  def render(liquid_context) # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/MethodLength, Metrics/CyclomaticComplexity
-    @helper.liquid_context = liquid_context
-    @do_not_escape = @helper.parameter_specified? "do_not_escape"
-    @download = @helper.parameter_specified? "download"
-    @dark = " dark" if @helper.parameter_specified?("dark")
-    @highlight_pattern = @helper.parameter_specified? "highlight"
-    @label = @helper.parameter_specified? "label"
-    @number_lines = @helper.parameter_specified? "number"
-    @label_specified = @label
-    @copy_button = @helper.parameter_specified? "copyButton"
-    @pre = @copy_button || @dark || @download || @label_specified || @number_lines || @helper.parameter_specified?("pre") # Download or label implies pre
+    flexible_include_paths = ENV.fetch('FLEXIBLE_INCLUDE_PATHS', nil)
+    read_paths = normalize_path(flexible_include_paths) if flexible_include_paths
+    return unless read_paths
 
-    filename = @helper.parameter_specified? "file"
-    filename ||= @helper.params.first # Do this after all options have been checked for
-    @label ||= filename
+    @read_regexes = read_paths.split(':').map do |path|
+      abs_path = path.start_with?('/') ? path : (Pathname.new(Dir.pwd) + path).to_s
+      Regexp.new(abs_path)
+    end
+  end
+end
 
-    # If a label was specified, use it, otherwise concatenate any dangling parameters and use that as the label
-    @label ||= @helper.params[1..].join(" ")
+FlexibleIncludeError = Class.new(Liquid::Error)
 
-    @logger.debug("filename=#{filename}")
+class FlexibleInclude < JekyllSupport::JekyllTag # rubocop: disable Metrics/ClassLength
+  include JekyllFlexibleIncludePluginVersion
 
-    path = JekyllTagHelper.expand_env(filename)
+  def render_impl # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    setup
+    path = JekyllPluginHelper.expand_env(@filename)
     case path
     when /\A\// # Absolute path
-      return denied("Access to #{path} denied by FLEXIBLE_INCLUDE_PATHS value.") unless self.class.access_allowed(path)
+      return denied("Access to <code>#{path}</code> denied by <code>FLEXIBLE_INCLUDE_PATHS</code> value.") unless self.class.access_allowed(path)
 
-      @logger.debug { "Absolute path=#{path}, filename=#{filename}" }
+      @logger.debug { "Absolute path=#{path}, @filename=#{@filename}" }
     when /\A~/ # Relative path to user's home directory
-      return denied("Access to #{path} denied by FLEXIBLE_INCLUDE_PATHS value.") unless self.class.access_allowed(path)
+      return denied("Access to <code>#{path}</code> denied by <code>FLEXIBLE_INCLUDE_PATHS</code> value.") unless self.class.access_allowed(path)
 
-      @logger.debug { "User home start filename=#{filename}, path=#{path}" }
-      filename.slice! "~/"
-      path = File.join(ENV['HOME'], filename)
-      @logger.debug { "User home end filename=#{filename}, path=#{path}" }
+      @logger.debug { "User home start @filename=#{@filename}, path=#{path}" }
+      @filename = @filename.delete_prefix '~/'
+      path = File.join(Dir.home, @filename)
+      @logger.debug { "User home end @filename=#{@filename}, path=#{path}" }
     when /\A!/ # Run command and return response
-      return denied("Arbitrary command execution denied by DISABLE_FLEXIBLE_INCLUDE value.") if @execution_denied
+      return denied('Arbitrary command execution denied by DISABLE_FLEXIBLE_INCLUDE value.') if @execution_denied
 
-      filename = JekyllTagHelper.remove_quotes(@helper.argv.first) if @helper.argv.first
-      filename.slice! "!"
-      contents = run(filename)
+      @filename = JekyllPluginHelper.remove_quotes(@helper.argv.first) if @helper.argv.first
+      @filename = @filename.delete_prefix '!'
+      contents = run(@filename)
     else # Relative path
-      site = liquid_context.registers[:site]
-      source = File.expand_path(site.config['source']) # website root directory
-      path = File.join(source, filename) # Fully qualified path of include file from relative path
+      source = File.expand_path(@site.config['source']) # website root directory
+      path = File.join(source, @filename) # Fully qualified path of include file from relative path
       @relative = true
-      @logger.debug { "Relative end filename=#{filename}, path=#{path}" }
+      @logger.debug { "Relative end @filename=#{@filename}, path=#{path}" }
     end
     render_completion(path, contents)
-    # rescue StandardError => e
-    #   raise FlexibleIncludeError, e.message.red, [] # Suppress stack trace
+  rescue Errno::EACCES => e
+    msg = format_error_message e.message
+    @logger.error msg
+    raise FlexibleIncludeError, msg, [] if @die_on_file_error
+
+    "<span class='flexible_error'>FlexibleIncludeError: #{msg}</span>"
+  rescue Errno::ENOENT => e
+    msg = format_error_message e.message
+    @logger.error msg
+    raise FlexibleIncludeError, msg, [] if @die_on_path_denied
+
+    "<span class='flexible_error'>FlexibleIncludeError: #{msg}</span>"
+  rescue FlexibleIncludeError => e
+    @logger.error e.message
+    raise e
+  rescue StandardError => e
+    msg = format_error_message e.message
+    @logger.error msg
+    raise FlexibleIncludeError, msg, [] if @die_on_other_error
+
+    "<span class='flexible_error'>FlexibleIncludeError: #{msg}</span>"
   end
 
   private
 
+  class << self
+    include FlexibleClassMethods
+  end
+
   def denied(msg)
-    @logger.error("#{@helper.page.path} - #{msg}")
-    "<p style='color: white; background-color: red; padding: 2pt 1em 2pt 1em;'>#{msg}</p>"
+    msg_no_html = remove_html_tags(msg)
+    @logger.error("#{@page['path']} - #{msg_no_html}")
+    raise FlexibleIncludeError, "#{@page['path']} - #{msg_no_html.red}", [] if @die_on_path_denied
+
+    "<p class='flexible_error'>#{msg}</p>"
+  end
+
+  def format_error_message(message)
+    "#{message} on line #{@line_number} (after front matter) of #{@page['path']}}"
   end
 
   def highlight(content, pattern)
-    content.gsub(Regexp::new(pattern), "<span class='bg_yellow'>\\0</span>")
+    content.gsub(Regexp.new(pattern), "<span class='bg_yellow'>\\0</span>")
   end
 
-  def read_file(file)
-    File.read(file)
+  def parse_args
+    @copy_button = @helper.parameter_specified? 'copyButton'
+    @dark = ' dark' if @helper.parameter_specified? 'dark'
+    @do_not_escape = @helper.parameter_specified? 'do_not_escape'
+    @download = @helper.parameter_specified? 'download'
+    @highlight_pattern = @helper.parameter_specified? 'highlight'
+    @label = @helper.parameter_specified? 'label'
+    @label_specified = @label
+    @number_lines = @helper.parameter_specified? 'number'
+    @strip = @helper.parameter_specified? 'strip'
+
+    # Download, dark, label or number implies pre
+    @pre = @helper.parameter_specified?('pre') || @copy_button || @dark || @download || @label_specified || @number_lines
+
+    @filename = @helper.parameter_specified? 'file'
+    @filename ||= @helper.params.first # Do this after all options have been checked for
+    @label ||= @filename
+
+    # If a label was specified, use it, otherwise concatenate any dangling parameters and use that as the label
+    @label ||= @helper.params[1..].join(' ')
+
+    @logger.debug("@filename=#{@filename}")
   end
 
+  # Not used, delete
   def realpath_prefixed_with?(path, dir)
     File.exist?(path) && File.realpath(path).start_with?(dir)
-  rescue StandardError
-    false
+  rescue StandardError => _e
+    raise FlexibleIncludeError, remove_html_tags(e.message).red, [] if @die_on_file_error
+  end
+
+  def remove_html_tags(string)
+    string.gsub(/<[^>]*>/, '')
   end
 
   def render_completion(path, contents)
-    contents ||= read_file(path)
-    contents2 = @do_not_escape ? contents : JekyllTagHelper.escape_html(contents)
+    contents ||= File.read(path)
+    contents.strip! if @strip
+    contents2 = @do_not_escape ? contents : FlexibleClassMethods.escape_html(contents)
     contents2 = highlight(contents2, @highlight_pattern) if @highlight_pattern
     contents2 = FlexibleInclude.number_content(contents2) if @number_lines
     @pre ? wrap_in_pre(path, contents2) : contents2
   end
 
   def run(cmd)
-    @logger.debug { "Executing filename=#{cmd}" }
+    if cmd.empty?
+      msg = format_error_message 'FlexibleIncludeError: Empty command string'
+      @do_not_escape = true
+      return "<span class='flexible_error'>#{msg}</span>" unless @die_on_other_error
+
+      raise FlexibleIncludeError, msg, []
+    end
+
+    @logger.debug { "Executing #{cmd}" }
     %x[#{cmd}].chomp
+  rescue FlexibleIncludeError => e
+    raise e
+  rescue StandardError => e
+    msg = format_error_message "#{e.class}: #{e.message.strip}"
+    @logger.error msg
+    @do_not_escape = true
+    return "<span class='flexible_error'>#{msg}</span>" unless @die_on_run_error
+
+    e.set_backtrace []
+    raise e
+  end
+
+  def setup
+    self.class.security_check
+
+    config = @config[JekyllFlexibleIncludeName::PLUGIN_NAME]
+    if config
+      @die_on_file_error  = config['die_on_file_error'] == true
+      @die_on_other_error = config['die_on_other_error'] == true
+      @die_on_path_denied = config['die_on_path_denied'] == true
+      @die_on_run_error   = config['die_on_run_error'] == true
+    end
+
+    parse_args
   end
 
-  PREFIX = "<button class='copyBtn' data-clipboard-target="
-  SUFFIX = "title='Copy to clipboard'><img src='/assets/images/clippy.svg' alt='Copy to clipboard' style='width: 13px'></button>"
+  PREFIX = "<button class='copyBtn' data-clipboard-target=".freeze
+  SUFFIX = "title='Copy to clipboard'><img src='/assets/images/clippy.svg' alt='Copy to clipboard' style='width: 13px'></button>".freeze
 
   def wrap_in_pre(path, content)
     basename = File.basename(path)
@@ -178,14 +232,13 @@ class FlexibleInclude < Liquid::Tag
                       @label_specified ? @label : basename
                     end
     pre_id = "id#{SecureRandom.hex 6}"
-    copy_button = @copy_button ? "#{PREFIX}'##{pre_id}'#{SUFFIX}" : ""
-    dark_label = " darkLabel" if @dark
+    copy_button = @copy_button ? "#{PREFIX}'##{pre_id}'#{SUFFIX}" : ''
+    dark_label = ' darkLabel' if @dark
     <<~END_PRE
       <div class="codeLabel#{dark_label}">#{label_or_href}</div>
       <pre data-lt-active="false" class="maxOneScreenHigh copyContainer#{@dark}" id="#{pre_id}">#{copy_button}#{content}</pre>
     END_PRE
   end
-end
 
-PluginMetaLogger.instance.info { "Loaded #{JekyllFlexibleIncludeName::PLUGIN_NAME} v#{JekyllFlexibleIncludePluginVersion::VERSION} plugin." }
-Liquid::Template.register_tag('flexible_include', FlexibleInclude)
+  JekyllPluginHelper.register(self, 'flexible_include')
+end

data/lib/git_util.rb

@@ -0,0 +1,41 @@
+require 'rugged'
+
+class GitFileReader
+  def initialize(repo_dir = '.')
+    @repo = Rugged::Repository.new repo_dir
+  end
+
+  def blob_at(ref, path)
+    commit = @repo.rev_parse ref # Rugged::Commit
+    @repo.blob_at(commit.oid, path) # Rugged::Blob
+  end
+
+  def commit_for_ref(ref)
+    reference = @repo.ref ref # Rugged::Reference
+    abort "Error: #{ref} is an invalid ref" if reference.nil?
+
+    reference_direct = reference.type == :symbolic ? reference.target : reference
+    @commit = reference_direct.target # Rugged::Commit
+    self
+  end
+
+  # @return content of desired file
+  def contents(filename)
+    abort('Error: @commit is undefined; invoke commit_for_ref before invoking contents') if @commit.nil?
+
+    tree = @commit.tree # Rugged::Tree
+    entry = tree.get_entry filename # hash
+    abort("Error: #{filename} is not present in commit #{commit.oid}") if entry.nil?
+
+    sha = entry[:oid] # String
+    object = @repo.read sha # Rugged::ObdObject; this is a blob
+    object.data # String
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  puts GitFileReader.new('.').blob_at('HEAD~2', 'README.md').content
+  # puts GitFileReader.new('.').commit_for_ref('HEAD^').contents('README.md')
+  # puts GitFileReader.new('.').commit_for_ref('HEAD').contents('README.md')
+  # puts GitFileReader.new('.').commit_for_ref('refs/heads/master').contents('README.md')
+end

data/spec/flexible_include_spec.rb

@@ -0,0 +1,18 @@
+require_relative '../lib/flexible_include'
+
+RSpec.describe(FlexibleInclude) do
+  it 'controls access to files' do
+    ENV['FLEXIBLE_INCLUDE_PATHS'] = '~/.*:spec/.*'
+
+    described_class.send(:new, 'my_tag', '', Liquid::ParseContext.new)
+    described_class.security_check
+    expect(described_class.access_allowed(__FILE__)).to be_truthy
+
+    expect(described_class.access_allowed('~/.mem_settings.yaml')).to be_truthy
+
+    home_file = JekyllTagHelper.expand_env('$HOME/.mem_settings.yaml')
+    expect(described_class.access_allowed(home_file)).to be_truthy
+
+    expect(described_class.access_allowed('/asdf')).to be_falsey
+  end
+end

data/spec/spec_helper.rb

@@ -1,16 +1,14 @@
-# frozen_string_literal: true
+require 'jekyll'
 
-require "jekyll"
-
-require_relative "../lib/flexible_include"
+require_relative '../lib/flexible_include'
 
 Jekyll.logger.log_level = :info
 
 RSpec.configure do |config|
   config.filter_run :focus
-  config.order = "random"
+  config.order = 'random'
   config.run_all_when_everything_filtered = true
 
   # See https://relishapp.com/rspec/rspec-core/docs/command-line/only-failures
-  config.example_status_persistence_file_path = "spec/status_persistence.txt"
+  config.example_status_persistence_file_path = 'spec/status_persistence.txt'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jekyll_flexible_include
 version: !ruby/object:Gem::Version
-  version: 2.0.14
+  version: 2.0.18
 platform: ruby
 authors:
 - Mike Slinn
@@ -10,38 +10,24 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-09-27 00:00:00.000000000 Z
+date: 2023-03-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: jekyll
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.5.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.5.0
-- !ruby/object:Gem::Dependency
-  name: jekyll_plugin_logger
+  name: jekyll_plugin_support
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.1.0
+        version: 0.5.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.1.0
+        version: 0.5.1
 - !ruby/object:Gem::Dependency
-  name: key-value-parser
+  name: rugged
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -73,8 +59,8 @@ files:
 - jekyll_flexible_include_plugin.gemspec
 - lib/flexible_include.rb
 - lib/flexible_include/version.rb
-- lib/jekyll_tag_helper.rb
-- spec/glob_spec.rb
+- lib/git_util.rb
+- spec/flexible_include_spec.rb
 - spec/spec_helper.rb
 - spec/status_persistence.txt
 homepage: https://www.mslinn.com/blog/2020/10/03/jekyll-plugins.html#flexibleInclude
@@ -110,7 +96,7 @@ specification_version: 4
 summary: Jekyll plugin supports various ways to include content into the generated
   site.
 test_files:
-- spec/glob_spec.rb
+- spec/flexible_include_spec.rb
 - spec/spec_helper.rb
 - spec/status_persistence.txt
 ...

data/lib/jekyll_tag_helper.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-require "shellwords"
-require 'key_value_parser'
-
-class JekyllTagHelper
-  attr_reader :argv, :liquid_context, :logger, :params, :tag_name
-
-  def self.escape_html(string)
-    string.gsub("&", "&")
-          .gsub("{", "{")
-          .gsub("}", "}")
-          .gsub("<", "&lt;")
-  end
-
-  # Expand a environment variable reference
-  def self.expand_env(str, die_if_undefined=false)
-    str.gsub(/\$([a-zA-Z_][a-zA-Z0-9_]*)|\${\g<1>}|%\g<1>%/) do
-      envar = Regexp.last_match(1)
-      raise FlexibleError, "flexible_include error: #{envar} is undefined".red, [] if !ENV.key?(envar) && die_if_undefined # Suppress stack trace
-      ENV[envar]
-    end
-  end
-
-  # strip leading and trailing quotes if present
-  def self.remove_quotes(string)
-    string.strip.gsub(/\A'|\A"|'\Z|"\Z/, '').strip if string
-  end
-
-  def initialize(tag_name, markup, logger)
-    @tag_name = tag_name
-    @argv = Shellwords.split(markup)
-    @keys_values = KeyValueParser.new.parse(@argv) # Hash[Symbol, String|Boolean]
-    @logger = logger
-    @logger.debug { "@keys_values='#{@keys_values}'" }
-  end
-
-  def delete_parameter(name)
-    @params.delete(name)
-    @argv.delete_if { |x| x.start_with? name }
-    @keys_values.delete(name.to_sym)
-  end
-
-  # @return if parameter was specified, returns value and removes it from the available tokens
-  def parameter_specified?(name)
-    value = @keys_values[name.to_sym]
-    delete_parameter(name)
-    value
-  end
-
-  PREDEFINED_SCOPE_KEYS = [:include, :page].freeze
-
-  # Finds variables defined in an invoking include, or maybe somewhere else
-  # @return variable value or nil
-  def dereference_include_variable(name)
-    @liquid_context.scopes.each do |scope|
-      next if PREDEFINED_SCOPE_KEYS.include? scope.keys.first
-
-      value = scope[name]
-      return value if value
-    end
-    nil
-  end
-
-  # @return value of variable, or the empty string
-  def dereference_variable(name)
-    value = @liquid_context[name] # Finds variables named like 'include.my_variable', found in @liquid_context.scopes.first
-    value ||= @page[name] if @page # Finds variables named like 'page.my_variable'
-    value ||= dereference_include_variable(name)
-    value ||= ""
-    value
-  end
-
-  # Sets @params by replacing any Liquid variable names with their values
-  def liquid_context=(context)
-    @liquid_context = context
-    @params = @keys_values.map { |k, _v| lookup_variable(k) }
-  end
-
-  def lookup_variable(symbol)
-    string = symbol.to_s
-    return string unless string.start_with?("{{") && string.end_with?("}}")
-
-    dereference_variable(string.delete_prefix("{{").delete_suffix("}}"))
-  end
-
-  def page
-    @liquid_context.registers[:page]
-  end
-end

data/spec/glob_spec.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../lib/flexible_include"
-
-RSpec.describe(FlexibleInclude) do
-  it "controls access to files" do
-    ENV['FLEXIBLE_INCLUDE_PATHS'] = '~/.*:spec/.*'
-
-    FlexibleInclude.send(:new, 'my_tag', "", Liquid::ParseContext.new)
-    FlexibleInclude.security_check
-    expect(FlexibleInclude.access_allowed(__FILE__)).to be_truthy
-
-    expect(FlexibleInclude.access_allowed("~/.mem_settings.yaml")).to be_truthy
-
-    home_file = JekyllTagHelper.expand_env("$HOME/.mem_settings.yaml")
-    expect(FlexibleInclude.access_allowed(home_file)).to be_truthy
-
-    expect(FlexibleInclude.access_allowed('/asdf')).to be_falsey
-  end
-end