lbenicio-minimal-v1 1.0.2 → 1.0.5

data/benchmark/capture-assign.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'liquid'
+require 'benchmark/ips'
+
+puts "Ruby #{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}"
+puts "Liquid #{Liquid::VERSION}"
+
+template1 = '{% capture foobar %}foo{{ bar }}{% endcapture %}{{ foo }}{{ foobar }}'
+template2 = '{% assign foobar = "foo" | append: bar %}{{ foobar }}'
+
+def render(template)
+  Liquid::Template.parse(template).render('bar' => '42')
+end
+
+puts render(template1)
+puts render(template2)
+
+Benchmark.ips do |x|
+  x.report('capture') { render(template1) }
+  x.report('assign')  { render(template2) }
+end

data/benchmark/conditional_liquid.rb

@@ -0,0 +1,102 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'liquid'
+require 'benchmark/ips'
+
+# Test if processing content string without any Liquid constructs, via Liquid,
+# is slower than checking whether constructs exist ( using `String#include?` )
+# and return-ing the "plaintext" content string as is..
+#
+# Ref: https://github.com/jekyll/jekyll/pull/6735
+
+# Sample contents
+WITHOUT_LIQUID = <<~TEXT
+  Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce auctor libero at
+  pharetra tempus. Etiam bibendum magna et metus fermentum, eu cursus lorem
+  mattis. Curabitur vel dui et lacus rutrum suscipit et eget neque.
+
+  Nullam luctus fermentum est id blandit. Phasellus consectetur ullamcorper
+  ligula, at finibus eros laoreet id. Etiam sit amet est in libero efficitur
+  tristique. Ut nec magna augue. Quisque ut fringilla lacus, ac dictum enim.
+  Aliquam vel ornare mauris. Suspendisse ornare diam tempor nulla facilisis
+  aliquet. Sed ultrices placerat ultricies.
+TEXT
+
+WITH_LIQUID = <<~LIQUID
+  Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce auctor libero at
+  pharetra tempus. {{ author }} et metus fermentum, eu cursus lorem
+  mattis. Curabitur vel dui et lacus rutrum suscipit et eget neque.
+
+  Nullam luctus fermentum est id blandit. Phasellus consectetur ullamcorper
+  ligula, {% if author == "Jane Doe" %} at finibus eros laoreet id. {% else %}
+  Etiam sit amet est in libero efficitur.{% endif %}
+  tristique. Ut nec magna augue. Quisque ut fringilla lacus, ac dictum enim.
+  Aliquam vel ornare mauris. Suspendisse ornare diam tempor nulla facilisis
+  aliquet. Sed ultrices placerat ultricies.
+LIQUID
+
+WITH_JUST_LIQUID_VAR = <<~LIQUID
+  Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce auctor libero at
+  pharetra tempus. et metus fermentum, eu cursus lorem, ac dictum enim.
+  mattis. Curabitur vel dui et lacus rutrum suscipit et {{ title }} neque.
+
+  Nullam luctus fermentum est id blandit. Phasellus consectetur ullamcorper
+  ligula, at finibus eros laoreet id. Etiam sit amet est in libero efficitur.
+  tristique. Ut nec magna augue. {{ author }} Quisque ut fringilla lacus
+  Aliquam vel ornare mauris. Suspendisse ornare diam tempor nulla facilisis
+  aliquet. Sed ultrices placerat ultricies.
+LIQUID
+
+SUITE = {
+  "plain text": WITHOUT_LIQUID,
+  "tags n vars": WITH_LIQUID,
+  "just vars": WITH_JUST_LIQUID_VAR
+}.freeze
+
+# Mimic how Jekyll's LiquidRenderer would process a non-static file, with
+# some dummy payload
+def always_liquid(content)
+  Liquid::Template.error_mode = :warn
+  Liquid::Template.parse(content, line_numbers: true).render(
+    'author' => 'John Doe',
+    'title' => 'FooBar'
+  )
+end
+
+# Mimic how the proposed change would first execute a couple of checks and
+# proceed to process with Liquid if necessary
+def conditional_liquid(content)
+  return content if content.nil? || content.empty?
+  return content unless content.include?('{%') || content.include?('{{')
+
+  always_liquid(content)
+end
+
+# Test https://github.com/jekyll/jekyll/pull/6735#discussion_r165499868
+# ------------------------------------------------------------------------
+def check_with_regex(content)
+  !content.to_s.match?(/{[{%]/)
+end
+
+def check_with_builtin(content)
+  content.include?('{%') || content.include?('{{')
+end
+
+SUITE.each do |key, text|
+  Benchmark.ips do |x|
+    x.report("regex-check   - #{key}") { check_with_regex(text) }
+    x.report("builtin-check - #{key}") { check_with_builtin(text) }
+    x.compare!
+  end
+end
+# ------------------------------------------------------------------------
+
+# Let's roll!
+SUITE.each do |key, text|
+  Benchmark.ips do |x|
+    x.report("always thru liquid - #{key}") { always_liquid(text) }
+    x.report("conditional liquid - #{key}") { conditional_liquid(text) }
+    x.compare!
+  end
+end

data/benchmark/end-with-vs-regexp

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'benchmark/ips'
+
+Benchmark.ips do |x|
+  path_without_ending_slash = '/some/very/very/long/path/to/a/file/i/like'
+  x.report('no slash regexp')    { path_without_ending_slash =~ %r{/$} }
+  x.report('no slash end_with?') { path_without_ending_slash.end_with?('/') }
+  x.report('no slash [-1, 1]') { path_without_ending_slash[-1, 1] == '/' }
+end
+
+Benchmark.ips do |x|
+  path_with_ending_slash = '/some/very/very/long/path/to/a/file/i/like/'
+  x.report('slash regexp')    { path_with_ending_slash =~ %r{/$} }
+  x.report('slash end_with?') { path_with_ending_slash.end_with?('/') }
+  x.report('slash [-1, 1]')   { path_with_ending_slash[-1, 1] == '/' }
+end

data/benchmark/file-dir-ensure-trailing-slash

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'benchmark/ips'
+
+# For this pull request, which changes Page#dir
+# https://github.com/jekyll/jekyll/pull/4403
+
+FORWARD_SLASH = '/'
+
+def pre_pr(url)
+  url[-1, 1] == FORWARD_SLASH ? url : File.dirname(url)
+end
+
+def pr(url)
+  if url.end_with?(FORWARD_SLASH)
+    url
+  else
+    url_dir = File.dirname(url)
+    url_dir.end_with?(FORWARD_SLASH) ? url_dir : "#{url_dir}/"
+  end
+end
+
+def envygeeks(url)
+  return url if url.end_with?(FORWARD_SLASH) || url == FORWARD_SLASH
+
+  url = File.dirname(url)
+  url == FORWARD_SLASH ? url : "#{url}/"
+end
+
+# Just a slash
+Benchmark.ips do |x|
+  path = '/'
+  x.report("pre_pr:#{path}")    { pre_pr(path) }
+  x.report("pr:#{path}")        { pr(path) }
+  x.report("envygeeks:#{path}") { pr(path) }
+  x.compare!
+end
+
+# No trailing slash
+Benchmark.ips do |x|
+  path = '/some/very/very/long/path/to/a/file/i/like'
+  x.report("pre_pr:#{path}")    { pre_pr(path) }
+  x.report("pr:#{path}")        { pr(path) }
+  x.report("envygeeks:#{path}") { pr(path) }
+  x.compare!
+end
+
+# No trailing slash
+Benchmark.ips do |x|
+  path = '/some/very/very/long/path/to/a/file/i/like/'
+  x.report("pre_pr:#{path}")    { pre_pr(path) }
+  x.report("pr:#{path}")        { pr(path) }
+  x.report("envygeeks:#{path}") { pr(path) }
+  x.compare!
+end

data/benchmark/find-filter-vs-where-first-filters.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'benchmark/ips'
+require_relative '../lib/jekyll'
+
+puts ''
+print 'Setting up... '
+
+SITE = Jekyll::Site.new(
+  Jekyll.configuration({
+                         'source' => File.expand_path('../docs', __dir__),
+                         'destination' => File.expand_path('../docs/_site', __dir__),
+                         'disable_disk_cache' => true,
+                         'quiet' => true
+                       })
+)
+
+TEMPLATE_1 = Liquid::Template.parse(<<~HTML)
+  {%- assign doc = site.documents | where: 'url', '/docs/assets/' | first -%}
+  {{- doc.title -}}
+HTML
+
+TEMPLATE_2 = Liquid::Template.parse(<<~HTML)
+  {%- assign doc = site.documents | find: 'url', '/docs/assets/' -%}
+  {{- doc.title -}}
+HTML
+
+%i[reset read generate].each { |phase| SITE.send(phase) }
+
+puts 'done.'
+puts 'Testing... '
+puts "  #{'where + first'.cyan} results in #{TEMPLATE_1.render(SITE.site_payload).inspect.green}"
+puts "  #{'find'.cyan} results in #{TEMPLATE_2.render(SITE.site_payload).inspect.green}"
+
+if TEMPLATE_1.render(SITE.site_payload) == TEMPLATE_2.render(SITE.site_payload)
+  puts 'Success! Proceeding to run benchmarks.'.green
+  puts ''
+else
+  puts 'Something went wrong. Aborting.'.magenta
+  puts ''
+  return
+end
+
+Benchmark.ips do |x|
+  x.report('where + first') { TEMPLATE_1.render(SITE.site_payload) }
+  x.report('find') { TEMPLATE_2.render(SITE.site_payload) }
+  x.compare!
+end

data/benchmark/flat-map

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'benchmark/ips'
+
+enum = (0..50).to_a
+nested = enum.map { |i| [i] }
+
+def do_thing(blah)
+  blah * 1
+end
+
+Benchmark.ips do |x|
+  x.report('.map.flatten with nested arrays') { nested.map { |i| do_thing(i) }.flatten(1) }
+  x.report('.flat_map with nested arrays')    { nested.flat_map { |i| do_thing(i) } }
+
+  x.report('.map.flatten with no nested arrays') { enum.map { |i| do_thing(i) }.flatten(1) }
+  x.report('.flat_map with no nested arrays')    { enum.flat_map { |i| do_thing(i) } }
+end

data/benchmark/hash-fetch

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'benchmark/ips'
+
+h = { bar: 'uco' }
+
+Benchmark.ips do |x|
+  x.report('fetch with no block') { h.fetch(:bar, (0..9).to_a)    }
+  x.report('fetch with a block')  { h.fetch(:bar) { (0..9).to_a } }
+  x.report('brackets with an ||') { h[:bar] || (0..9).to_a        }
+end

data/benchmark/jekyll-sanitize-path

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/jekyll'
+require 'benchmark/ips'
+
+base_directory = Dir.pwd
+
+Benchmark.ips do |x|
+  #
+  # Does not include the base_directory
+  #
+  x.report('with no questionable path') do
+    Jekyll.sanitized_path(base_directory, '')
+  end
+  x.report('with a single-part questionable path') do
+    Jekyll.sanitized_path(base_directory, 'thingy')
+  end
+  x.report('with a multi-part questionable path') do
+    Jekyll.sanitized_path(base_directory, 'thingy/in/my/soup')
+  end
+  x.report('with a single-part traversal path') do
+    Jekyll.sanitized_path(base_directory, '../thingy')
+  end
+  x.report('with a multi-part traversal path') do
+    Jekyll.sanitized_path(base_directory, '../thingy/in/my/../../soup')
+  end
+
+  #
+  # Including the base_directory
+  #
+  x.report('with the exact same paths') do
+    Jekyll.sanitized_path(base_directory, base_directory)
+  end
+  x.report('with a single-part absolute path including the base_directory') do
+    Jekyll.sanitized_path(base_directory, File.join(base_directory, 'thingy'))
+  end
+  x.report('with a multi-part absolute path including the base_directory') do
+    Jekyll.sanitized_path(base_directory, File.join(base_directory, 'thingy/in/my/soup'))
+  end
+  x.report('with a single-part traversal path including the base_directory') do
+    Jekyll.sanitized_path(base_directory, File.join(base_directory, 'thingy/..'))
+  end
+  x.report('with a multi-part traversal path including the base_directory') do
+    Jekyll.sanitized_path(base_directory, File.join('thingy/in/my/../../soup'))
+  end
+end

data/benchmark/local-require

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'benchmark/ips'
+require 'jekyll'
+require 'json'
+
+DATA = { 'foo' => 'bar', 'alpha' => { 'beta' => 'gamma' }, 'lipsum' => %w[lorem ipsum dolor] }.freeze
+
+def local_require
+  require 'json'
+  JSON.pretty_generate(DATA)
+end
+
+def global_require
+  JSON.pretty_generate(DATA)
+end
+
+def graceful_require
+  Jekyll::External.require_with_graceful_fail('json')
+  JSON.pretty_generate(DATA)
+end
+
+Benchmark.ips do |x|
+  x.report('local-require') { local_require }
+  x.report('global-require') { global_require }
+  x.report('graceful-require') { graceful_require }
+  x.compare!
+end

data/benchmark/native-vs-pathutil-relative

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# -------------------------------------------------------------------
+# Benchmarking changes in https://github.com/jekyll/jekyll/pull/6767
+# -------------------------------------------------------------------
+
+require 'benchmark/ips'
+require 'pathutil'
+
+DOC_PATH = File.join(File.expand_path(__dir__), '_puppies', 'rover.md')
+COL_PATH = File.join(File.expand_path(__dir__), '_puppies')
+
+def pathutil_relative
+  Pathutil.new(DOC_PATH).relative_path_from(COL_PATH).to_s
+end
+
+def native_relative
+  DOC_PATH.sub("#{COL_PATH}/", '')
+end
+
+if pathutil_relative == native_relative
+  Benchmark.ips do |x|
+    x.report('pathutil') { pathutil_relative }
+    x.report('native')   { native_relative }
+    x.compare!
+  end
+else
+  print 'PATHUTIL: '
+  puts pathutil_relative
+  print 'NATIVE:   '
+  puts native_relative
+end

data/benchmark/parse-date

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/jekyll'
+require 'benchmark/ips'
+
+date = '2014-08-02 14:43:06 PDT'
+time = Time.parse(date)
+
+Benchmark.ips do |x|
+  x.report('Time.parse') do
+    Time.parse(date)
+  end
+
+  x.report('localtime') do
+    Time.parse(date).localtime
+  end
+
+  x.report('localtime parsed') do
+    time.localtime
+  end
+
+  x.report('Utils.parse_date') do
+    Jekyll::Utils.parse_date(date)
+  end
+end

data/benchmark/parse-include-tag-params.rb

@@ -0,0 +1,85 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# For pull request: https://github.com/jekyll/jekyll/pull/8192
+
+require 'benchmark/ips'
+require 'bundler/setup'
+require 'memory_profiler'
+require 'jekyll'
+
+CONTEXT = { 'bar' => 'The quick brown fox' }.freeze
+MARKUP_1 = %(foo=bar lorem="ipsum \\"dolor\\"" alpha='beta \\'gamma\\'')
+MARKUP_2 = %(foo=bar lorem="ipsum 'dolor'" alpha='beta "gamma"')
+
+def old_parse_params(markup)
+  params = {}
+
+  while (match = Jekyll::Tags::IncludeTag::VALID_SYNTAX.match(markup))
+    markup = markup[match.end(0)..]
+
+    value = if match[2]
+              match[2].gsub('\\"', '"')
+            elsif match[3]
+              match[3].gsub("\\'", "'")
+            elsif match[4]
+              CONTEXT[match[4]]
+            end
+
+    params[match[1]] = value
+  end
+  params
+end
+
+def new_parse_params(markup)
+  params = {}
+  markup.scan(Jekyll::Tags::IncludeTag::VALID_SYNTAX) do |key, d_quoted, s_quoted, variable|
+    value = if d_quoted
+              d_quoted.include?('\\"') ? d_quoted.gsub('\\"', '"') : d_quoted
+            elsif s_quoted
+              s_quoted.include?("\\'") ? s_quoted.gsub("\\'", "'") : s_quoted
+            elsif variable
+              CONTEXT[variable]
+            end
+
+    params[key] = value
+  end
+  params
+end
+
+def report(label, markup, color, &block)
+  prof_report = MemoryProfiler.report(&block)
+
+  allocated_memory  = prof_report.scale_bytes(prof_report.total_allocated_memsize)
+  allocated_objects = prof_report.total_allocated
+  retained_memory   = prof_report.scale_bytes(prof_report.total_retained_memsize)
+  retained_objects  = prof_report.total_retained
+
+  puts <<~MSG.send(color)
+    #{"#{label} ".ljust(49, '-')}
+
+    MARKUP: #{markup}
+    RESULT: #{yield}
+
+    Total allocated: #{allocated_memory} (#{allocated_objects} objects)
+    Total retained:  #{retained_memory} (#{retained_objects} objects)
+  MSG
+end
+
+report('old w/ escaping', MARKUP_1, :magenta) { old_parse_params(MARKUP_1) }
+report('new w/ escaping', MARKUP_1, :cyan)    { new_parse_params(MARKUP_1) }
+
+report('old no escaping', MARKUP_2, :green)  { old_parse_params(MARKUP_2) }
+report('new no escaping', MARKUP_2, :yellow) { new_parse_params(MARKUP_2) }
+
+Benchmark.ips do |x|
+  x.report('old + esc'.magenta) { old_parse_params(MARKUP_1) }
+  x.report('new + esc'.cyan)    { new_parse_params(MARKUP_1) }
+  x.compare!
+end
+
+Benchmark.ips do |x|
+  x.report('old - esc'.green)  { old_parse_params(MARKUP_2) }
+  x.report('new - esc'.yellow) { new_parse_params(MARKUP_2) }
+  x.compare!
+end

data/benchmark/path-manager.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'benchmark/ips'
+require 'jekyll'
+
+class FooPage
+  def initialize(dir:, name:)
+    @dir = dir
+    @name = name
+  end
+
+  def slow_path
+    File.join(*[@dir, @name].map(&:to_s).reject(&:empty?)).sub(%r{\A/}, '')
+  end
+
+  def fast_path
+    Jekyll::PathManager.join(@dir, @name).sub(%r{\A/}, '')
+  end
+end
+
+nil_page     = FooPage.new(dir: nil, name: nil)
+empty_page   = FooPage.new(dir: '', name: '')
+root_page    = FooPage.new(dir: '', name: 'ipsum.md')
+nested_page  = FooPage.new(dir: 'lorem', name: 'ipsum.md')
+slashed_page = FooPage.new(dir: '/lorem/', name: '/ipsum.md')
+
+if nil_page.slow_path == nil_page.fast_path
+  Benchmark.ips do |x|
+    x.report('nil_page slow') { nil_page.slow_path }
+    x.report('nil_page fast') { nil_page.fast_path }
+    x.compare!
+  end
+end
+
+if empty_page.slow_path == empty_page.fast_path
+  Benchmark.ips do |x|
+    x.report('empty_page slow') { empty_page.slow_path }
+    x.report('empty_page fast') { empty_page.fast_path }
+    x.compare!
+  end
+end
+
+if root_page.slow_path == root_page.fast_path
+  Benchmark.ips do |x|
+    x.report('root_page slow') { root_page.slow_path }
+    x.report('root_page fast') { root_page.fast_path }
+    x.compare!
+  end
+end
+
+if nested_page.slow_path == nested_page.fast_path
+  Benchmark.ips do |x|
+    x.report('nested_page slow') { nested_page.slow_path }
+    x.report('nested_page fast') { nested_page.fast_path }
+    x.compare!
+  end
+end
+
+if slashed_page.slow_path == slashed_page.fast_path
+  Benchmark.ips do |x|
+    x.report('slashed_page slow') { slashed_page.slow_path }
+    x.report('slashed_page fast') { slashed_page.fast_path }
+    x.compare!
+  end
+end

data/benchmark/proc-call-vs-yield

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'benchmark/ips'
+
+def fast
+  yield
+end
+
+def slow(&block)
+  block.call
+end
+
+Benchmark.ips do |x|
+  x.report('yield') { fast { (0..9).to_a } }
+  x.report('block.call') { slow { (0..9).to_a } }
+end

data/benchmark/regexp-vs-include.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'benchmark/ips'
+
+# For this pull request, which changes Page#dir
+# https://github.com/jekyll/jekyll/pull/4403
+
+CONTENT_CONTAINING = <<~HTML
+  <!DOCTYPE HTML>
+  <html lang="en-US">
+    <head>
+  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+      <meta charset="UTF-8">
+      <title>Jemoji</title>
+      <meta name="viewport" content="width=device-width,initial-scale=1">
+      <link rel="stylesheet" href="/css/screen.css">
+    </head>
+    <body class="wrap">
+      <p><img class="emoji" title=":+1:" alt=":+1:" src="https://assets.github.com/images/icons/emoji/unicode/1f44d.png" height="20" width="20" align="absmiddle"></p>
+
+    </body>
+  </html>
+HTML
+CONTENT_NOT_CONTAINING = <<~HTML
+  <!DOCTYPE HTML>
+  <html lang="en-US">
+    <head>
+  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+      <meta charset="UTF-8">
+      <title>Jemoji</title>
+      <meta name="viewport" content="width=device-width,initial-scale=1">
+      <link rel="stylesheet" href="/css/screen.css">
+    </head>
+    <body class="wrap">
+      <p><img class="emoji" title=":+1:" alt=":+1:" src="https://assets.github.com/images/icons/emoji/unicode/1f44d.png" height="20" width="20" align="absmiddle"></p>
+
+    </body>
+  </html>
+HTML
+
+Benchmark.ips do |x|
+  x.report('no body include?') { CONTENT_NOT_CONTAINING.include?('<body') }
+  x.report('no body regexp')   { CONTENT_NOT_CONTAINING =~ /<\s*body/ }
+  x.compare!
+end
+
+# No trailing slash
+Benchmark.ips do |x|
+  x.report('with body include?') { CONTENT_CONTAINING.include?('<body') }
+  x.report('with body regexp')   { CONTENT_CONTAINING =~ /<\s*body/ }
+  x.compare!
+end

data/benchmark/sanitize-url.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'benchmark/ips'
+
+PATH = '/../../..../...//.....//lorem/ipsum//dolor///sit.xyz'
+
+def sanitize_with_regex
+  "/#{PATH.gsub(%r!/{2,}!, '/').gsub(%r{\.+/|\A/+}, '')}"
+end
+
+def sanitize_with_builtin
+  "/#{PATH}".gsub('..', '/').gsub('./', '').squeeze('/')
+end
+
+if sanitize_with_regex == sanitize_with_builtin
+  Benchmark.ips do |x|
+    x.report('sanitize w/ regexes') { sanitize_with_regex }
+    x.report('sanitize w/ builtin') { sanitize_with_builtin }
+    x.compare!
+  end
+else
+  puts "w/ regexes: #{sanitize_with_regex}"
+  puts "w/ builtin: #{sanitize_with_builtin}"
+  puts ''
+  puts 'Thank you. Do try again :('
+end