jekyll_from_to_until 1.0.3 → 1.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e9c06080cf832cfcda1eb6c9cd671885c26f512947574df19e6a6ac1fe5c35a
-  data.tar.gz: dd4b79b63729f6317cee948f042ce2988668115b9a0a90c654e95518c9902f1f
+  metadata.gz: 1a9e56c1266c423bdcca5f7fc1a5bfbd88038b3b7c92fbb84f0d05f73041f091
+  data.tar.gz: 6526b906d36f9937f63d0e81211dad42bec006eda5ec1cf62b286168925c489a
 SHA512:
-  metadata.gz: e9586ed9c90b47badb95791248aee4b8774b7c335314881902182f499be6afb173cdc085925186c164bb2bdc77192546ede605579cc39cf3b2b58f5a62f23ddd
-  data.tar.gz: f662add178d12e1be22f3595781e974908c6d0b637d78af8d2abd6c03aadc3b6918e4c115723bd5ebaf67966196b969569869695fb3191efea5fe48974acb44e
+  metadata.gz: b8a0f1ec7d9032e98edc3bd6729a1037b9884fb7b1ef7614f8b9f53045f5d223cf4615588d3f62c9fa604daeef8e06dc03d371fe452b34df6152c2545d8e3cab
+  data.tar.gz: 7a3621381e1d6bc4258728b98520087d8954035cfceecc2932885f77f6f87879f2d8d163f7fd07552a68ec134ded6b0b6a7e206382e979bacf06e57315a889ca

data/.rubocop.yml

@@ -11,11 +11,11 @@ require:
 AllCops:
   Exclude:
     - demo/_site/**/*
+    - binstub/**/*
     - exe/**/*
     - vendor/**/*
     - Gemfile*
   NewCops: enable
-  TargetRubyVersion: 2.6
 
 Gemspec/DeprecatedAttributeAssignment:
   Enabled: false
@@ -23,6 +23,9 @@ Gemspec/DeprecatedAttributeAssignment:
 Gemspec/RequireMFA:
   Enabled: false
 
+Gemspec/RequiredRubyVersion:
+  Enabled: false
+
 Layout/HashAlignment:
   EnforcedColonStyle: table
   Exclude:

data/CHANGELOG.md

@@ -1,18 +1,45 @@
+# Change Log
+
+## 1.0.5 / 2024-08-22
+
+* Fixed method forwarding
+* Regexes are now subjected to an HTML unescape, so special characters are now supported,
+  such as the right closing squiggly bracket:
+
+   ```html
+   {{ css | from: '.error' | to: '}' | strip }}
+   ```
+
+
+## 1.0.4 / 2023-11-18
+
+* Now callable from any Ruby program
+
+
 ## 1.0.3 / 2023-02-25
-  * Fixed `undefined method 'registers' for nil:NilClass (NoMethodError)`
+
+* Fixed `undefined method 'registers' for nil:NilClass (NoMethodError)`
+
 
 ## 1.0.2 / 2023-02-21
-  * Improved how the logger was used.
-  * Added `demo` website
+
+* Improved how the logger was used.
+* Added `demo` website
+
 
 ## 1.0.1 / 2022-04-05
-  * Updated to `jekyll_plugin_logger` v2.1.0
+
+* Updated to `jekyll_plugin_logger` v2.1.0
+
 
 ## 1.0.0 / 2022-03-14
-  * Made into a Ruby gem and published on RubyGems.org as [jekyll_from_to_until](https://rubygems.org/gems/jekyll_from_to_until).
-  * `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_from_to_until](https://rubygems.org/gems/jekyll_from_to_until).
+* `bin/attach` script added for debugging
+* Rubocop standards added
+* Proper versioning and CHANGELOG.md added
+
 
 ## 0.1.0 / 2020-12-29
-  * Initial version published
+
+* Initial version published

data/README.md

@@ -1,65 +1,119 @@
-`jekyll_from_to_until`
-[![Gem Version](https://badge.fury.io/rb/jekyll_from_to_until.svg)](https://badge.fury.io/rb/jekyll_from_to_until)
-===========
+# `jekyll_from_to_until` [![Gem Version](https://badge.fury.io/rb/jekyll_from_to_until.svg)](https://badge.fury.io/rb/jekyll_from_to_until)
 
-This Jekyll plugin provides 3 filters that return portions of a multiline string.
-Regular expression is used to specify matches; the simplest regular expression is a string.
- * `from` — returns the portion beginning with the line that satisfies a regular expression to the end of the multiline string.
- * `to` — returns the portion from the first line to the line that satisfies a regular expression, including the matched line.
- * `until` — returns the portion from the first line to the line that satisfies a regular expression, excluding the matched line.
+This module provides 3 filters that return portions of a multiline string.
+It can be used as a Jekyll plugin, or it can be called from any Ruby program.
+
+Matches are specified by regular expressions; the simplest regular expression is a string.
+
+* `from` — returns the portion beginning with the line that satisfies a regular expression to the end of the multiline string.
+* `to` — returns the portion from the first line to the line that satisfies a regular expression, including the matched line.
+* `until` — returns the portion from the first line to the line that satisfies a regular expression, excluding the matched line.
 
  [Rubular](https://rubular.com/) is a handy online tool to try out regular expressions.
 
 
-### Additional Information
-More information is available on my web site about [my Jekyll plugins](https://www.mslinn.com/blog/2020/10/03/jekyll-plugins.html).
+## Additional Information
+
+More information is available on the [`jekyll_from_to_until` gem web page](https://www.mslinn.com/jekyll_plugins/jekyll_from_to_until.html).
 
 
 ## Installation
 
-Add this line to your application's Gemfile:
+### As a Jekyll Filter Plugin
+
+If you want to use this Ruby gem in a Jekyll application,
+add the following line to your application's `Gemfile`:
 
 ```ruby
-gem 'jekyll_from_to_until'
+group :jekyll_plugins do
+  gem 'jekyll_from_to_until'
+end
 ```
 
 And then install in the usual fashion:
 
-    $ bundle install
+```shell
+$ bundle
+```
+
+### As a Dependency Of a Gem
+
+Add the following line to your application's `.gemspec`:
+
+```ruby
+spec.add_dependency 'jekyll_from_to_until'
+```
+
+And then install the dependencies in the usual fashion:
+
+```shell
+$ bundle
+```
 
+### As a Ruby Module In a Ruby Program
+
+Add the following line to your application's `Gemfile`:
+
+```ruby
+gem 'jekyll_from_to_until'
+```
+
+And then install the dependencies in the usual fashion:
+
+```shell
+$ bundle
+```
+
+
+## Jekyll Syntax
 
-## Syntax
 The regular expression may be enclosed in single quotes, double quotes, or nothing.
 
+
 ### `from`
+
 All of these examples perform identically.
-```
+
+```html
 {{ sourceOfLines | from: 'regex' }}
 {{ sourceOfLines | from: "regex" }}
 {{ sourceOfLines | from: regex }}
 ```
 
 ### `to`
+
 All of these examples perform identically.
-```
+
+```html
 {{ sourceOfLines | to: 'regex' }}
 {{ sourceOfLines | to: "regex" }}
 {{ sourceOfLines | to: regex }}
 ```
 
 ### `until`
+
 All of these examples perform identically.
-```
+
+```text
 {{ sourceOfLines | until: 'regex' }}
 {{ sourceOfLines | until: "regex" }}
 {{ sourceOfLines | until: regex }}
 ```
-:warning: Important: the name of the filter must be followed by a colon (:). If you fail to do that an error will be generated and the Jekyll site building process will halt. The error message looks something like this: `Liquid Warning: Liquid syntax error (line 285): Expected end_of_string but found string in "{{ lines | from '2' | until: '4' | xml_escape }}" in /some_directory/some_files.html Liquid Exception: Liquid error (line 285): wrong number of arguments (given 1, expected 2) in /some_directory/some_file.html Error: Liquid error (line 285): wrong number of arguments (given 1, expected 2)`
-## Usage
+
+:warning: Important: the name of the filter must be followed by a colon (:).
+If you fail to do that an error will be generated and the Jekyll site building process will halt.
+The error message looks something like this:
+`Liquid Warning: Liquid syntax error (line 285): Expected end_of_string but found string in
+"{{ lines | from '2' | until: '4' | xml_escape }}" in /some_directory/some_files.html Liquid Exception:
+Liquid error (line 285): wrong number of arguments (given 1, expected 2) in /some_directory/some_file.
+html Error: Liquid error (line 285): wrong number of arguments (given 1, expected 2)`
+
+
+## Jekyll Usage
 
 Some of the following examples use a multiline string called `lines` that contains 5 lines, which was created this way:
 
-```
+```html
 {% capture lines %}line 1
 line 2
 line 3
@@ -68,8 +122,10 @@ line 5
 {% endcapture %}
 ```
 
-Other examples use a multiline string called `gitignore` that contains the contents of a mythical `.gitignore` file, which looks like this:
-```
+Other examples use a multiline string called `gitignore` that contains the contents of a mythical `.gitignore` file,
+which looks like this:
+
+```text
 .bsp/
 project/
 target/
@@ -114,27 +170,38 @@ cloud9.zip
 mslinn_aws.tar
 ```
 
+
 ### From the third line of string
-These examples return the lines of the file from the beginning of the until a line with the string "3" is found, including the matched line. The only difference between the examples is the delimiter around the regular expression.
-```
+
+These examples return the lines of the file from the beginning of the until a line with the string "3" is found,
+including the matched line.
+The only difference between the examples is the delimiter around the regular expression.
+
+```html
 {{ lines | from: '3' }}
 {{ lines | from: "3" }}
 {{ lines | from: 3 }}
 ```
+
 The above all generate:
-```
+
+```plain
 line 3
 line 4
 line 5
 ```
 
+
 ### From Line In a File Containing 'PID'
-```
+
+```html
 {% capture gitignore %}{% flexible_include '.gitignore' %}{% endcapture %}
 {{ gitignore | from: 'PID' | xml_escape }}
 ```
+
 The above generates:
-```
+
+```text
 RUNNING_PID
 mslinn_jekyll_plugins.zip
 cloud9.tar
@@ -142,26 +209,37 @@ cloud9.zip
 mslinn_aws.tar
 ```
 
+
 ### To the third line of string
-These examples return the lines of the file from the first line until a line with the string `"3"` is found, including the matched line. The only difference between the examples is the delimiter around the regular expression.
-```
+
+These examples return the lines of the file from the first line until a line with the string `"3"` is found,
+including the matched line.
+The only difference between the examples is the delimiter around the regular expression.
+
+```html
 {{ lines | to: '3' }}
 {{ lines | to: "3" }}
 {{ lines | to: 3 }}
 ```
+
 The above all generate:
-```
+
+```text
 line 1
 line 2
 line 3
 ```
 
+
 ### To Line In a File Containing 'idea'
-```
+
+```html
 {{ gitignore | to: 'idea' }}
 ```
+
 The above generates:
-```
+
+```text
 .bsp/
 project/
 target/
@@ -174,25 +252,35 @@ target/
 .idea*
 ```
 
+
 ### Until the third line of string
-These examples return the lines of the file until a line with the string `"3"` is found, excluding the matched line. The only difference between the examples is the delimiter around the regular expression.
-```
+
+These examples return the lines of the file until a line with the string `"3"` is found, excluding the matched line.
+The only difference between the examples is the delimiter around the regular expression.
+
+```html
 {{ lines | until: '3' }}
 {{ lines | until: "3" }}
 {{ lines | until: 3 }}
 ```
+
 The above all generate:
-```
+
+```text
 line 1
 line 2
 ```
 
+
 ### Until Line In a File Containing 'idea'
-```
+
+```html
 {{ gitignore | until: 'idea' }}
 ```
+
 The above generates:
-```
+
+```text
 .bsp/
 project/
 target/
@@ -204,26 +292,38 @@ target/
 *.log
 ```
 
+
 ### From the string "2" until the string "4"
-These examples return the lines of the file until a line with the string `"3"` is found, excluding the matched line. The only difference between the examples is the delimiter around the regular expression.
-```
+
+These examples return the lines of the file until a line with the string `"3"` is found, excluding the matched line.
+The only difference between the examples is the delimiter around the regular expression.
+
+```html
 {{ lines | from: '2' | until: '4' }}
 {{ lines | from: "2" | until: "4" }}
 {{ lines | from: 2 | until: 4 }}
 ```
+
 The above all generate:
-```
+
+```text
 line 2
 line 3
 ```
 
+
 ### From Line In a File Containing 'idea' Until no match
-The `.gitignore` file does not contain the string `xx`. If we attempt to match against that string the remainder of the file is returned for the to and until filter, and the empty string is returned for the from filter.
-```
+
+The `.gitignore` file does not contain the string `xx`.
+If we attempt to match against that string the remainder of the file is returned for the to and until filter.
+
+```html
 {{ gitignore | from: 'PID' | until: 'xx' }}
 ```
+
 The above generates:
-```
+
+```text
 RUNNING_PID
 mslinn_jekyll_plugins.zip
 cloud9.tar
@@ -231,21 +331,38 @@ cloud9.zip
 mslinn_aws.tar
 ```
 
+
 ### More Complex Regular Expressions
+
 The `from`, `to` and `until` filters can all accept regular expressions.
 The regular expression matches lines that have either the string `sun` or `cloud`
 at the beginning of the line.
-```
+
+```html
 {{ gitignore | from: '^(cloud|sun)' }}
 ```
+
 The above generates:
-```
+
+```text
 cloud9.tar
 cloud9.zip
 mslinn_aws.tar
 ```
 
 
+### Encoding Special Characters
+
+Special characters can be specified as HTML entities.
+For example, `}` is `Open parenthesis. Belle par. A parent. 5 Resulting. OK. }`.
+
+```html
+{{ css | from: '.error' | to: '}' | strip }}
+```
+
+`demo/special.html` demonstrates this.
+
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies.
@@ -254,12 +371,15 @@ You can also run `bin/console` for an interactive prompt that will allow you to
 
 
 ### Build and Install Locally
+
 To build and install this gem onto your local machine, run:
-```shell
+
+```shellSoap. XboxXboxOur cub Our company outcome.XboxParent
 $ bundle exec rake install
 ```
 
 Examine the newly built gem:
+
 ```shell
 $ gem info jekyll_from_to_until
 
@@ -275,12 +395,15 @@ jekyll_from_to_until (1.0.0)
     Generates Jekyll logger with colored output.
 ```
 
+
 ## 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
 
@@ -297,29 +420,34 @@ Options:
 
 
 ### 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
-    ```
+1. Set breakpoints.
+2. Initiate a debug session from the command line:
 
-  3. Once the `Fast Debugger` signon appears, launch the Visual Studio Code launch configuration called `Attach rdebug-ide`.
+   ```shell
+   $ demo/bin/debug
+   ```
 
-  4. View the generated website at [`http://localhost:4444`](http://localhost:4444).
+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:
-     ```shell
-     $ bundle exec rake release
-     ```
-     The above creates a git tag for the version, commits the created tag,
-     and pushes the new `.gem` file to [RubyGems.org](https://rubygems.org).
+
+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:
+
+   ```shell
+   $ bundle exec rake release
+   ```
+
+   The above creates a git tag for the version, commits the created tag,
+   and pushes the new `.gem` file to [RubyGems.org](https://rubygems.org).
 
 
 ## Contributing

data/jekyll_from_to_until.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
   END_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#from_to_until'
+  spec.homepage = 'https://www.mslinn.com/jekyll_plugins/jekyll_from_to_until.html'
   spec.license = 'MIT'
   spec.metadata = {
     'allowed_push_host' => 'https://rubygems.org',
@@ -32,6 +32,7 @@ Gem::Specification.new do |spec|
   spec.test_files = spec.files.grep(%r!^(test|spec|features)/!)
   spec.version = JekyllFromToUntilVersion::VERSION
 
+  spec.add_dependency 'htmlentities'
   spec.add_dependency 'jekyll', '>= 3.5.0'
   spec.add_dependency 'jekyll_plugin_logger'
 end

data/lib/jekyll_from_to_until/version.rb

@@ -1,3 +1,3 @@
 module JekyllFromToUntilVersion
-  VERSION = '1.0.3'.freeze
+  VERSION = '1.0.5'.freeze
 end

data/lib/jekyll_from_to_until.rb

@@ -1,92 +1,140 @@
-# @author Copyright 2020 Michael Slinn
 # Jekyll filters for working with multiline strings.
 
-require 'jekyll_plugin_logger'
-require 'liquid'
+require 'htmlentities'
 require_relative 'jekyll_from_to_until/version'
 
 module JekyllPluginFromToUntilName
   PLUGIN_NAME = 'jekyll_from_to_until'.freeze
 end
 
-module FromToUntil
-  @logger = PluginMetaLogger.instance.new_logger("FromToUntil", PluginMetaLogger.instance.config)
-
-  # Filters a multiline string, returning the portion beginning with the line that satisfies a regex.
-  # The regex could be enclosed in single quotes, double quotes, or nothing.
-  # @param input_strings [String] The multi-line string to scan
-  # @param regex [String] The regular expression to match against each line of `input_strings` until found
-  # @return [String] The remaining multi-line string
-  # @example Returns remaining lines starting with the line containing the word `module`.
-  #   {{ flexible_include '/blog/2020/10/03/jekyll-plugins.html' | from 'module' }}
-  def from(input_strings, regex)
-    return '' unless check_parameters(input_strings, regex)
-
-    regex = remove_quotations(regex.to_s.strip)
-    matched = false
-    result = ''
-    input_strings.each_line do |line|
-      matched = true if !matched && line =~ %r!#{regex}!
-      result += line if matched
+CALLED_FROM_JEKYLL = !$LOADED_FEATURES.grep(/.*liquid.rb/).empty?
+
+module Jekyll
+  module FromToUntil
+    @logger = if CALLED_FROM_JEKYLL
+                require 'liquid'
+                require 'jekyll_plugin_logger'
+                PluginMetaLogger.instance.new_logger "FromToUntil", PluginMetaLogger.instance.config
+              else
+                require 'logger'
+                Logger.new $stdout
+              end
+
+    # Filters a multiline string, returning the portion beginning with the line that satisfies a regex.
+    # The regex could be enclosed in single quotes, double quotes, or nothing.
+    # @param input_strings [String] The multi-line string to scan
+    # @param regex [String] The regular expression to match against each line of `input_strings` until found
+    # @return [String] The remaining multi-line string
+    # @example Returns remaining lines starting with the line containing the word `module`.
+    #   {{ flexible_include '/blog/2020/10/03/jekyll-plugins.html' | from 'module' }}
+    def from(input_strings, regex)
+      return '' unless check_parameters(input_strings, regex)
+
+      regex = remove_quotations(regex.to_s.strip)
+      matched = false
+      result = ''
+      input_strings.each_line do |line|
+        matched = true if !matched && line =~ %r!#{regex}!
+        result += line if matched
+      end
+      result
     end
-    result
-  end
 
-  # Filters a multiline string, returning the portion from the beginning until and including the line that satisfies a regex.
-  # The regex could be enclosed in single quotes, double quotes, or nothing.
-  # @example Returns lines up to and including the line containing the word `module`.
-  #   {{ flexible_include '/blog/2020/10/03/jekyll-plugins.html' | to 'module' }}
-  def to(input_strings, regex)
-    return '' unless check_parameters(input_strings, regex)
-
-    regex = remove_quotations(regex.to_s.strip)
-    result = ''
-    input_strings.each_line do |line|
-      result += line
-      return result if line.match?(%r!#{regex}!)
+    # Filters a multiline string, returning the portion from the beginning until and including the line that satisfies a regex.
+    # The regex could be enclosed in single quotes, double quotes, or nothing.
+    # @example Returns lines up to and including the line containing the word `module`.
+    #   {{ flexible_include '/blog/2020/10/03/jekyll-plugins.html' | to 'module' }}
+    def to(input_strings, regex)
+      return '' unless check_parameters(input_strings, regex)
+
+      regex = remove_quotations(regex.to_s.strip)
+      result = ''
+      input_strings.each_line do |line|
+        result += line
+        return result if line.match?(%r!#{regex}!)
+      end
+      result
     end
-    result
-  end
 
-  # Filters a multiline string, returning the portion from the beginning until but not including the line that satisfies a regex.
-  # The regex could be enclosed in single quotes, double quotes, or nothing.
-  # @example Returns lines up to but not including the line containing the word `module`.
-  #   {{ flexible_include '/blog/2020/10/03/jekyll-plugins.html' | until 'module' }}
-  def until(input_strings, regex)
-    return '' unless check_parameters(input_strings, regex)
+    # Filters a multiline string, returning the portion from the beginning until but not including the line that satisfies a regex.
+    # The regex could be enclosed in single quotes, double quotes, or nothing.
+    # @example Returns lines up to but not including the line containing the word `module`.
+    #   {{ flexible_include '/blog/2020/10/03/jekyll-plugins.html' | until 'module' }}
+    def until(input_strings, regex)
+      return '' unless check_parameters(input_strings, regex)
 
-    regex = remove_quotations(regex.to_s.strip)
-    result = ''
-    input_strings.each_line do |line|
-      return result if line.match?(%r!#{regex}!)
+      regex = remove_quotations(regex.to_s.strip)
+      result = ''
+      input_strings.each_line do |line|
+        return result if line.match?(%r!#{regex}!)
 
-      result += line
+        result += line
+      end
+      result
     end
-    result
+
+    private if CALLED_FROM_JEKYLL
+
+    def check_parameters(input_strings, regex)
+      if input_strings.nil? || input_strings.empty?
+        @logger.warn { "Warning: Plugin 'from' received no input for regex #{regex}." }
+        return false
+      end
+
+      regex = regex.to_s
+      if regex.nil? || regex.empty?
+        @logger.warn { "Warning: Plugin 'from' received no regex for input #{input_strings}." }
+        return false
+      end
+      true
+    end
+
+    def remove_quotations(str)
+      str = str.slice(1..-2) if (str.start_with?('"') && str.end_with?('"')) ||
+                                (str.start_with?("'") && str.end_with?("'"))
+      str
+    end
+
+    module_function :from, :to, :until, :check_parameters, :remove_quotations
   end
 
-  private
+  # See https://www.mslinn.com/jekyll/10400-jekyll-plugin-template-collection.html#module_function
+  module FromToUntilFilter
+    def from(input_strings, regex)
+      input_strings = extra_decode HTMLEntities.new.decode input_strings
+      regex         = extra_decode HTMLEntities.new.decode regex
+      FromToUntil.from(input_strings, regex) # method forwarding
+    end
+
+    def to(input_strings, regex)
+      input_strings = extra_decode HTMLEntities.new.decode input_strings
+      regex         = extra_decode HTMLEntities.new.decode regex
+      FromToUntil.to(input_strings, regex) # method forwarding
+    end
 
-  def check_parameters(input_strings, regex)
-    if input_strings.nil? || input_strings.empty?
-      @logger.warn { "Warning: Plugin 'from' received no input for regex #{regex}." }
-      return false
+    def until(input_strings, regex)
+      input_strings = extra_decode HTMLEntities.new.decode input_strings
+      regex         = extra_decode HTMLEntities.new.decode regex
+      FromToUntil.until(input_strings, regex) # method forwarding
     end
 
-    regex = regex.to_s
-    if regex.nil? || regex.empty?
-      @logger.warn { "Warning: Plugin 'from' received no regex for input #{input_strings}." }
-      return false
+    # HTMLEntities does not support enough HTML entities
+    def extra_decode(line)
+      line.gsub('{', '{')
+          .gsub('}', '}')
+          .gsub('(', '(')
+          .gsub(')', ')')
+          .gsub('&lparen;', '(')
+          .gsub('&rparen;', ')')
+          .gsub('[', '[')
+          .gsub(']', ']')
+          .gsub('[', '[')
+          .gsub(']', ']')
     end
-    true
   end
 
-  def remove_quotations(str)
-    str = str.slice(1..-2) if (str.start_with?('"') && str.end_with?('"')) ||
-                              (str.start_with?("'") && str.end_with?("'"))
-    str
+  if CALLED_FROM_JEKYLL
+    PluginMetaLogger.instance.info { "Loaded #{JekyllPluginFromToUntilName::PLUGIN_NAME} v#{JekyllFromToUntilVersion::VERSION} plugin." }
+    Liquid::Template.register_filter(FromToUntilFilter)
   end
 end
-
-PluginMetaLogger.instance.info { "Loaded #{JekyllPluginFromToUntilName::PLUGIN_NAME} v#{JekyllFromToUntilVersion::VERSION} plugin." }
-Liquid::Template.register_filter(FromToUntil)

data/spec/{from_to_until_spec.rb → jekyll_from_to_until_spec.rb}

@@ -2,8 +2,8 @@ require 'jekyll'
 require 'fileutils'
 require_relative '../lib/jekyll_from_to_until'
 
-RSpec.describe(JekyllFromToUntil) do
-  include JekyllFromToUntil
+RSpec.describe(FromToUntil) do
+  include described_class
 
   let(:lines) do
     <<~END_OF_LINES

data/spec/spec_helper.rb

@@ -5,9 +5,8 @@ require_relative '../lib/jekyll_from_to_until'
 Jekyll.logger.log_level = :info
 
 RSpec.configure do |config|
-  config.filter_run :focus
-  config.order = 'random'
-  config.run_all_when_everything_filtered = true
+  config.filter_run_when_matching focus: true
+  # config.order = 'random'
 
   # See https://relishapp.com/rspec/rspec-core/docs/command-line/only-failures
   config.example_status_persistence_file_path = "spec/status_persistence.txt"

data/spec/status_persistence.txt

@@ -0,0 +1,6 @@
+example_id                               | status | run_time        |
+---------------------------------------- | ------ | --------------- |
+./spec/jekyll_from_to_until_spec.rb[1:1] | passed | 0.00121 seconds |
+./spec/jekyll_from_to_until_spec.rb[1:2] | passed | 0.00007 seconds |
+./spec/jekyll_from_to_until_spec.rb[1:3] | passed | 0.00005 seconds |
+./spec/jekyll_from_to_until_spec.rb[1:4] | passed | 0.00015 seconds |

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: jekyll_from_to_until
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.5
 platform: ruby
 authors:
 - Mike Slinn
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-02-27 00:00:00.000000000 Z
+date: 2024-08-22 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: htmlentities
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: jekyll
   requirement: !ruby/object:Gem::Requirement
@@ -55,20 +69,21 @@ files:
 - jekyll_from_to_until.gemspec
 - lib/jekyll_from_to_until.rb
 - lib/jekyll_from_to_until/version.rb
-- spec/from_to_until_spec.rb
+- spec/jekyll_from_to_until_spec.rb
 - spec/spec_helper.rb
-homepage: https://www.mslinn.com/blog/2020/10/03/jekyll-plugins.html#from_to_until
+- spec/status_persistence.txt
+homepage: https://www.mslinn.com/jekyll_plugins/jekyll_from_to_until.html
 licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
   bug_tracker_uri: https://github.com/mslinn/jekyll_from_to_until/issues
   changelog_uri: https://github.com/mslinn/jekyll_from_to_until/CHANGELOG.md
-  homepage_uri: https://www.mslinn.com/blog/2020/10/03/jekyll-plugins.html#from_to_until
+  homepage_uri: https://www.mslinn.com/jekyll_plugins/jekyll_from_to_until.html
   source_code_uri: https://github.com/mslinn/jekyll_from_to_until
 post_install_message: |2+
 
-  Thanks for installing jekyll_from_to_until v1.0.3!
+  Thanks for installing jekyll_from_to_until v1.0.5!
 
 rdoc_options: []
 require_paths:
@@ -84,12 +99,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.5.17
 signing_key:
 specification_version: 4
 summary: 'This Jekyll plugin provides 3 filters that return portions of a multiline
   string: from, to and until.'
 test_files:
-- spec/from_to_until_spec.rb
+- spec/jekyll_from_to_until_spec.rb
 - spec/spec_helper.rb
+- spec/status_persistence.txt
 ...