terminal-layout 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: effa639a6efd09195fc644fe6d4b325191ca7905
-  data.tar.gz: 187b259dcc98d8584948c4856772d440c6895564
+  metadata.gz: 97802dee983f8248f8d8406cf323754b8768613a
+  data.tar.gz: 7af99e4ca121f6cf67668985954e2f52bb26aa87
 SHA512:
-  metadata.gz: e2538c3ca865a7d81c0bc562d1a6c6c71da80fc345785ad3f3c138bb1622c0917369b36081244b48e309a7dc1fd63d4399e876341fe0b7834150a5d59c92d982
-  data.tar.gz: 5e57352329d7cf5cecd6b09d98d6d6d65fb8931b32dc0fdc7db510a8428842ec07a6fd58a45b77aee3a803aeaa8ce775a39eda2635a3d9e19b17411752aac86f
+  metadata.gz: 5698f4d780074e3b2d10540a7dbbb27f7d0f6046ac93826ca86be379aa43266c997826b5723c0605788bc9b67080c9f4715cc647dd021d2f35e4eef8a08762e7
+  data.tar.gz: cf51538f560efbd170bb726cef284adebbede5599ae418f626f011447a2fcbadefe745c501c0a8187770c1104c344f2907238ff70ecfab5a19043e3d4fcd687e

data/Gemfile.lock

@@ -1,7 +1,8 @@
 PATH
   remote: .
   specs:
-    terminal-layout (0.4.0)
+    terminal-layout (0.4.1)
+      ansi_string (~> 0.1)
       highline (~> 1.7, >= 1.7.8)
       ruby-terminfo (~> 0.1.1)
       ruby-termios (~> 0.9.6)
@@ -10,6 +11,7 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
+    ansi_string (0.1.0)
     byebug (5.0.0)
       columnize (= 0.9.0)
     coderay (1.1.0)

data/lib/terminal_layout/version.rb

@@ -1,3 +1,3 @@
 module TerminalLayout
-  VERSION = "0.4.0"
+  VERSION = "0.4.1"
 end

data/lib/terminal_layout.rb

@@ -1,5 +1,5 @@
-require 'ansi_string'
 require 'ostruct'
+require 'ansi_string'
 require 'treefell'
 
 module TerminalLayout

data/terminal-layout.gemspec

@@ -18,6 +18,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
+  spec.add_dependency 'ansi_string', '~> 0.1'
   spec.add_dependency "ruby-terminfo", "~> 0.1.1"
   spec.add_dependency "ruby-termios", "~> 0.9.6"
   spec.add_dependency 'highline', '~> 1.7', '>= 1.7.8'

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: terminal-layout
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Zach Dennis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-27 00:00:00.000000000 Z
+date: 2016-07-01 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: ansi_string
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
 - !ruby/object:Gem::Dependency
   name: ruby-terminfo
   requirement: !ruby/object:Gem::Requirement
@@ -129,11 +143,9 @@ files:
 - README.md
 - Rakefile
 - block-flow.rb
-- lib/ansi_string.rb
 - lib/tasks/gem.rake
 - lib/terminal_layout.rb
 - lib/terminal_layout/version.rb
-- spec/ansi_string_spec.rb
 - spec/spec_helper.rb
 - spec/terminal_layout_spec.rb
 - terminal-layout.gemspec
@@ -163,7 +175,6 @@ signing_key:
 specification_version: 4
 summary: A terminal layout manager
 test_files:
-- spec/ansi_string_spec.rb
 - spec/spec_helper.rb
 - spec/terminal_layout_spec.rb
 has_rdoc: 

data/lib/ansi_string.rb

@@ -1,371 +0,0 @@
-# encoding: UTF-8
-
-require 'forwardable'
-
-class ANSIString
-  extend Forwardable
-  attr_reader :raw, :without_ansi
-
-  def_delegators :@without_ansi, :each_char, :each_byte, :index,
-    :match, :=~
-
-  def initialize(str)
-    process_string raw_string_for(str)
-  end
-
-  def +(other)
-    self.class.new @raw + raw_string_for(other)
-  end
-
-  def <<(other)
-    range = length..length
-    str = replace_in_string(range, other)
-    process_string raw_string_for(str)
-    self
-  end
-
-  def insert(position, string)
-    if position < 0
-      position = @without_ansi.length + position + 1
-    end
-    self[position...position] = string
-    self
-  end
-
-  def empty?
-    length == 0
-  end
-
-  def [](range)
-    # convert numeric position to a range
-    range = (range..range) if range.is_a?(Integer)
-
-    range_begin = range.begin
-    range_end = range.end
-
-    if range.exclude_end?
-      if range_begin == 0 && range_end == 0
-        return ""
-      else
-        range_end -= 1
-      end
-    end
-
-    range_begin = @without_ansi.length - range.begin.abs if range.begin < 0
-    range_end = @without_ansi.length - range.end.abs if range.end < 0
-
-    str = build_string_with_ansi_for(range_begin..range_end)
-    ANSIString.new str if str
-  end
-
-  def []=(range, replacement_str)
-    # convert numeric position to a range
-    range = (range..range) if range.is_a?(Integer)
-
-    range_begin = range.begin
-    range_end = range.exclude_end? ? range.end - 1 : range.end
-
-    range_begin = @without_ansi.length - range.begin.abs if range.begin < 0
-    range_end = @without_ansi.length - range.end.abs if range.end < 0
-
-    updated_string = replace_in_string(range_begin..range_end, replacement_str)
-    process_string raw_string_for(updated_string)
-    self
-  end
-
-  # See String#rindex for arguments
-  def rindex(*args)
-    @without_ansi.rindex(*args)
-  end
-
-  def replace(str)
-    process_string raw_string_for(str)
-    self
-  end
-
-  def reverse
-    str = @ansi_sequence_locations.reverse.map do |location|
-      [location[:start_ansi_sequence], location[:text].reverse, location[:end_ansi_sequence]].join
-    end.join
-    ANSIString.new str
-  end
-
-  def scan(pattern)
-    results = []
-    without_ansi.enum_for(:scan, pattern).each do
-      md = Regexp.last_match
-      if md.captures.any?
-        results << md.captures.map.with_index do |_, i|
-          # captures use 1-based indexing
-          self[md.begin(i+1)..md.end(i+1)-1]
-        end
-      else
-        results << self[md.begin(0)..md.end(0)-1]
-      end
-    end
-    results
-  end
-
-  def slice(index, length=nil)
-    return ANSIString.new("") if length == 0
-    range = nil
-    index = index.without_ansi if index.is_a?(ANSIString)
-    index = Regexp.new Regexp.escape(index) if index.is_a?(String)
-    if index.is_a?(Integer)
-      length ||= 1
-      range = (index..index+length-1)
-    elsif index.is_a?(Range)
-      range = index
-    elsif index.is_a?(Regexp)
-      md = @without_ansi.match(index)
-      capture_group_index = length || 0
-      if md
-        capture_group = md.offset(capture_group_index)
-        range = (capture_group.first..capture_group.last-1)
-      end
-    else
-      raise(ArgumentError, "Must pass in at least an index or a range.")
-    end
-    self[range] if range
-  end
-
-  def split(*args)
-    raw.split(*args).map { |s| ANSIString.new(s) }
-  end
-
-  def strip
-    ANSIString.new raw.strip
-  end
-
-  def length
-    @without_ansi.length
-  end
-
-  def lines
-    result = []
-    current_string = ""
-    @ansi_sequence_locations.map do |location|
-      if location[:text] == "\n"
-        result << ANSIString.new(current_string + "\n")
-        current_string = ""
-        next
-      end
-
-      location[:text].scan(/.*(?:\n|$)/).each_with_index do |line, i|
-        break if line == ""
-
-        if i == 0
-          current_string << [
-            location[:start_ansi_sequence],
-            line,
-            location[:end_ansi_sequence]
-          ].join
-        else
-          result << ANSIString.new(current_string)
-          current_string = ""
-          current_string << [
-            location[:start_ansi_sequence],
-            line,
-            location[:end_ansi_sequence]
-          ].join
-        end
-      end
-
-      if location[:text].end_with?("\n")
-        result << ANSIString.new(current_string)
-        current_string = ""
-        next
-      end
-    end
-    result << ANSIString.new(current_string) if current_string.length > 0
-    result
-  end
-
-  def dup
-    ANSIString.new(@raw.dup)
-  end
-
-  def sub(pattern, replacement)
-    str = ""
-    count = 0
-    max_count = 1
-    index = 0
-    @without_ansi.enum_for(:scan, pattern).each do
-      md = Regexp.last_match
-      str << build_string_with_ansi_for(index...(index + md.begin(0)))
-      index = md.end(0)
-      break if (count += 1) == max_count
-    end
-    if index != @without_ansi.length
-      str << build_string_with_ansi_for(index..@without_ansi.length)
-    end
-    nstr = str.gsub /(\033\[[0-9;]*m)(.+?)\033\[0m\1/, '\1\2'
-    ANSIString.new(nstr)
-  end
-
-  def to_s
-    @raw.dup
-  end
-  alias :to_str :to_s
-
-  def inspect
-    to_s.inspect
-  end
-
-  def ==(other)
-    (other.class == self.class && other.raw == @raw) || (other.kind_of?(String) && other == @raw)
-  end
-
-  def <=>(other)
-    (other.class == self.class && @raw <=> other.raw)
-  end
-
-  private
-
-  def raw_string_for(str)
-    str.is_a?(ANSIString) ? str.raw : str.to_s
-  end
-
-  def process_string(raw_str)
-    @without_ansi = ""
-    @ansi_sequence_locations = []
-    raw_str.enum_for(:scan, /(\e\[[0-9;]*m)?(.*?)(?=\e\[[0-9;]*m|\Z)/m ).each do
-      md = Regexp.last_match
-      ansi_sequence, text = md.captures
-
-      previous_sequence_location = @ansi_sequence_locations.last
-      if previous_sequence_location
-        if ansi_sequence == "\e[0m"
-          previous_sequence_location[:end_ansi_sequence] = ansi_sequence
-          ansi_sequence = nil
-        elsif previous_sequence_location[:start_ansi_sequence] == ansi_sequence
-          previous_sequence_location[:text] << text
-          previous_sequence_location[:ends_at] += text.length
-          previous_sequence_location[:length] += text.length
-          @without_ansi << text
-          next
-        end
-      end
-
-      if ansi_sequence.nil? && text.to_s.length == 0
-        next
-      end
-
-      @ansi_sequence_locations.push(
-        begins_at: @without_ansi.length,
-        ends_at: [@without_ansi.length + text.length - 1, 0].max,
-        length: text.length,
-        text: text,
-        start_ansi_sequence: ansi_sequence
-      )
-
-      @without_ansi << text
-    end
-
-    @raw = @ansi_sequence_locations.map do |location|
-      [location[:start_ansi_sequence], location[:text], location[:end_ansi_sequence]].compact.join
-    end.join
-
-    @ansi_sequence_locations
-  end
-
-  def replace_in_string(range, replacement_str)
-    raise RangeError, "#{range.inspect} out of range" if range.begin > length
-    return replacement_str if @ansi_sequence_locations.empty?
-
-    range = range.begin..(range.end - 1) if range.exclude_end?
-    str = ""
-    @ansi_sequence_locations.each_with_index do |location, j|
-      # If the given range encompasses part of the location, then we want to
-      # include the whole location
-      if location[:begins_at] >= range.begin && location[:ends_at] <= range.end
-        end_index = range.end - location[:begins_at] + 1
-
-        str << [
-          location[:start_ansi_sequence],
-          replacement_str,
-          location[:text][end_index..-1],
-          location[:end_ansi_sequence]
-        ].join
-
-      # If the location falls within the given range then  make sure we pull
-      # out the bits that we want, and keep ANSI escape sequenece intact while
-      # doing so.
-      elsif location[:begins_at] <= range.begin && location[:ends_at] >= range.end
-        start_index = range.begin - location[:begins_at]
-        end_index = range.end - location[:begins_at] + 1
-
-        str << [
-          location[:start_ansi_sequence],
-          location[:text][0...start_index],
-          replacement_str,
-          location[:text][end_index..-1],
-          location[:end_ansi_sequence]
-        ].join
-
-      elsif location[:ends_at] == range.begin
-        start_index = range.begin - location[:begins_at]
-        end_index = range.end
-        num_chars_to_remove_from_next_location = range.end - location[:ends_at]
-
-        str << [
-          location[:start_ansi_sequence],
-          location[:text][location[:begins_at]...(location[:begins_at]+start_index)],
-          replacement_str,
-          location[:text][end_index..-1],
-          location[:end_ansi_sequence],
-        ].join
-
-        if location=@ansi_sequence_locations[j+1]
-          old = location.dup
-          location[:text][0...num_chars_to_remove_from_next_location] = ""
-          location[:begins_at] += num_chars_to_remove_from_next_location
-          location[:ends_at] += num_chars_to_remove_from_next_location
-        end
-
-      # If we're pushing onto the end of the string
-      elsif range.begin == length && location[:ends_at] == length - 1
-        if replacement_str.is_a?(ANSIString)
-          str << [location[:start_ansi_sequence], location[:text], location[:end_ansi_sequence], replacement_str].join
-        else
-          str << [location[:start_ansi_sequence], location[:text], replacement_str, location[:end_ansi_sequence]].join
-        end
-      else
-        str << [location[:start_ansi_sequence], location[:text], location[:end_ansi_sequence]].join
-      end
-    end
-
-    str
-  end
-
-  def build_string_with_ansi_for(range)
-    return nil if range.begin > length
-
-    str = ""
-
-    if range.exclude_end?
-      range = range.begin..(range.end - 1)
-    end
-
-    @ansi_sequence_locations.each do |location|
-      # If the given range encompasses part of the location, then we want to
-      # include the whole location
-      if location[:begins_at] >= range.begin && location[:ends_at] <= range.end
-        str << [location[:start_ansi_sequence], location[:text], location[:end_ansi_sequence]].join
-
-      elsif location[:begins_at] >= range.begin && location[:begins_at] <= range.end
-        str << [location[:start_ansi_sequence], location[:text][0..(range.end - location[:begins_at])], location[:end_ansi_sequence]].join
-
-      # If the location falls within the given range then  make sure we pull
-      # out the bits that we want, and keep ANSI escape sequenece intact while
-      # doing so.
-      elsif (location[:begins_at] <= range.begin && location[:ends_at] >= range.end) || range.cover?(location[:ends_at])
-        start_index = range.begin - location[:begins_at]
-        end_index = range.end - location[:begins_at]
-        str << [location[:start_ansi_sequence], location[:text][start_index..end_index], location[:end_ansi_sequence]].join
-      end
-    end
-    str
-  end
-
-end

data/spec/ansi_string_spec.rb

@@ -1,701 +0,0 @@
-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
-
-    it "can be constructed with UTF-8 characters" do;
-      expect do
-        ansi_string = ANSIString.new "this #{blue('ƒ')} a string"
-        expect(ansi_string).to be
-      end.to_not raise_error
-    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 "#each_byte" do
-    let(:blue_ansi_string){ ANSIString.new blue_string }
-    let(:blue_string){ blue("this is blue") }
-
-    it "iterates over each character ignoring ANSI sequences" do
-      expected = "this is blue"
-      actual = ""
-      blue_ansi_string.each_byte { |ch| actual << ch }
-      expect(actual).to eq(expected)
-    end
-  end
-
-  describe "#each_char" do
-    let(:blue_ansi_string){ ANSIString.new blue_string }
-    let(:blue_string){ blue("this is blue") }
-
-    it "iterates over each character ignoring ANSI sequences" do
-      expected = "this is blue"
-      actual = ""
-      blue_ansi_string.each_char { |ch| actual << ch }
-      expect(actual).to eq(expected)
-    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 "#insert (see Ruby's String#insert for intent)" do
-    it "insert a string into the ANSIString" do
-      ansi_string = ANSIString.new "az"
-      ansi_string.insert 1, "thru"
-      expect(ansi_string).to eq ANSIString.new("athruz")
-
-      ansi_string.insert 0, "_"
-      expect(ansi_string).to eq ANSIString.new("_athruz")
-
-      ansi_string.insert ansi_string.length, "_"
-      expect(ansi_string).to eq ANSIString.new("_athruz_")
-    end
-
-    it "insert an ANSIString into an ANSIString" do
-      ansi_string = ANSIString.new blue("az")
-      ansi_string.insert 1, yellow("thru")
-      expect(ansi_string).to eq ANSIString.new("\e[34ma\e[33mthru\e[0mz\e[0m")
-    end
-
-    it "inserts from the end with a negative position" do
-      ansi_string = ANSIString.new blue("az")
-      ansi_string.insert -2, yellow("thru")
-      expect(ansi_string).to eq ANSIString.new("\e[34ma\e[33mthru\e[0mz\e[0m")
-    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 "#empty?" do
-    it "returns true when empty" do
-      expect(ANSIString.new("").empty?).to be(true)
-    end
-
-    it "returns true when it only contains ANSI sequences" do
-      expect(ANSIString.new(blue("")).empty?).to be(true)
-    end
-
-    it "returns false when there are non-ANSI characters" do
-      expect(ANSIString.new("a").empty?).to be(false)
-      expect(ANSIString.new(blue("a")).empty?).to be(false)
-    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 the correct substring when location of an ANSI sequence comes before the end of the request" do
-      s = ANSIString.new("ABC \e[7mGemfile.lock\e[0m LICENSE.txt  README.md")
-      expect(s[4...28]).to eq ANSIString.new("\e[7mGemfile.lock\e[0m LICENSE.txt")
-    end
-
-    it "returns text that is not ANSI escaped" do
-      expect(ansi_string[12..14]).to eq "ABC"
-    end
-
-    it "returns dos thine" do
-      ansi_string = ANSIString.new("ABC")
-      expect(ansi_string[0...1]).to eq "A"
-    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 "supports replacing with negative indexes at the front of the string" do
-      ansi_string[0..-1] = "abc"
-      expect(ansi_string).to eq ANSIString.new(blue("abc"))
-    end
-
-    it "supports replacing with negative indexes in the middle of the string" do
-      ansi_string = ANSIString.new(blue("abc"))
-      ansi_string[1..-2] = red("*")
-
-      # Do not preserve reset sequences (e.g. "\e[0m") when inserting/replacing.
-      # So no \e[0m before the replacement '*'
-      expect(ansi_string).to eq ANSIString.new("\e[34ma\e[31m*\e[0mc\e[0m")
-    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 "moves the boundaries when using positive indexes and a regular String replacement" do
-        ansi_string[3..4] = yellow("SORRY")
-        expect(ansi_string).to eq ANSIString.new("thi#{yellow('SORRY')}#{blue('hat')}")
-      end
-
-      it "moves the boundaries when using positive indexes and an ANSIString replacement" do
-        ansi_string[3..4] = yellow("SORRY")
-        expect(ansi_string).to eq ANSIString.new("thi#{yellow('SORRY')}#{blue('hat')}")
-      end
-
-      it "moves the boundaries when using negatives indexes and a regular String replacement" do
-        ansi_string[-5..4] = "SORRY"
-        expect(ansi_string).to eq ANSIString.new("thiSORRY#{blue('hat')}")
-      end
-
-      it "moves the boundaries when using negatives indexes and an ANSIString replacement" do
-        ansi_string[-5..4] = yellow("SORRY")
-        expect(ansi_string).to eq ANSIString.new("thi#{yellow('SORRY')}#{blue('hat')}")
-      end
-    end
-
-    context "clearing the string" do
-      subject(:ansi_string){ ANSIString.new "this\nthat" }
-
-      it "clears the string" do
-        ansi_string[0..-1] = ""
-        expect(ansi_string).to eq ANSIString.new("")
-      end
-    end
-
-    context "expanding a string" do
-      subject(:ansi_string){ ANSIString.new "" }
-
-      it "expands the string" do
-        ansi_string[0..-1] = ANSIString.new(blue("HI"))
-        expect(ansi_string).to eq ANSIString.new(blue("HI"))
-      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 "<=>" do
-    let(:string_1){ ANSIString.new blue("abc") }
-    let(:string_2){ ANSIString.new blue("def") }
-
-    it "behaves the same as a normal string" do
-      expect(string_1 <=> string_2).to eq(-1)
-      expect(string_1 <=> string_1).to eq(0)
-      expect(string_2 <=> string_1).to eq(1)
-    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 "#=~" do
-    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 =~ /are/).to eq(string =~ /are/)
-    end
-  end
-
-  describe "#scan" do
-    it "scans without capture groups" do
-      string = "567"
-      ansi_string = ANSIString.new("1234#{red('5678')}90")
-      expect(ansi_string.scan(/.{2}/)).to eq([
-        ANSIString.new("12"),
-        ANSIString.new("34"),
-        ANSIString.new("#{red('56')}"),
-        ANSIString.new("#{red('78')}"),
-        ANSIString.new("90")
-      ])
-    end
-
-    it "scans with capture groups" do
-      string = "567"
-      ansi_string = ANSIString.new("1234#{red('5678')}90")
-      expect(ansi_string.scan(/(.)./)).to eq([
-        [ANSIString.new("1")],
-        [ANSIString.new("3")],
-        [ANSIString.new("#{red('5')}")],
-        [ANSIString.new("#{red('7')}")],
-        [ANSIString.new("9")]
-      ])
-    end
-  end
-
-  describe "#replace" do
-    it "replaces the contents of the current string with the new string" do
-      ansi_string = ANSIString.new("abc")
-      original_object_id = ansi_string.object_id
-      expect(ansi_string.replace("def")).to eq ANSIString.new("def")
-      expect(ansi_string.object_id).to eq(original_object_id)
-    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, 0)).to eq ANSIString.new("")
-      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 "#strip" do
-    it 'returns a copy of the string with leading and trailing whitespace removed' do
-      ansi_string = ANSIString.new " this is his #{blue('pig')} "
-      expect(ansi_string.strip).to eq ANSIString.new "this is his #{blue('pig')}"
-      expect(ansi_string).to eq ANSIString.new " this is his #{blue('pig')} "
-    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 "#inspect" do
-    subject(:ansi_string){ ANSIString.new blue(string) }
-    let(:string){ "this is blue" }
-
-    it "returns a quoted version of the strong" do
-      expect(ansi_string.inspect).to eq "\"\\e[34mthis is blue\\e[0m\""
-    end
-  end
-
-  describe "#succ" do
-    it "needs to be implemented"
-  end
-end