terminal-layout 0.1.0

data/spec/ansi_string_spec.rb

@@ -0,0 +1,499 @@
+require 'spec_helper'
+require 'term/ansicolor'
+
+describe 'ANSIString' do
+  include Term::ANSIColor
+
+  describe "constructing" do
+    it "can be constructed with a String" do
+      ansi_string = ANSIString.new "this is a string"
+      expect(ansi_string).to be
+    end
+
+    it "can be constructed with a String containing ANSI escape sequences" do
+      ansi_string = ANSIString.new "this #{blue('is')} a string"
+      expect(ansi_string).to be
+    end
+  end
+
+  describe "redundant ANSI sequences" do
+    it "strips out redundant ANSI sequences that are immediately next to each other" do
+      ansi_string = ANSIString.new "this is\e[31m\e[31m a string"
+      expect(ansi_string.to_s).to eq "this is\e[31m a string"
+    end
+
+    it "strips out redundant ANSI sequences that are not immediately next to each other" do
+      ansi_string = ANSIString.new "this \e[31m a\e[31m string"
+      expect(ansi_string.to_s).to eq "this \e[31m a string"
+    end
+
+    it "does not strip out ANSI sequences that differ" do
+      ansi_string = ANSIString.new "this \e[31m a\e[32m string"
+      expect(ansi_string.to_s).to eq "this \e[31m a\e[32m string"
+    end
+  end
+
+  describe "#+ combining strings" do
+    let(:blue_ansi_string){ ANSIString.new blue_string }
+    let(:yellow_ansi_string){ ANSIString.new yellow_string }
+    let(:blue_string){ blue("this is blue") }
+    let(:yellow_string){ yellow("this is yellow") }
+
+    it "returns a new string when combining two ANSIStrings" do
+      expect(blue_ansi_string + yellow_ansi_string).to eq ANSIString.new(blue_string + yellow_string)
+    end
+
+    it "returns a new string when combining a ANIString with a String" do
+      expect(blue_ansi_string + yellow_string).to eq ANSIString.new(blue_string + yellow_string)
+    end
+  end
+
+  describe "#<<" do
+    it "appends a String onto the end of the current ANSIString" do
+      ansi_string = ANSIString.new ""
+      ansi_string << "a"
+      expect(ansi_string).to eq ANSIString.new("a")
+
+      ansi_string << "b"
+      expect(ansi_string).to eq ANSIString.new("ab")
+
+      ansi_string << "cd"
+      expect(ansi_string).to eq ANSIString.new("abcd")
+    end
+
+    it "appends an ANSIString onto the end of the current ANSIString" do
+      ansi_string = ANSIString.new ""
+      ansi_string << ANSIString.new(blue("a"))
+      expect(ansi_string).to eq ANSIString.new("#{blue('a')}")
+
+      ansi_string << ANSIString.new(yellow("b"))
+      expect(ansi_string).to eq ANSIString.new("#{blue('a')}#{yellow('b')}")
+
+      ansi_string << ANSIString.new(red("cd"))
+      expect(ansi_string).to eq ANSIString.new("#{blue('a')}#{yellow('b')}#{red('cd')}")
+    end
+  end
+
+  describe "#length" do
+    subject(:ansi_string){ ANSIString.new blue(string) }
+    let(:string){ "this is blue" }
+
+    it "returns the length string without ANSI escape sequences" do
+      expect(ansi_string.length).to eq string.length
+    end
+  end
+
+  describe "#index" do
+    it "returns the index of the first occurrence of the given substring" do
+      ansi_string = ANSIString.new("this is not blue")
+      expect(ansi_string.index("b")).to eq 12
+
+      ansi_string = ANSIString.new("this is #{blue('blue')}")
+      expect(ansi_string.index("blu")).to eq 8
+
+      ansi_string = ANSIString.new("this is #{blue('blue')} and this is #{yellow('yellow')}")
+      expect(ansi_string.index("yellow")).to eq 25
+    end
+
+    it "returns the index starting on or after an optional start position" do
+      ansi_string = ANSIString.new("this is not blue")
+      expect(ansi_string.index("t", 0)).to eq 0
+
+      ansi_string = ANSIString.new("this is #{blue('blue')}")
+      expect(ansi_string.index("is", 3)).to eq 5
+      expect(ansi_string.index("bl", 7)).to eq 8
+      expect(ansi_string.index("bl", 9)).to eq nil
+
+      ansi_string = ANSIString.new("this is #{blue('blue')} and this is #{yellow('yellow')}")
+      expect(ansi_string.index("yel", 5)).to eq 25
+      expect(ansi_string.index("yel", 25)).to eq 25
+      expect(ansi_string.index("yel", 26)).to eq nil
+    end
+
+    it "returns the index of the first occurrence of the given regular expression" do
+      ansi_string = ANSIString.new("this is not blue")
+      expect(ansi_string.index(/b/)).to eq 12
+
+      ansi_string = ANSIString.new("this is #{blue('blue')}")
+      expect(ansi_string.index(/blu/)).to eq 8
+
+      ansi_string = ANSIString.new("this is #{blue('blue')} and this is #{yellow('yellow')}")
+      expect(ansi_string.index(/y.ll.w/)).to eq 25
+    end
+  end
+
+  describe "#rindex" do
+    it "returns the index of the last occurrence of the given substring" do
+      ansi_string = ANSIString.new("this is not blue")
+      expect(ansi_string.rindex("i")).to eq 5
+
+      ansi_string = ANSIString.new("this is #{blue('blue')}")
+      expect(ansi_string.rindex("blu")).to eq 8
+
+      ansi_string = ANSIString.new("this is #{blue('blue')} and this is #{yellow('yellow')}")
+      expect(ansi_string.rindex("yellow")).to eq 25
+    end
+
+    it "returns the index of the match on or after an optional stop position" do
+      ansi_string = ANSIString.new("this is not blue")
+      expect(ansi_string.rindex("t", 0)).to eq 0
+      expect(ansi_string.rindex("is", 3)).to eq 2
+      expect(ansi_string.rindex("bl", 12)).to eq 12
+
+      ansi_string = ANSIString.new("this is #{blue('blue')}")
+      expect(ansi_string.rindex("is", 0)).to eq nil
+      expect(ansi_string.rindex("is", 3)).to eq 2
+      expect(ansi_string.rindex("bl", 8)).to eq 8
+      expect(ansi_string.rindex("bl", 12)).to eq 8
+
+      ansi_string = ANSIString.new("this is #{blue('blue')} and this is #{yellow('yellow')}")
+      expect(ansi_string.rindex("yel", 5)).to eq nil
+      expect(ansi_string.rindex("yel", 25)).to eq 25
+      expect(ansi_string.rindex("yel", 26)).to eq 25
+    end
+
+    it "returns the index of the last occurrence of the given regular expression" do
+      ansi_string = ANSIString.new("this is not blue")
+      expect(ansi_string.rindex(/b/)).to eq 12
+
+      ansi_string = ANSIString.new("this is #{blue('blue')}")
+      expect(ansi_string.rindex(/blu/)).to eq 8
+
+      ansi_string = ANSIString.new("this is #{blue('blue')} and this is #{yellow('yellow')}")
+      expect(ansi_string.rindex(/y.ll.w/)).to eq 25
+    end
+  end
+
+  describe "#[]" do
+    subject(:ansi_string){ ANSIString.new "#{blue_string}ABC#{yellow_string}" }
+    let(:blue_string){ blue("this is blue") }
+    let(:yellow_string){ yellow("this is yellow") }
+
+    it "returns the full substring with the appropriate ANSI start and end sequence" do
+      expect(ansi_string[0...12]).to eq ANSIString.new(blue("this is blue"))
+      expect(ansi_string[15..-1]).to eq ANSIString.new(yellow("this is yellow"))
+    end
+
+    it "returns a partial substring with the appropriate ANSI start sequence and provides an end sequence" do
+      expect(ansi_string[0..1]).to eq blue("th")
+      expect(ansi_string[17..-5]).to eq yellow("is is ye")
+    end
+
+    it "returns text that is not ANSI escaped" do
+      expect(ansi_string[12..14]).to eq "ABC"
+    end
+
+    it "returns up to the end" do
+      expect(ansi_string[-2..-1]).to eq yellow("ow")
+    end
+
+    context "and the range is around the ANSI sequence location in the string" do
+      it "returns the string with the ANSI sequences within it intact" do
+        ansi_string = ANSIString.new "abc#{green('def')}ghi"
+        expect(ansi_string[0..-1]).to eq "abc#{green('def')}ghi"
+      end
+
+      it "returns the string with the ANSI sequences within it intact" do
+        ansi_string = ANSIString.new "abc#{green('def')}ghi"
+        expect(ansi_string[0..2]).to eq "abc"
+      end
+    end
+
+    it "returns nil when the given range is beyond the length of the string" do
+      ansi_string = ANSIString.new "abc"
+      expect(ansi_string[4]).to be nil
+    end
+  end
+
+  describe "#[]=" do
+    subject(:ansi_string){ ANSIString.new blue(string) }
+    let(:string){ "this is blue" }
+
+    it "returns a new ANSIString with the string at the given index replaced with the new string" do
+      ansi_string[1] = "Z"
+      expect(ansi_string).to eq ANSIString.new(blue("tZis is blue"))
+    end
+
+    it "returns a new ANSIString with the string at the given range replaced with the new string" do
+      ansi_string[1..2] = "ZYX"
+      expect(ansi_string).to eq ANSIString.new(blue("tZYXs is blue"))
+    end
+
+    it "preserves coloring when part of the text with a String" do
+      ansi_string[0..3] = "that"
+      expect(ansi_string).to eq ANSIString.new(blue("that is blue"))
+    end
+
+    it "preserves coloring when replacing all of the text with a String" do
+      ansi_string[0..11] = "foobar"
+      expect(ansi_string).to eq ANSIString.new(blue("foobar"))
+    end
+
+    it "preserves coloring when part of the text with a String and we're not starting at an index of 0" do
+      ansi_string[5..6] = "ain't"
+      expect(ansi_string).to eq ANSIString.new(blue("this ain't blue"))
+    end
+
+    context "appending a string to the very end" do
+      subject(:ansi_string){ ANSIString.new green("CircleCI pass") }
+
+      it "combines when the ANSI sequences are the same" do
+        ansi_string[13..15] = ANSIString.new green("ed")
+        expect(ansi_string).to eq ANSIString.new(green("CircleCI passed"))
+      end
+
+      it "doesn't combine when the ANSI sequences are different" do
+        ansi_string[13..15] = ANSIString.new red("ed")
+        expect(ansi_string).to eq ANSIString.new(green("CircleCI pass") + red("ed"))
+      end
+    end
+
+    context "replacing on newline boundaries" do
+      subject(:ansi_string){ ANSIString.new "this\nthat" }
+
+      it "keeps the new line intact" do
+        ansi_string[2...4] = "IS"
+        expect(ansi_string).to eq ANSIString.new("thIS\nthat")
+      end
+    end
+
+    context "replacing the same location twice" do
+      subject(:ansi_string){ ANSIString.new "this\nthat" }
+
+      it "keeps the new line intact" do
+        ansi_string[2...4] = blue("IS")
+        ansi_string[2...4] = blue("IS")
+        expect(ansi_string).to eq ANSIString.new("th#{blue('IS')}\nthat")
+      end
+    end
+
+    context "replacing a substring that goes across ANSI sequence boundaries" do
+      subject(:ansi_string){ ANSIString.new "this#{blue('that')}" }
+
+      it "successfully moves the boundaries" do
+        ansi_string[3..4] = yellow("SORRY")
+        expect(ansi_string).to eq ANSIString.new("thi#{yellow('SORRY')}#{blue('hat')}")
+      end
+    end
+
+    it "raises an error out of index" do
+      expect {
+        ansi_string[14..15] = string
+      }.to raise_error(RangeError, "14..15 out of range")
+    end
+
+    context "replacing a substring that comes entirely after an ANSI sequence" do
+      subject(:ansi_string){ ANSIString.new "this #{blue('is')} your television screen." }
+
+      it "places the substring in the correct location" do
+        ansi_string[14..15] = "YO YO"
+        expect(ansi_string).to eq ANSIString.new "this #{blue('is')} your tYO YOevision screen."
+      end
+    end
+  end
+
+  describe "#dup" do
+    subject(:ansi_string){ ANSIString.new blue(string) }
+    let(:string){ "this is blue" }
+
+    it "returns a dup'd version of itself" do
+      duped = ansi_string.dup
+      expect(duped).to be_kind_of(ANSIString)
+      expect(duped.raw).to eq(ansi_string.raw)
+    end
+  end
+
+  describe "#lines" do
+    subject(:ansi_string){ ANSIString.new blue(string) }
+    let(:string){ "this\nis\nblue" }
+
+    it "returns lines" do
+      expect(ansi_string.lines).to eq [
+        ANSIString.new(blue("this\n")),
+        ANSIString.new(blue("is\n")),
+        ANSIString.new(blue("blue"))
+      ]
+    end
+
+    it "returns lines" do
+      ansi_string = ANSIString.new blue("abc") + "\n" + red("d\nef") + "hi\n" + yellow("foo")
+      expect(ansi_string.lines).to eq [
+        ANSIString.new(blue("abc") + "\n"),
+        ANSIString.new(red("d\n")),
+        ANSIString.new(red("ef") + "hi\n"),
+        ANSIString.new(yellow("foo"))
+      ]
+    end
+  end
+
+  describe "#==" do
+    subject(:ansi_string){ ANSIString.new blue(string) }
+    let(:string){ "this is blue" }
+
+    it "returns true when comparing against itself" do
+      expect(ansi_string).to eq ansi_string
+    end
+
+    it "returns true when comparing against another ANSIString with the same contents" do
+      expect(ansi_string).to eq ANSIString.new(blue(string))
+    end
+
+    it "returns false when comparing against another ANSIString with differnent contents" do
+      expect(ansi_string).to_not eq ANSIString.new(blue("other stuff"))
+    end
+
+    it "returns true when comparing against a String with the same raw contents" do
+      expect(ansi_string).to eq blue(string)
+    end
+
+    it "returns true when comparing against a String that doesn't match its raw contents" do
+      expect(ansi_string).to_not eq "asfsd"
+    end
+  end
+
+  describe "#match" do
+    it "matches on a string pattren" do
+      string = "apples are bananas are they not?"
+      ansi_string = ANSIString.new("app#{red('les are bananas')} are they not?")
+      expect(ansi_string.match("are")).to eq(string.match("are"))
+    end
+
+    it "matches on a regex pattren" do
+      string = "apples are bananas are they not?"
+      ansi_string = ANSIString.new("app#{red('les are bananas')} are they not?")
+      expect(ansi_string.match(/are/)).to eq(string.match(/are/))
+    end
+  end
+
+  describe "#reverse" do
+    it "reverses the string" do
+      ansi_string = ANSIString.new("abc")
+      expect(ansi_string.reverse).to eq ANSIString.new("cba")
+    end
+
+    it "reverses the string with ANSI sequences" do
+      ansi_string = ANSIString.new("a#{blue('b')}#{yellow('c')}")
+      expect(ansi_string.reverse).to eq ANSIString.new("#{yellow('c')}#{blue('b')}a")
+    end
+  end
+
+  describe "#slice" do
+    it "returns a substring of one character given a numeric index" do
+      ansi_string = ANSIString.new("a#{blue('b')}c")
+      expect(ansi_string.slice(0)).to eq ANSIString.new("a")
+      expect(ansi_string.slice(1)).to eq ANSIString.new(blue("b"))
+      expect(ansi_string.slice(2)).to eq ANSIString.new("c")
+    end
+
+    it "returns a substring of characters of N length given a start index and max length N" do
+      ansi_string = ANSIString.new("a#{blue('b')}c")
+      expect(ansi_string.slice(0, 2)).to eq ANSIString.new("a#{blue('b')}")
+      expect(ansi_string.slice(1, 2)).to eq ANSIString.new("#{blue('b')}c")
+
+      # length is over, doesn't blow up
+      expect(ansi_string.slice(1, 3)).to eq ANSIString.new("#{blue('b')}c")
+    end
+
+    it "returns a substring of characters using a range as delimiters" do
+      ansi_string = ANSIString.new("a#{blue('b')}c")
+      expect(ansi_string.slice(0..1)).to eq ANSIString.new("a#{blue('b')}")
+      expect(ansi_string.slice(0...2)).to eq ANSIString.new("a#{blue('b')}")
+
+      # length is over, doesn't blow up
+      expect(ansi_string.slice(1..3)).to eq ANSIString.new("#{blue('b')}c")
+    end
+
+    it "returns a substring of characters matching the given regex" do
+      ansi_string = ANSIString.new("a#{blue('b')}c")
+      expect(ansi_string.slice(/b/)).to eq ANSIString.new("#{blue('b')}")
+      expect(ansi_string.slice(/(b)c/)).to eq ANSIString.new("#{blue('b')}c")
+
+      # length is over, doesn't blow up
+      expect(ansi_string.slice(/.*/)).to eq ANSIString.new("a#{blue('b')}c")
+    end
+
+    it "returns a substring for the capture group matching the given regex and capture group index" do
+      ansi_string = ANSIString.new("a#{blue('b')}c")
+      expect(ansi_string.slice(/((a)(b)(c))/, 1)).to eq ANSIString.new("a#{blue('b')}c")
+      expect(ansi_string.slice(/((a)(b)(c))/, 2)).to eq ANSIString.new("a")
+      expect(ansi_string.slice(/((a)(b)(c))/, 3)).to eq ANSIString.new("#{blue('b')}")
+      expect(ansi_string.slice(/((a)(b)(c))/, 4)).to eq ANSIString.new("c")
+    end
+
+    it "returns the substring when a given string is found" do
+      ansi_string = ANSIString.new("a#{blue('b')}c")
+      expect(ansi_string.slice("bc")).to eq(ANSIString.new("#{blue('b')}c"))
+    end
+
+    it "returns nil when no matches are found" do
+      ansi_string = ANSIString.new("a#{blue('b')}c")
+      expect(ansi_string.slice("zzz")).to be nil
+      expect(ansi_string.slice(/zzz/)).to be nil
+      expect(ansi_string.slice(99)).to be nil
+      expect(ansi_string.slice(99, 100)).to be nil
+      expect(ansi_string.slice(99..100)).to be nil
+    end
+  end
+
+  describe "#split" do
+    it "splits on the given string pattern" do
+      ansi_string = ANSIString.new("apples are #{red('red')}. bananas are #{blue('blue')}. cats are #{yellow('yellow')}.")
+      expect(ansi_string.split(". ")).to eq([
+        ANSIString.new("apples are #{red('red')}"),
+        ANSIString.new("bananas are #{blue('blue')}"),
+        ANSIString.new("cats are #{yellow('yellow')}.")
+      ])
+    end
+
+    it "splits on the given regex pattern" do
+      ansi_string = ANSIString.new("apples are #{red('red')}. bananas are #{blue('blue')}. cats are #{yellow('yellow')}.")
+      expect(ansi_string.split(/\.\s?/)).to eq([
+        ANSIString.new("apples are #{red('red')}"),
+        ANSIString.new("bananas are #{blue('blue')}"),
+        ANSIString.new("cats are #{yellow('yellow')}")
+      ])
+    end
+
+    it "limits how many times it splits with a secondary limit argument" do
+      ansi_string = ANSIString.new("apples are #{red('red')}. bananas are #{blue('blue')}. cats are #{yellow('yellow')}.")
+      expect(ansi_string.split(/\.\s?/, 2)).to eq([
+        ANSIString.new("apples are #{red('red')}"),
+        ANSIString.new("bananas are #{blue('blue')}. cats are #{yellow('yellow')}.")
+      ])
+    end
+  end
+
+  describe "#sub" do
+    subject(:ansi_string){ ANSIString.new blue(string) }
+    let(:string){ "this is blue" }
+
+    it "returns an ANSIString" do
+      expect(ansi_string.sub(/ is /, "")).to eq ANSIString.new(blue("thisblue"))
+    end
+
+    it "works across ansi sequences" do
+      blue_string = blue("this is blue")
+      yellow_string = yellow("this is yellow")
+      non_colored_string = "hi there\nbye there"
+      str = ANSIString.new(blue_string + yellow_string + non_colored_string + "  \n   \n   \n    ")
+      expect(str.sub(/\s*\Z/m, "")).to eq ANSIString.new(blue_string + yellow_string + non_colored_string)
+    end
+  end
+
+  describe "#gsub" do
+    it "needs to be implemented"
+  end
+
+  describe "#to_s" do
+    subject(:ansi_string){ ANSIString.new blue(string) }
+    let(:string){ "this is blue" }
+
+    it "returns the ANSI capable string" do
+      expect(ansi_string.to_s).to eq blue(string)
+    end
+  end
+
+  describe "#succ" do
+    it "needs to be implemented"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,102 @@
+$LOAD_PATH << File.dirname(__FILE__) + "/../lib"
+
+require 'pry'
+require 'terminal_layout'
+require 'ansi_string'
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end