jekyll_plugin_support 0.7.2 → 0.8.1

data/lib/jekyll_plugin_error_handling.rb

@@ -0,0 +1,51 @@
+module JekyllSupportErrorHandling
+  attr_reader :logger, :page
+
+  # If a Jekyll plugin needs to crash exit, and stop Jekyll, call this method.
+  # It does not generate a stack trace.
+  # This method does not return because the process is abruptly terminated.
+  #
+  # @param error StandardError or a subclass of StandardError is required
+  #
+  # Do not raise the error before calling this method, just create it via 'new', like this:
+  # exit_without_stack_trace StandardError.new('This is my error message')
+  #
+  # If you want to call this method from a handler method, the default index for the backtrace array must be specified.
+  # The default backtrace index is 1, which means the calling method.
+  # To specify the calling method's caller, pass in 2, like this:
+  # exit_without_stack_trace StandardError.new('This is my error message'), 2
+  def exit_without_stack_trace(error, caller_index = 1)
+    raise error
+  rescue StandardError => e
+    file, line_number, caller = e.backtrace[caller_index].split(':')
+    caller = caller.tr('`', "'")
+    warn "#{error.message} #{caller} on line #{line_number} (after front matter) of #{file}".red
+    # Process.kill('HUP', Process.pid) # generates huge stack trace
+    exec "echo ''"
+  end
+
+  # TODO: Delete this
+  def format_error_message(message)
+    page = " of #{@page['path']}" if @page
+    remove_ansi_color "on line #{line_number} (after front matter)#{page}.\n#{message}"
+  end
+
+  # TODO: Delete this
+  def remove_ansi_color(string)
+    string.gsub(/\e\[([;\d]+)?m/, '')
+  end
+
+  # TODO: Delete this
+  def maybe_reraise_error(error, throw_error: true)
+    fmsg = format_error_message "#{error.class}: #{error.message.strip}"
+    @logger.error { fmsg }
+    return "<span class='jekyll_plugin_support_error'>#{fmsg}</span>" unless throw_error
+
+    error.set_backtrace error.backtrace[0..9]
+    raise error
+  end
+
+  def warn_short_trace(error)
+    JekyllSupport.warn_short_trace(@logger, error)
+  end
+end

data/lib/jekyll_plugin_helper.rb

@@ -1,45 +1,14 @@
 require 'facets/string/interpolate'
 require 'key_value_parser'
 require 'shellwords'
-require_relative 'gem_support'
+require_relative 'jekyll_plugin_helper_class'
+require_relative 'jekyll_plugin_helper_attribution'
 
-# Base class for all types of Jekyll plugin helpers
-class JekyllPluginHelper # rubocop:disable Metrics/ClassLength
+class JekyllPluginHelper
   attr_accessor :liquid_context
   attr_reader :argv, :attribution, :keys_values, :logger, :markup, :no_arg_parsing, :params, :tag_name,
               :argv_original, :excerpt_caller, :keys_values_original, :params_original, :jpsh_subclass_caller
 
-  # Expand an 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 HrefError, "jekyll_href error: #{envar} is undefined".red, [] \
-        if !ENV.key?(envar) && die_if_undefined # Suppress stack trace
-
-      ENV.fetch(envar, nil)
-    end
-  end
-
-  def self.register(klass, name)
-    abort("Error: The #{name} plugin does not define VERSION") \
-      unless klass.const_defined?(:VERSION)
-
-    version = klass.const_get(:VERSION)
-
-    abort("Error: The #{name} plugin is not an instance of JekyllSupport::JekyllBlock or JekyllSupport::JekyllTag") \
-      unless klass.instance_of?(Class) &&
-             (klass.ancestors.include?(JekyllSupport::JekyllBlock) ||
-              klass.ancestors.include?(JekyllSupport::JekyllTag))
-
-    Liquid::Template.register_tag(name, klass)
-    PluginMetaLogger.instance.info { "Loaded #{name} v#{version} plugin." }
-  end
-
-  # strip leading and trailing quotes if present
-  def self.remove_quotes(string)
-    string.strip.gsub(/\A'|\A"|'\Z|"\Z/, '').strip if string
-  end
-
   # See https://github.com/Shopify/liquid/wiki/Liquid-for-Programmers#create-your-own-tags
   # @param tag_name [String] the name of the tag, which we already know.
   # @param argument_string [String] the arguments from the tag, as a single string.
@@ -53,51 +22,18 @@ class JekyllPluginHelper # rubocop:disable Metrics/ClassLength
     @tag_name = tag_name
     @logger = logger
     @no_arg_parsing = no_arg_parsing
-    reinitialize(markup.strip)
-
-    @attribution = parameter_specified?('attribution') || false unless no_arg_parsing
-    @logger.debug { "@keys_values='#{@keys_values}'" }
+    @markup = markup
   rescue StandardError => e
-    @logger.error { "#{self.class} died with a #{e.full_message}" }
-  end
-
-  def attribute
-    return unless @current_gem
-
-    <<~END_OUTPUT
-      <div id="jps_attribute_#{rand(999_999)}" class="jps_attribute">
-        <div>
-          <a href="#{@homepage}" target="_blank" rel="nofollow">
-            #{attribution_string}
-          </a>
-        </div>
-      </div>
-    END_OUTPUT
-  end
-
-  def default_attribution
-    authors = @authors&.join(', ')
-    result = "Generated by the \#{@name} v\#{@version} Jekyll plugin"
-    result << ", written by #{authors}" if authors
-    result << " \#{@published_date}" if @published_date
-    result << '.'
-    result
-  end
-
-  # Sets @current_gem if file points at a uniquely named file within a gem.
-  # @param file must be a fully qualified file name in a gem, for example: __FILE__
-  def gem_file(file)
-    @current_gem = GemSupport.current_spec file
-    @logger.debug "No gem found for '#{file} was found." unless @current_gem
-    annotate_globals if @attribution && @current_gem
+    e.shorten_backtrace
+    @logger.error { e.message }
   end
 
   # @return undefined if parameter was specified, removes it from the available tokens and returns value
   def parameter_specified?(name, delete_param: true)
-    return if @keys_values.empty?
+    return false if @keys_values.to_s.empty?
 
     key = name
-    key = name.to_sym if @keys_values.first.first.instance_of?(Symbol)
+    key = name.to_sym if @keys_values&.first&.first.instance_of?(Symbol)
     value = @keys_values[key]
     delete_parameter(name) if delete_param
     value
@@ -112,18 +48,21 @@ class JekyllPluginHelper # rubocop:disable Metrics/ClassLength
       define_singleton_method(:params) { warn_fetch :params }
       define_singleton_method(:parameter_specified?) { |_name| warn_parse(:parameter_specified?) }
       define_singleton_method(:delete_parameter) { |_name| warn_parse(:delete_parameter) }
+      @attribution = false
     else
       parse markup
+      @attribution = parameter_specified?('attribution') || false
+      @logger.debug { "@keys_values='#{@keys_values}'" }
     end
   end
 
   # Call this method to return the remaining markup after `parameter_specified?` has been invoked.
   def remaining_markup
-    @argv.join(' ')
+    @argv&.join(' ')
   end
 
   def remaining_markup_original
-    @argv_original.join(' ')
+    @argv_original&.join(' ')
   end
 
   def warn_fetch(variable)
@@ -134,27 +73,6 @@ class JekyllPluginHelper # rubocop:disable Metrics/ClassLength
     abort "Error: Argument parsing was suppressed, but an attempt to invoke #{meth} was made"
   end
 
-  private
-
-  def attribution_string
-    string = if @attribution == true
-               default_attribution
-             else
-               @attribution
-             end
-    String.interpolate { string }
-  end
-
-  def annotate_globals
-    return unless @current_gem
-
-    @name           = @current_gem.name
-    @authors        = @current_gem.authors
-    @homepage       = @current_gem.homepage
-    @published_date = @current_gem.date.to_date.to_s
-    @version        = @current_gem.version
-  end
-
   def delete_parameter(key)
     return if @keys_values.empty? || @params.nil?
 
@@ -167,58 +85,26 @@ class JekyllPluginHelper # rubocop:disable Metrics/ClassLength
     @keys_values_original.delete(key)
   end
 
-  PREDEFINED_SCOPE_KEYS = %i[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
-
-  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
+  private
 
   def page
     @liquid_context.registers[:page]
   end
 
-  # rubocop:disable Style/IfUnlessModifier
   def parse(markup)
     @argv_original = Shellwords.split(markup)
     @keys_values_original = KeyValueParser
-      .new({}, { array_values: false, normalize_keys: false, separator: /=/ })
-      .parse(@argv_original)
-    unless respond_to?(:no_arg_parsing) && no_arg_parsing
-      @params_original = @keys_values_original.map { |k, _v| lookup_variable(k) }
-    end
+                            .new({}, { array_values: false, normalize_keys: false, separator: /=/ })
+                            .parse(@argv_original)
+    @params_original = @keys_values_original unless respond_to?(:no_arg_parsing) && no_arg_parsing
 
     @argv = Shellwords.split(self.class.expand_env(markup))
     @keys_values = KeyValueParser
-      .new({}, { array_values: false, normalize_keys: false, separator: /=/ })
-      .parse(@argv)
+                   .new({}, { array_values: false, normalize_keys: false, separator: /=/ })
+                   .parse(@argv)
 
     return if respond_to?(:no_arg_parsing) && no_arg_parsing
 
-    @params = @keys_values.map { |k, _v| lookup_variable(k) }
+    @params = @keys_values # TODO: @keys_values should be deleted
   end
-  # rubocop:enable Style/IfUnlessModifier
 end

data/lib/jekyll_plugin_helper_attribution.rb

@@ -0,0 +1,72 @@
+# Attribution aspect of JekyllPluginHelper
+class JekyllPluginHelper
+  # @param file must be a fully qualified file name that points to a file within a gem.
+  # @return Gem::Specification of gem that file points into, or nil if not called from a gem
+  # See https://stackoverflow.com/a/75890279/553865
+  def self.current_spec(file)
+    abort 'JekyllPluginHelper::current_spec: file is nil' if file.nil?
+    return nil unless File.exist?(file)
+
+    searcher = if Gem::Specification.respond_to?(:find)
+                 Gem::Specification
+               elsif Gem.respond_to?(:searcher)
+                 Gem.searcher.init_gemspecs
+               end
+
+    searcher&.find do |spec|
+      file.start_with? spec.full_gem_path
+    end
+  end
+
+  def attribute
+    return unless @current_gem
+
+    <<~END_OUTPUT
+      <div id="jps_attribute_#{rand(999_999)}" class="jps_attribute">
+        <div>
+          <a href="#{@homepage}" target="_blank" rel="nofollow">
+            #{attribution_string}
+          </a>
+        </div>
+      </div>
+    END_OUTPUT
+  end
+
+  def default_attribution
+    authors = @authors&.join(', ')
+    result = "Generated by the \#{@name} v\#{@version} Jekyll plugin"
+    result << ", written by #{authors}" if authors
+    result << " \#{@published_date}" if @published_date
+    result << '.'
+    result
+  end
+
+  # Sets @current_gem if file points at a uniquely named file within a gem.
+  # @param file must be a fully qualified file name in a gem, for example: __FILE__
+  def gem_file(file)
+    @current_gem = JekyllPluginHelper.current_spec file
+    @logger.debug "No gem found for '#{file} was found." unless @current_gem
+    annotate_globals if @attribution && @current_gem
+  end
+
+  private
+
+  def annotate_globals
+    return unless @current_gem
+
+    @name           = @current_gem.name
+    @authors        = @current_gem.authors
+    @homepage       = @current_gem.homepage
+    @published_date = @current_gem.date.to_date.to_s
+    @version        = @current_gem.version
+  end
+
+  def attribution_string
+    string = if @attribution == true
+               default_attribution
+             else
+               @attribution
+             end
+    String.interpolate { string }
+  end
+end

data/lib/jekyll_plugin_helper_class.rb

@@ -0,0 +1,73 @@
+require 'facets/string/camelcase'
+require 'facets/string/snakecase'
+require 'yaml'
+
+# Class methods for JekyllPluginHelper
+class JekyllPluginHelper
+  # Expand an 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 JekyllPluginSupportError, "jekyll_plugin_support error: #{envar} is undefined".red, [] \
+        if !ENV.key?(envar) && die_if_undefined # Suppress stack trace
+
+      ENV.fetch(envar, nil)
+    end
+  end
+
+  def self.generate_message(klass, tag_name, version)
+    error_ruby_class_name = "#{klass.name.camelcase(:upper)}Error"
+    config_die_key = "die_on_#{error_ruby_class_name.snakecase}"
+    error_css_class_name = error_ruby_class_name.split('::').last.snakecase
+    # config_file_fq = File.realpath 'demo/_config.yml'
+    config = YAML.load_file('demo/_config.yml')
+    tag_config = config[tag_name]
+    tag_config_msg = if tag_config.nil?
+                       <<~END_MSG
+                         _config.yml does not contain configuration information for this plugin.
+                           You could add a section containing default values like this:
+
+                               #{tag_name}:
+                                 #{config_die_key}: false
+                       END_MSG
+                     else
+                       <<~END_MSG
+                         _config.yml contains the following configuration for this plugin is:
+                           #{tag_config}
+                       END_MSG
+                     end
+
+    <<~END_MSG
+      Loaded plugin #{tag_name} v#{version}. It has:
+        Error class: #{error_ruby_class_name}
+        CSS class for error messages: #{error_css_class_name}
+
+        #{tag_config_msg}
+    END_MSG
+  end
+
+  def self.register(klass, tag_name)
+    abort("Error: The #{tag_name} plugin does not define VERSION") \
+      unless klass.const_defined?(:VERSION)
+
+    version = klass.const_get(:VERSION)
+
+    abort("Error: The #{tag_name} plugin is not an instance of JekyllSupport::JekyllBlock or JekyllSupport::JekyllTag") \
+      unless klass.instance_of?(Class) &&
+             (klass.ancestors.include?(JekyllSupport::JekyllBlock) ||
+              klass.ancestors.include?(JekyllSupport::JekyllTag))
+
+    Liquid::Template.register_tag(tag_name, klass)
+    msg = generate_message(klass, tag_name, version)
+    PluginMetaLogger.instance.info msg
+  end
+
+  def self.remove_html_tags(string)
+    string.gsub(/<[^>]*>/, '').strip
+  end
+
+  # strip leading and trailing quotes if present
+  def self.remove_quotes(string)
+    string.strip.gsub(/\A'|\A"|'\Z|"\Z/, '').strip if string
+  end
+end

data/lib/jekyll_plugin_support/version.rb

@@ -1,3 +1,3 @@
 module JekyllPluginSupportVersion
-  VERSION = '0.7.2'.freeze
+  VERSION = '0.8.1'.freeze
 end

data/lib/jekyll_plugin_support.rb

@@ -4,211 +4,15 @@ require 'jekyll_plugin_logger'
 require_relative 'jekyll_plugin_helper'
 require_relative 'jekyll_plugin_support/version'
 
-# @author Copyright 2022 Michael Slinn
-# @license SPDX-License-Identifier: Apache-2.0``
 module NoArgParsing
   attr_accessor :no_arg_parsing
 
   @no_arg_parsing = true
 end
 
-module JekyllSupport
-  DISPLAYED_CALLS = 8
-
-  def self.error_short_trace(logger, error)
-    remaining = error.backtrace.length - DISPLAYED_CALLS
-    logger.error do
-      error.message + "\n" + # rubocop:disable Style/StringConcatenation
-        error.backtrace.take(DISPLAYED_CALLS).join("\n") +
-        "\n...Remaining #{remaining} call sites elided.\n"
-    end
-  end
-
-  def self.warn_short_trace(logger, error)
-    remaining = error.backtrace.length - DISPLAYED_CALLS
-    logger.warn do
-      error.message + "\n" + # rubocop:disable Style/StringConcatenation
-        error.backtrace.take(DISPLAYED_CALLS).join("\n") +
-        "\n...Remaining #{remaining} call sites elided.\n"
-    end
-  end
-
-  # Base class for Jekyll block tags
-  class JekyllBlock < Liquid::Block
-    attr_reader :argument_string, :helper, :line_number, :logger, :page, :site, :text
-
-    # See https://github.com/Shopify/liquid/wiki/Liquid-for-Programmers#create-your-own-tags
-    # @param tag_name [String] the name of the tag, which we usually know.
-    # @param argument_string [String] the arguments passed to 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
-    # @return [void]
-    def initialize(tag_name, argument_string, parse_context)
-      super
-      @tag_name = tag_name
-      @argument_string = argument_string
-      @logger = PluginMetaLogger.instance.new_logger(self, PluginMetaLogger.instance.config)
-      @logger.debug { "#{self.class}: respond_to?(:no_arg_parsing) #{respond_to?(:no_arg_parsing) ? 'yes' : 'no'}." }
-      @helper = JekyllPluginHelper.new tag_name, argument_string, @logger, respond_to?(:no_arg_parsing)
-    end
-
-    # @return line number where tag or block was found, relative to the start of the page
-    def jekyll_line_number
-      @page['front_matter'].count("\n") + @line_number
-    end
-
-    # Method prescribed by the Jekyll plugin lifecycle.
-    # Defines @config, @envs, @mode, @page and @site
-    # @return [String]
-    def render(liquid_context)
-      text = super
-      @helper.liquid_context = liquid_context
-
-      @page = liquid_context.registers[:page] # hash
-      @site = liquid_context.registers[:site]
-      @config = @site.config
-      @envs = liquid_context.environments.first
-
-      @layout    = @envs[:layout]
-      @paginator = @envs[:paginator]
-      @theme     = @envs[:theme]
-
-      @mode = @config['env']&.key?('JEKYLL_ENV') ? @config['env']['JEKYLL_ENV'] : 'development'
-
-      render_impl text
-    rescue StandardError => e
-      @logger.error { "#{self.class} died with a #{e.full_message}" }
-      JekyllSupport.error_short_trace(@logger, e)
-    end
-
-    # Jekyll plugins should override this method, not render,
-    # so they can be tested more easily.
-    # The following variables are predefined:
-    #   @argument_string, @config, @envs, @helper, @layout, @logger, @mode, @page, @paginator, @site, @tag_name and @theme
-    # @return [String] The result to be rendered to the invoking page
-    def render_impl(text)
-      text
-    end
-
-    def warn_short_trace(error)
-      JekyllSupport.warn_short_trace(@logger, error)
-    end
-  end
-
-  class JekyllBlockNoArgParsing < JekyllBlock
-    def initialize(tag_name, argument_string, parse_context)
-      class << self
-        include NoArgParsing
-      end
-
-      super
-      @logger.debug { "#{self.class}: respond_to?(:o_arg_parsing) #{respond_to?(:no_arg_parsing) ? 'yes' : 'no'}." }
-    rescue StandardError => e
-      @logger.error { "#{self.class} died with a #{e.full_message}" }
-      JekyllSupport.error_short_trace(@logger, e)
-    end
-
-    def warn_short_trace(error)
-      JekyllSupport.warn_short_trace(@logger, error)
-    end
-  end
-
-  # Base class for Jekyll tags
-  class JekyllTag < Liquid::Tag
-    attr_reader :argument_string, :helper, :line_number, :logger, :page, :site
-
-    # See https://github.com/Shopify/liquid/wiki/Liquid-for-Programmers#create-your-own-tags
-    # @param tag_name [String] the name of the tag, which we usually know.
-    # @param argument_string [String] the arguments passed to 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
-    # @return [void]
-    def initialize(tag_name, argument_string, parse_context)
-      super
-      @tag_name = tag_name
-      @argument_string = argument_string
-      @logger = PluginMetaLogger.instance.new_logger(self, PluginMetaLogger.instance.config)
-      @logger.debug { "#{self.class}: respond_to?(:no_arg_parsing) #{respond_to?(:no_arg_parsing) ? 'yes' : 'no'}." }
-      @helper = JekyllPluginHelper.new(tag_name, argument_string, @logger, respond_to?(:no_arg_parsing))
-    end
-
-    # If a Jekyll plugin needs to crash exit, and stop Jekyll, call this method.
-    # It does not generate a stack trace.
-    # This method does not return because the process is abruptly terminated.
-    #
-    # @param error StandardError or a subclass of StandardError is required
-    #
-    # Do not raise the error before calling this method, just create it via 'new', like this:
-    # exit_without_stack_trace StandardError.new('This is my error message')
-    #
-    # If you want to call this method from a handler method, the default index for the backtrace array must be specified.
-    # The default backtrace index is 1, which means the calling method.
-    # To specify the calling method's caller, pass in 2, like this:
-    # exit_without_stack_trace StandardError.new('This is my error message'), 2
-    def exit_without_stack_trace(error, caller_index = 1)
-      raise error
-    rescue StandardError => e
-      file, line_number, caller = e.backtrace[caller_index].split(':')
-      caller = caller.tr('`', "'")
-      warn "#{self.class} died with a '#{error.message}' #{caller} on line #{line_number} of #{file}".red
-      # Process.kill('HUP', Process.pid) # generates huge stack trace
-      exec "echo ''"
-    end
-
-    # @return line number where tag or block was found, relative to the start of the page
-    def jekyll_line_number
-      @page['front_matter'].count("\n") + @line_number
-    end
-
-    # Method prescribed by the Jekyll plugin lifecycle.
-    def render(liquid_context)
-      return if @helper.excerpt_caller
-
-      @helper.liquid_context = liquid_context
-
-      @envs      = liquid_context.environments.first
-
-      @layout    = @envs[:layout]
-      @paginator = @envs[:paginator]
-      @theme     = @envs[:theme]
-
-      @page      = liquid_context.registers[:page]
-      @site      = liquid_context.registers[:site]
-
-      @config = @site.config
-      @mode = @config['env']&.key?('JEKYLL_ENV') ? @config['env']['JEKYLL_ENV'] : 'development'
-
-      render_impl
-    rescue StandardError => e
-      JekyllSupport.error_short_trace(@logger, e)
-    end
-
-    # Jekyll plugins must override this method, not render, so their plugin can be tested more easily
-    # The following variables are predefined:
-    #   @argument_string, @config, @envs, @helper, @layout, @logger, @mode, @page, @paginator, @site, @tag_name and @theme
-    def render_impl
-      abort "#{self.class}.render_impl for tag #{@tag_name} must be overridden, but it was not."
-    end
-
-    def warn_short_trace(error)
-      JekyllSupport.warn_short_trace(@logger, error)
-    end
-  end
-
-  class JekyllTagNoArgParsing < JekyllTag
-    def initialize(tag_name, argument_string, parse_context)
-      class << self
-        include NoArgParsing
-      end
-
-      super
-      @logger.debug { "#{self.class}: respond_to?(:no_arg_parsing) #{respond_to?(:no_arg_parsing) ? 'yes' : 'no'}." }
-    end
-  end
-end
+require_relative 'jekyll_plugin_support_class'
+require_relative 'jekyll_plugin_support_block'
+require_relative 'jekyll_plugin_support_block_noarg'
+require_relative 'jekyll_plugin_support_tag'
+require_relative 'jekyll_plugin_support_tag_noarg'
+require_relative 'jekyll_custom_error'