jekyll_plugin_support 1.1.0 → 3.1.0

data/lib/jekyll_plugin_support/jekyll_plugin_support_class.rb

@@ -1,8 +1,7 @@
-require_relative '../error/jekyll_custom_error'
-
 # Monkey patch StandardError so a new method called shorten_backtrace is added.
 class StandardError
-  def shorten_backtrace(backtrace_element_count = 3)
+  def shorten_backtrace(backtrace_element_count = 5)
+    set_backtrace backtrace[0..backtrace_element_count]
     # self.backtrace = backtrace[0..backtrace_element_count].map do |x|
     #   raise JekyllPluginSupportError, "backtrace contains a #{x.class} with value '#{x}'." unless x.instance_of? String
 
@@ -12,21 +11,21 @@ class StandardError
 end
 
 module JekyllSupport
-  DISPLAYED_CALLS = 8
+  DISPLAYED_CALLS = 8 unless defined?(DISPLAYED_CALLS)
 
   def self.error_short_trace(logger, error)
     error.set_backtrace error.backtrace[0..DISPLAYED_CALLS]
-    logger.error { error }
+    logger.error { error.full_message } # Are error and logger.error defined?
     error
   end
 
   # @return a new StandardError subclass containing the shorten_backtrace method
   def define_error
-    Class.new JekyllSupport::CustomError
+    Class.new ::JekyllSupport::CustomError
   end
   module_function :define_error
 
-  JekyllPluginSupportError = define_error
+  JekyllPluginSupportError = define_error unless defined?(JekyllPluginSupportError)
 
   def self.dump_vars(_logger, liquid_context)
     page = liquid_context.registers[:page]

data/lib/jekyll_plugin_support/jekyll_plugin_support_spec_support.rb

@@ -1,6 +1,4 @@
-require 'jekyll'
-
-Registers = Struct.new(:page, :site)
+Registers = Struct.new(:page, :site) unless defined?(Registers)
 
 # Mock for Collections
 class Collections

data/lib/jekyll_plugin_support/version.rb

@@ -1,3 +1,3 @@
 module JekyllPluginSupportVersion
-  VERSION = '1.1.0'.freeze
+  VERSION = '3.1.0'.freeze unless defined?(VERSION)
 end

data/lib/jekyll_plugin_support.rb

@@ -1,13 +1,26 @@
-require 'colorator'
-require 'jekyll'
-require 'jekyll_plugin_logger'
-
 def require_directory(dir)
   Dir[File.join(dir, '*.rb')]&.sort&.each do |file|
     require file unless file == __FILE__
   end
 end
 
+require 'colorator'
+require 'jekyll'
+require 'jekyll_plugin_logger'
+require 'pry'
+require 'sorted_set'
+
+# require_directory __dir__
+require_directory "#{__dir__}/util"
+require_directory "#{__dir__}/error"
+require_directory "#{__dir__}/block"
+require_directory "#{__dir__}/generator"
+require_directory "#{__dir__}/helper"
+require_directory "#{__dir__}/jekyll_plugin_support"
+require_directory "#{__dir__}/tag"
+require_directory "#{__dir__}/jekyll_all_collections"
+require_directory "#{__dir__}/hooks"
+
 module JekyllSupport
   def self.redef_without_warning(const, value)
     send(:remove_const, const) if const_defined?(const)
@@ -15,34 +28,36 @@ module JekyllSupport
   end
 end
 
+module ToString
+  def to_s
+    "#{self}.class.name"
+  end
+end
+
 module NoArgParsing
   attr_accessor :no_arg_parsing
 
   @no_arg_parsing = true
 end
 
-require_directory __dir__
-require_directory "#{__dir__}/block"
-require_directory "#{__dir__}/error"
-require_directory "#{__dir__}/generator"
-require_directory "#{__dir__}/helper"
-require_directory "#{__dir__}/jekyll_plugin_support"
-require_directory "#{__dir__}/tag"
-
 module JekyllSupport
   class JekyllTag
     include JekyllSupportError
+    include ToString
   end
 
   class JekyllTagNoArgParsing
     include JekyllSupportError
+    include ToString
   end
 
   class JekyllBlock
     include JekyllSupportError
+    include ToString
   end
 
   class JekyllBlockNoArgParsing
     include JekyllSupportError
+    include ToString
   end
 end

data/lib/tag/jekyll_plugin_support_tag.rb

@@ -1,6 +1,3 @@
-require 'pry'
-require_relative '../error/jekyll_plugin_error_handling'
-
 module JekyllSupport
   # Base class for Jekyll tags
   class JekyllTag < Liquid::Tag
@@ -36,7 +33,7 @@ module JekyllSupport
       @helper = JekyllPluginHelper.new(tag_name, @argument_string, @logger, respond_to?(:no_arg_parsing))
 
       @error_name = "#{tag_name.camelcase(:upper)}Error"
-      JekyllSupport::CustomError.factory @error_name
+      ::JekyllSupport::CustomError.factory @error_name
     end
 
     # Method prescribed by the Jekyll plugin lifecycle.

data/lib/tag/jekyll_plugin_support_tag_noarg.rb

@@ -1,5 +1,3 @@
-require_relative '../error/jekyll_plugin_error_handling'
-
 module JekyllSupport
   class JekyllTagNoArgParsing < JekyllTag
     attr_reader :argument_string, :helper, :line_number, :logger, :page, :site

data/lib/util/mslinn_binary_search.rb

@@ -0,0 +1,152 @@
+unless defined?(MSlinnBinarySearchError)
+  class MSlinnBinarySearchError < StandardError
+  end
+end
+
+# Ruby's binary search is unsuitable because the value to be searched for changes the required ordering for String compares
+class MSlinnBinarySearch
+  attr_reader :accessor_chain, :array # For testing only
+
+  def initialize(accessor_chain)
+    @array = SortedSet.new # [LruFile] Ordered highest to lowest
+    @accessor_chain = accessor_chain
+  end
+
+  # Convert the SortedSet to an Array
+  def enable_search
+    @array = @array.to_a
+  end
+
+  # A match is found when the Array[LruFile] has an href which starts with the given stem
+  # @param stem [String]
+  # @return first item from @array.url that matches, or nil if no match
+  def find(stem)
+    raise MSlinnBinarySearchError, 'Invalid find because stem to search for is nil.' if stem.nil?
+
+    index = find_index(stem)
+    return nil if index.nil?
+
+    @array[index]
+  end
+
+  # @param stem [String]
+  # @return index of first matching stem, or nil if @array is empty, or 0 if no stem specified
+  def find_index(stem)
+    return nil if @array.empty?
+    return 0 if stem.nil? || stem.empty?
+
+    mets = stem.reverse
+    return nil if @array[0].url[0...mets.size] > mets # TODO: use chain eval for item
+    return nil if @array[0].url[0] != mets[0]
+
+    _find_index(mets, 0, @array.length - 1)
+  end
+
+  # @param stem [String]
+  # @return [index] of matching values, or [] if @array is empty, or entire array if no stem specified
+  def find_indices(stem)
+    return [] if @array.empty?
+    return @array if stem.nil? || stem.empty?
+
+    first_index = _find_index(stem, 0, @array.length - 1)
+    last_index = first_index
+    last_index += 1 while @array[last_index].url.start_with? stem
+    [first_index..last_index]
+  end
+
+  # @param item [LruFile]
+  # @return [int] index of matching LruFile in @array, or nil if not found
+  def index_of(lru_file)
+    raise MSlinnBinarySearchError, 'Invalid index_of lru_file (nil).' if lru_file.nil?
+
+    find_index lru_file.url
+  end
+
+  # @return [LruFile] item at given index in @array
+  def item_at(index)
+    if index > @array.length - 1
+      raise MSlinnBinarySearchError,
+            "Invalid item_at index (#{index}) is greater than maximum stem (#{@array.length - 1})."
+    end
+    raise MSlinnBinarySearchError, "Invalid item_at index (#{index}) is less than zero." if index.negative?
+
+    @array[index]
+  end
+
+  # @param lru_file [LruFile]
+  def insert(lru_file)
+    raise MSlinnBinarySearchError, 'Invalid insert because new item is nil.' if lru_file.nil?
+    raise MSlinnBinarySearchError, "Invalid insert because new item has no chain (#{lru_file})" if lru_file.chain.nil?
+
+    @array.add lru_file
+  end
+
+  # TODO: Cache this method
+  # @param suffix [String] to use stem search on
+  # @return nil if @array is empty
+  # @return the first item in @array if suffix is nil or an empty string
+  def prefix_search(suffix)
+    return nil if @array.empty?
+    return @array[0] if suffix.empty? || suffix.nil?
+
+    low = search_index { |x| x.evaluate_with suffix }
+    return [] if low.nil?
+
+    high = low
+    high += 1 while high < @array.length &&
+                    @array[high].evaluate_with(suffix)
+    @array[low..high]
+  end
+
+  # @param stem [String]
+  # @return [APage] matching APages, or [] if @array is empty, or entire array if no stem specified
+  def select_pages(stem)
+    first_index = find_index stem
+    return [] if first_index.nil?
+
+    last_index = first_index
+    while last_index < @array.length - 1
+      # LruFile.url is reversed, bug LruFile.page is not
+      break unless @array[last_index + 1].url.start_with?(stem.reverse)
+
+      last_index += 1
+    end
+    Range.new(first_index, last_index).map { |i| @array[i].page }
+  end
+
+  private
+
+  # A match is found when the Array[LruFile] has an href which starts with the given stem
+  # @param stem [String]
+  # @return [int] first index in @array that matches, or nil if no match
+  def _find_index(mets, min_index, max_index)
+    raise MSlinnBinarySearchError, "_find_index min_index(#{min_index})<0" if min_index.negative?
+    raise MSlinnBinarySearchError, "_find_index min_index(#{min_index})>max_index(#{max_index})" if min_index > max_index
+    raise MSlinnBinarySearchError, "_find_index max_index(#{max_index})>=@array.length(#{@array.length})" if max_index >= @array.length
+
+    return min_index if (min_index == max_index) && @array[min_index].url.start_with?(mets)
+
+    while min_index < max_index
+      mid_index = (min_index + max_index) / 2
+      mid_value = @array[mid_index].url[0...(mets.size)] # TODO: use chain eval for item
+
+      if mid_value == mets # back up until the first match is found
+        index = mid_index
+        loop do
+          return 0 if index.zero?
+
+          return index unless @array[index - 1].url.start_with?(mets)
+
+          index -= 1
+        end
+      elsif mid_value > mets
+        max_index = mid_index - 1
+        return _find_index(mets, min_index, max_index)
+      else
+        min_index = mid_index + 1
+        return _find_index(mets, min_index, max_index)
+      end
+    end
+    nil
+  end
+end

data/lib/util/send_chain.rb

@@ -0,0 +1,56 @@
+# Supports one chain at a time
+module SendChain
+  # See https://stackoverflow.com/a/79333706/553865
+  # This method can be called directly if no methods in the chain require arguments
+  # Does not use any external state
+  def send_chain(chain)
+    Array(chain).inject(self) { |o, a| o.send(*a) }
+  end
+
+  # Saves @chain structure containing :placeholders for arguments to be supplied later
+  # Call when a different chain with :placeholders is desired
+  def new_chain(chain)
+    abort "new_chain error: chain must be an array ('#{chain}' was an #{chain.class.name})" \
+      unless chain.instance_of?(Array)
+    @chain = chain
+  end
+
+  # Call after new_chain, to evaluate @chain with values
+  def substitute_and_send_chain_with(values)
+    send_chain substitute_chain_with values
+  end
+
+  alias evaluate_with substitute_and_send_chain_with
+
+  # Call this method after calling new_chain to perform error checking and replace :placeholders with values.
+  # @chain is not modified.
+  # @return [Array] Modified chain
+  def substitute_chain_with(values)
+    values = [values] unless values.instance_of?(Array)
+
+    placeholder_count = @chain.flatten.count { |x| x == :placeholder }
+    if values.length != placeholder_count
+      abort "with_values error: number of values (#{values.length}) does not match the number of placeholders (#{placeholder_count})"
+    end
+
+    eval_chain @chain, values
+  end
+
+  private
+
+  # Replaces :placeholders with values
+  # Does not use any external state
+  # @return modified chain
+  def eval_chain(chain, values)
+    chain.map do |c|
+      case c
+      when :placeholder
+        values.shift
+      when Array
+        eval_chain c, values
+      else
+        c
+      end
+    end
+  end
+end

data/spec/all_collections_tag/all_collections_tag_sort_spec.rb

@@ -0,0 +1,184 @@
+require_relative '../spec_helper'
+require_relative '../../lib/hooks/a_page'
+
+class NullBinding < BasicObject
+  include ::Kernel
+
+  # Avoid error message "warning: undefining `object_id' may cause serious problems"
+  # https://stackoverflow.com/a/17791631/553865
+  (
+    ::Kernel.instance_methods(false) +
+    ::Kernel.private_instance_methods(false) -
+    [:binding]
+  ).each { |x| undef_method(x) unless x == :object_id }
+
+  def min_binding
+    binding
+  end
+end
+
+def show_dates(label, array)
+  puts "  #{label} actual: #{array.map(&:title).join(', ')}  <==>  expected: #{expected.map(&:title).join(', ')}"
+end
+
+def show(label, lambda_string, actual, expected)
+  puts "#{label} - For lambda_string: #{lambda_string}"
+  puts "  actual: #{actual.map(&:title).join(', ')}"
+  puts "expected: #{expected.map(&:title).join(', ')}"
+  actual_array = actual.map do |x|
+    [
+      (x.date.strftime '%Y-%m-%d' + '/' + x.title), (x.last_modified.strftime '%Y-%m-%d' + '/' + x.title)
+    ].join('/')
+  end
+  expected_array = expected.map do |x|
+    [
+      (x.date.strftime '%Y-%m-%d' + '/' + x.title), (x.last_modified.strftime '%Y-%m-%d' + '/' + x.title)
+    ].join('/')
+  end
+  puts '  actual date/last_modified: ' + actual_array.join(', ')
+  puts 'expected date/last_modified: ' + expected_array.join(', ')
+end
+
+logger = PluginMetaLogger.instance.new_logger(self, PluginMetaLogger.instance.config)
+
+# See https://stackoverflow.com/a/75388137/553865
+RSpec.describe(JekyllSupport) do
+  let(:o1) do
+    described_class.apage_from(
+      collection_name: '_posts',
+      date:            '2020-01-20',
+      last_modified:   '2020-01-20',
+      logger:          logger,
+      title:           'a_A (o1)'
+    )
+  end
+  let(:o2) do
+    described_class.apage_from(
+      collection_name: '_posts',
+      date:            '2021-01-21',
+      last_modified:   '2021-01-21',
+      logger:          logger,
+      title:           'b_B (o2)'
+    )
+  end
+  let(:o3) do
+    described_class.apage_from(
+      collection_name: '_posts',
+      date:            '2021-01-21',
+      last_modified:   '2022-01-22',
+      logger:          logger,
+      title:           'b_C (o3)'
+    )
+  end
+  let(:o4) do
+    described_class.apage_from(
+      collection_name: '_posts',
+      date:            '2022-01-22',
+      last_modified:   '2022-01-22',
+      logger:          logger,
+      title:           'c_C (o4)'
+    )
+  end
+  let(:objs) { [o1, o2, o3, o4] }
+
+  it '(1) defines sort_by lambda with last_modified (ascending)' do
+    sort_lambda = ->(a, b) { [a.last_modified] <=> [b.last_modified] }
+    actual = objs.sort(&sort_lambda)
+    expected = [o1, o2, o3, o4]
+    show('(1)', '[a.last_modified] <=> [b.last_modified]', actual, expected)
+    expect(actual).to eq(expected)
+  end
+
+  it '(2) makes sort_by lambdas from stringified comparison of last_modified (ascending)' do
+    sort_lambda_string = '->(a, b) { a.last_modified <=> b.last_modified }'
+    sort_lambda = eval sort_lambda_string, NullBinding.new.min_binding, __FILE__, __LINE__ - 1
+    actual = objs.sort(&sort_lambda)
+    expected = [o1, o2, o3, o4]
+    show('(2)', sort_lambda_string, actual, expected)
+    expect(actual).to eq(expected)
+  end
+
+  it '(3) makes sort_by lambda from stringified array of last_modified (ascending)' do
+    sort_lambda_string = '->(a, b) { [a.last_modified] <=> [b.last_modified] }'
+    sort_lambda = eval sort_lambda_string, NullBinding.new.min_binding, __FILE__, __LINE__ - 1
+    actual = objs.sort(&sort_lambda)
+    expected = [o1, o2, o3, o4]
+    show('(3)', sort_lambda_string, actual, expected)
+    expect(actual).to eq(expected)
+  end
+
+  it '(4) makes sort_by lambda with last_modified (descending) from stringified array' do
+    sort_lambda_string = '->(a, b) { [b.last_modified] <=> [a.last_modified] }'
+    sort_lambda = eval sort_lambda_string, NullBinding.new.min_binding, __FILE__, __LINE__ - 1
+    actual = objs.sort(&sort_lambda)
+    expected = [o4, o3, o2, o1]
+    show('(4)', sort_lambda_string, actual, expected)
+    expect([o3, o4]).to include(actual[0]) # The sort might yield o3 or o4 in this position
+    expect([o3, o4]).to include(actual[1]) # The sort might yield o3 or o4 in this position
+    expect(o2).to eq(actual[2])
+    expect(o1).to eq(actual[3])
+  end
+
+  it '(5) create_lambda with date (descending)' do
+    lambda_string = JekyllAllCollections::AllCollectionsTag.create_lambda_string('-last_modified')
+    expect(lambda_string).to eq('->(a, b) { [b.last_modified] <=> [a.last_modified] }')
+    sort_lambda = self.eval lambda_string, binding
+    actual = objs.sort(&sort_lambda)
+    expected = [o4, o3, o2, o1]
+    show('(5)', lambda_string, actual, expected)
+    expect([o3, o4]).to include(actual[0]) # The sort might yield o3 or o4 in this position
+    expect([o3, o4]).to include(actual[1]) # The sort might yield o3 or o4 in this position
+    expect(o2).to eq(actual[2])
+    expect(o1).to eq(actual[3])
+  end
+
+  it '(6) create_lambda with date (ascending)' do
+    lambda_string = JekyllAllCollections::AllCollectionsTag.create_lambda_string('date')
+    expect(lambda_string).to eq('->(a, b) { [a.date] <=> [b.date] }')
+    sort_lambda = self.eval lambda_string, binding
+    actual = objs.sort(&sort_lambda)
+    expected = [o1, o2, o3, o4]
+    show('(1)', lambda_string, actual, expected)
+    expect(actual).to eq(expected)
+  end
+
+  it '(7) create_lambda with date (ascending) and last_modified (ascending)' do
+    lambda_string = JekyllAllCollections::AllCollectionsTag.create_lambda_string(%w[date last_modified])
+    expect(lambda_string).to eq('->(a, b) { [a.date, a.last_modified] <=> [b.date, b.last_modified] }')
+    sort_lambda = self.eval lambda_string, binding
+    actual = objs.sort(&sort_lambda)
+    expected = [o1, o2, o3, o4]
+    show('(7)', lambda_string, actual, expected)
+    expect(actual).to eq(expected)
+  end
+
+  it '(8) create_lambda with date (descending) and last_modified (descending)' do
+    lambda_string = JekyllAllCollections::AllCollectionsTag.create_lambda_string(['-date', '-last_modified'])
+    expect(lambda_string).to eq('->(a, b) { [b.date, b.last_modified] <=> [a.date, a.last_modified] }')
+    sort_lambda = self.eval lambda_string, binding
+    actual = objs.sort(&sort_lambda)
+    expected = [o4, o3, o2, o1]
+    show('(8)', lambda_string, actual, expected)
+    expect(actual).to eq(expected)
+  end
+
+  it '(9) create_lambda with date (descending) and last_modified (ascending)' do
+    lambda_string = JekyllAllCollections::AllCollectionsTag.create_lambda_string(['-date', 'last_modified'])
+    expect(lambda_string).to eq('->(a, b) { [b.date, a.last_modified] <=> [a.date, b.last_modified] }')
+    sort_lambda = self.eval lambda_string, binding
+    actual = objs.sort(&sort_lambda)
+    expected = [o4, o2, o3, o1]
+    show('(9)', lambda_string, actual, expected)
+    expect(actual).to eq(expected)
+  end
+
+  it '(10) create_lambda with date (ascending) and last_modified (descending)' do
+    lambda_string = JekyllAllCollections::AllCollectionsTag.create_lambda_string(['date', '-last_modified'])
+    expect(lambda_string).to eq('->(a, b) { [a.date, b.last_modified] <=> [b.date, a.last_modified] }')
+    sort_lambda = self.eval lambda_string, binding
+    actual = objs.sort(&sort_lambda)
+    expected = [o1, o3, o2, o4]
+    show('(10)', lambda_string, actual, expected)
+    expect(actual).to eq(expected)
+  end
+end

data/spec/bsearch_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+# Ruby's binary search is unsuitable because ordering requirements are not stable.
+# the value to be searched for changes the required ordering
+
+RSpec.describe(Array) do
+  before { skip('Never gonna give you up/Never gonna let you down') }
+
+  sorted_ints = [0, 4, 7, 10, 12]
+  sorted_strings = %w[aaa aab aac bbb bbc bbd ccc ccd cce].sort.reverse
+
+  it 'returns index of first int match' do
+    actual = sorted_ints.bsearch_index { |x| x >= 4 }
+    expect(actual).to eq(1)
+
+    actual = sorted_ints.bsearch_index { |x| x >= 6 }
+    expect(actual).to eq(2)
+
+    actual = sorted_ints.bsearch_index { |x| x >= -1 }
+    expect(actual).to eq(0)
+
+    actual = sorted_ints.bsearch_index { |x| x >= 100 }
+    expect(actual).to be_nil
+  end
+
+  # See https://stackoverflow.com/q/79333097/553865
+  it 'returns index of first string match' do
+    puts(sorted_strings.map { |x| x.start_with? 'a' })
+    index = sorted_strings.bsearch_index { |x| x.start_with? 'a' }
+    expect(sorted_strings[index]).to eq('aac')
+
+    index = sorted_strings.bsearch_index { |x| x.start_with? 'aa' }
+    expect(sorted_strings[index]).to eq('aac')
+
+    index = sorted_strings.bsearch_index { |x| x.start_with? 'aaa' }
+    expect(sorted_strings[index]).to eq('aaa')
+
+    index = sorted_strings.bsearch_index { |x| x.start_with? 'b' }
+    expect(sorted_strings[index]).to eq('bbd')
+
+    index = sorted_strings.bsearch_index { |x| x.start_with? 'bb' }
+    expect(sorted_strings[index]).to eq('bbd')
+
+    index = sorted_strings.bsearch_index { |x| x.start_with? 'bbc' }
+    expect(sorted_strings[index]).to eq('bbc')
+
+    index = sorted_strings.bsearch_index { |x| x.start_with? 'cc' }
+    expect(sorted_strings[index]).to eq('cce')
+  end
+end

data/spec/custom_error_spec.rb

@@ -1,5 +1,7 @@
-require_relative '../lib/jekyll_custom_error'
-require_relative '../lib/jekyll_plugin_support_class'
+require 'spec_helper'
+require_relative '../lib/error/jekyll_custom_error'
+require_relative '../lib/jekyll_plugin_support/jekyll_plugin_support_class'
+require_relative '../lib/helper/jekyll_plugin_helper'
 
 class Dummy
   def just_for_testing; end
@@ -8,30 +10,30 @@ end
 class CustomErrorSpec
   tag_name = 'test_tag'
   argument_string = 'This is the argument string'
-  AnError = JekyllSupport.define_error
+  AnError = ::JekyllSupport.define_error
   AnError.class_variable_set(:@@tag_name, tag_name)
   AnError.class_variable_set(:@@argument_string, argument_string)
 
   puts "AnError is a #{AnError.class}; StandardError is a #{StandardError.class}"
   begin
-    raise AnError, 'Oops'
+    raise AnError, 'This error is expected'
   rescue AnError => e
     puts "Caught AnError: #{e.message}"
-  rescue JekyllSupport::CustomError => e
+  rescue ::JekyllSupport::CustomError => e
     puts "Caught CustomError: #{e.message}"
   end
 
-  RSpec.describe JekyllPluginHelper do
+  RSpec.describe ::JekyllSupport::JekyllPluginHelper do
     it 'generates messages' do
       msg = described_class.generate_message(Dummy, tag_name, '0.1.0')
       puts msg
-      expect(msg).to include(match(/Error class. DummyError/))
-      expect(msg).to include(match(/CSS class for error messages. dummy_error/))
-      expect(msg).to include(match(/die_on_dummy_error. false/))
+      expect(msg).to include('Error class: DummyError')
+      expect(msg).to include('CSS class for error messages: dummy_error')
+      expect(msg).to include('die_on_dummy_error: false')
     end
   end
 
-  RSpec.describe JekyllSupport::CustomError do
+  RSpec.describe ::JekyllSupport::CustomError do
     it 'can create custom errors' do
       expect { raise AnError, 'Oops' }.to raise_error(AnError)
     end