rak 1.0 → 1.2

data/lib/rak.rb

@@ -1,4 +1,4 @@
 
 class Rak
-  VERSION = "1.0"
+  VERSION = "1.2"
 end

data/spec/help_spec.rb

@@ -1,50 +1,56 @@
+require "spec_helper"
 
-
-require File.dirname(__FILE__) + "/spec_helpers"
+def extract_options_from_help_message(msg)
+  msg.scan(/\B--?(?:\[no\]|no)?([a-zA-Z0-9\-]+)/).flatten.sort.uniq
+end
 
 describe "Rak", "help and errors" do
-  before(:all) do
-    ENV['RAK_TEST'] = "true"
-  end
-  after(:all) do
-    ENV['RAK_TEST'] = "false"
-  end
-  
   it "--version prints version information" do
-    strip_ansi(%x{rak --version}).should == t=<<END
-rak 0.9
+    rak("--version").should == <<-END
+      rak #{Rak::VERSION}
 
-Copyright 2008 Daniel Lucraft, all rights reserved. 
-Based on the perl tool 'ack' by Andy Lester.
+      Copyright 2008-#{Time.now.year} Daniel Lucraft, all rights reserved. 
+      Based on the perl tool 'ack' by Andy Lester.
 
-This program is free software; you can redistribute it and/or modify it
-under the same terms as Ruby.
-END
+      This program is free software; you can redistribute it and/or modify it
+      under the same terms as Ruby.
+    END
   end
   
   it "prints unknown type errors" do
-    %x{rak Virg --type=pyth}.should == t=<<END
-rak: Unknown --type "pyth"
-rak: See rak --help types
-END
+    rak("Virg --type=pyth").should == <<-END
+      rak: Unknown --type "pyth"
+      rak: See rak --help types
+    END
   end
   
   it "--help prints help information" do
-    %x{rak Virg --help}.split("\n")[0].should == "Usage: rak [OPTION]... PATTERN [FILES]"
+    rak("Virg --help").lines[0].should == <<-END
+      Usage: rak [OPTION]... PATTERN [FILES]
+    END
   end
   
   it "--help types prints type information" do
-    %x{rak --help types}.split("\n")[2].should == "The following is the list of filetypes supported by rak.  You can"
+    rak("--help types").lines[2].should == <<-END
+      The following is the list of filetypes supported by rak.  You can
+    END
   end
   
   it "no options or patterns prints the usage info" do
-    %x{rak}.split("\n")[0].should == "Usage: rak [OPTION]... PATTERN [FILES]"
+    rak.lines[0].should == <<-END
+      Usage: rak [OPTION]... PATTERN [FILES]
+    END
   end
 
   it "prints a nice message for unknown options" do
-    t=<<END
-rak: see rak --help for usage.
-END
-    %x{rak foo --asfdasfd}.include?(t).should be_true
+    rak("foo --asfdasfd 2>/dev/null").should include <<-END
+      rak: see rak --help for usage.
+    END
+  end
+
+  it "should mention every option it supports in help" do
+    expected = extract_options_from_help_message(File.readlines(bin_rak).grep(/GetoptLong/).join) - ['color']
+    actual   = extract_options_from_help_message(rak()) - ['ruby']
+    actual.should == expected
   end
 end

data/spec/rak_spec.rb

@@ -1,536 +1,608 @@
 
-require 'fileutils'
-
-require File.dirname(__FILE__) + "/spec_helpers"
+require "spec_helper"
 
 describe "Rak", "with no options" do 
-  before(:all) do
-    ENV['RAK_TEST'] = "true"
-  end
-  before(:each)do
-    FileUtils.cd(HERE+"/example/")
-  end
-  after(:all) do
-    ENV['RAK_TEST'] = "false"
-  end
   it "prints all matches from files in the current directory" do
-    asterize_ansi(%x{rak Cap.ic}).should == t=<<END
-*foo.rb*
-   3|foo foo foo *Capric*a foo foo foo
-   4|foo *Capsic*um foo foo foo foo foo
-
-END
+    rak("Cap.ic").should == <<-END
+      *foo.rb*
+         3|foo foo foo *Capric*a foo foo foo
+         4|foo *Capsic*um foo foo foo foo foo
+    END
   end
   
   it "prints all matches correctly" do
-    strip_ansi(%x{rak foo}).should == t=<<END
-foo.rb
-   3|foo foo foo Caprica foo foo foo
-   4|foo Capsicum foo foo foo foo foo
-   6|foo foo foo foo foo Pikon foo foo
-   8|foo Pikon foo foo foo foo foo foo
-  10|foo foo Six foo foo foo Six foo
-  11|foo foo foo foo Six foo foo foo
-  13|foo foo foo Gemenon foo foo foo
-
-END
+    rak("foo", :ansi => '').should == <<-END
+      foo.rb
+         3|foo foo foo Caprica foo foo foo
+         4|foo Capsicum foo foo foo foo foo
+         6|foo foo foo foo foo Pikon foo foo
+         8|foo Pikon foo foo foo foo foo foo
+        10|foo foo Six foo foo foo Six foo
+        11|foo foo foo foo Six foo foo foo
+        13|foo foo foo Gemenon foo foo foo
+    END
   end
 
   it "prints all matches from files in subdirectories" do
-    asterize_ansi(%x{rak  Pikon}).should == t=<<END
-*dir1/bar.rb*
-   2|bar bar bar bar *Pikon* bar
-   9|bar bar *Pikon* bar bar bar
+    rak("Pikon").should == <<-END
+      *dir1/bar.rb*
+         2|bar bar bar bar *Pikon* bar
+         9|bar bar *Pikon* bar bar bar
 
-*foo.rb*
-   6|foo foo foo foo foo *Pikon* foo foo
-   8|foo *Pikon* foo foo foo foo foo foo
-
-END
+      *foo.rb*
+         6|foo foo foo foo foo *Pikon* foo foo
+         8|foo *Pikon* foo foo foo foo foo foo
+    END
   end
   
   it "prints multiple matches in a line" do
-    asterize_ansi(%x{rak Six}).should == t=<<END
-*foo.rb*
-  10|foo foo *Six* foo foo foo *Six* foo
-  11|foo foo foo foo *Six* foo foo foo
-
-END
+    rak("Six").should == <<-END
+      *foo.rb*
+        10|foo foo *Six* foo foo foo *Six* foo
+        11|foo foo foo foo *Six* foo foo foo
+    END
   end
   
   it "skips VC dirs" do
-    %x{rak Aerelon}.should == ""
+    rak("Aerelon").should == ""
   end
   
   it "does not follow symlinks" do
-    %x{rak Sagitarron}.should == ""
+    rak("Sagitarron").should == ""
   end
   
   it "changes defaults when redirected" do
-    ENV['RAK_TEST'] = "false"
-    asterize_ansi(%x{rak Six | cat}).should == t=<<END
-foo.rb   10|foo foo Six foo foo foo Six foo
-foo.rb   11|foo foo foo foo Six foo foo foo
-END
-    ENV['RAK_TEST'] = "true"
+    rak("Six | cat", :test_mode => false).should == <<-END
+      foo.rb:10:foo foo Six foo foo foo Six foo
+      foo.rb:11:foo foo foo foo Six foo foo foo
+    END
   end
 
   it "searches shebangs for valid inputs" do
-    asterize_ansi(%x{rak Aquaria}).should == t=<<END
-*shebang*
-   3|goo goo goo *Aquaria* goo goo
-
-END
+    rak("Aquaria").should == <<-END
+      *shebang*
+         3|goo goo goo *Aquaria* goo goo
+    END
   end
   
   it "recognizes Makefiles and Rakefiles" do
-    asterize_ansi(%x{rak Canceron}).should == t=<<END
-*Rakefile*
-   1|rakefile rakefile *Canceron* rakefile
-
-END
+    rak("Canceron").should == <<-END
+      *Rakefile*
+         1|rakefile rakefile *Canceron* rakefile
+    END
   end
 end
 
 describe "Rak", "with FILE or STDIN inputs" do
-  before(:all) do
-    ENV['RAK_TEST'] = "true"
-  end
-  after(:all) do
-    ENV['RAK_TEST'] = "false"
-  end
   it "should only search in given files or directories" do
-    asterize_ansi(%x{rak Pikon foo.rb}).should == t=<<END
-   6|foo foo foo foo foo *Pikon* foo foo
-   8|foo *Pikon* foo foo foo foo foo foo
-END
-    strip_ansi(%x{rak Pikon dir1/}).should == t=<<END
-dir1/bar.rb
-   2|bar bar bar bar Pikon bar
-   9|bar bar Pikon bar bar bar
-
-END
+    rak("Pikon foo.rb").should == <<-END
+         6|foo foo foo foo foo *Pikon* foo foo
+         8|foo *Pikon* foo foo foo foo foo foo
+    END
+    rak("Pikon dir1/", :ansi => '').should == <<-END
+      dir1/bar.rb
+         2|bar bar bar bar Pikon bar
+         9|bar bar Pikon bar bar bar
+    END
   end
   
   it "should search in STDIN by default if no files are specified" do
-    asterize_ansi(%x{cat _darcs/baz.rb | rak Aere}).should == t=<<END
-   2|baz baz baz *Aere*lon baz baz baz
-END
+    rak("Aere", :pipe => "cat _darcs/baz.rb").should == <<-END
+         2|baz baz baz *Aere*lon baz baz baz
+    END
   end
   
   it "only searches STDIN when piped to" do
-    asterize_ansi(%x{echo asdfCapasdf | rak Cap}).should == t=<<END
-   1|asdf*Cap*asdf
-END
+    rak("Cap", :pipe => "echo asdfCapasdf").should == <<-END
+         1|asdf*Cap*asdf
+    END
+  end
+
+  it "should either match on rax x or rak -v x" do
+    (rak('"\A.{0,100}\Z" dir1/bar.rb').length + rak('-v "\A.{0,100}\Z" dir1/bar.rb').length).should > 0
   end
 end
 
 describe "Rak", "options" do
-  before(:all) do
-    ENV['RAK_TEST'] = "true"
-  end
-  after(:all) do
-    ENV['RAK_TEST'] = "false"
-  end
   it "prints only files with --files" do
-    t=<<END
-Rakefile
-quux.py
-dir1/bar.rb
-foo.rb
-shebang
-END
-    sort_lines(%x{rak -f}).should == sort_lines(t)
+    t = <<-END
+      Rakefile
+      quux.py
+      dir1/bar.rb
+      foo.rb
+      shebang
+    END
+    rak("-f").lines.sort.should == t.lines.sort
   end
   
   it "prints a maximum number of matches if --max-count=x is specified" do
-    strip_ansi(%x{rak Cap.ic -m 1}).should == t=<<END
-foo.rb
-   3|foo foo foo Caprica foo foo foo
+    rak("Cap.ic -m 1").should == <<-END
+      *foo.rb*
+         3|foo foo foo *Capric*a foo foo foo
+    END
+  end
 
-END
+  it "prints context of all matches if -m and -C are both specified, without further highlighting" do
+    rak("Cap.ic -C2 -m 1").should == <<-END
+      *foo.rb*
+         1|
+         2|
+         3|foo foo foo *Capric*a foo foo foo
+         4|foo Capsicum foo foo foo foo foo
+         5|
+    END
   end
   
   it "prints the evaluated output for --output" do
-    strip_ansi(%x{rak Cap --output='$&'}).should == t=<<END
-Cap
-Cap
-END
+    rak("Cap --output='$&'", :ansi => '').should == <<-END
+      Cap
+      Cap
+    END
+  end
+
+  it "-v -c displays correct counts even with multiple matches per line" do
+    rak("-v -c bar").lines.sort.join.should == <<-END
+      Rakefile:1
+      dir1/bar.rb:7
+      foo.rb:13
+      quux.py:1
+      shebang:3
+    END
   end
   
   it "-c prints only the number of matches found per file" do
-    t=<<END
-dir1/bar.rb:2
-foo.rb:2
-END
-    sort_lines(strip_ansi(%x{rak Pik -c})).should == sort_lines(t)
+    rak("Pik -c").lines.sort.join.should  == <<-END
+      dir1/bar.rb:2
+      foo.rb:2
+    END
   end
   
   it "-h suppresses filename and line number printing" do
-    asterize_ansi(%x{rak Pik -h}).should == t=<<END
-bar bar bar bar *Pik*on bar
-bar bar *Pik*on bar bar bar
-foo foo foo foo foo *Pik*on foo foo
-foo *Pik*on foo foo foo foo foo foo
-END
+    rak("Pik -h").should == <<-END
+      bar bar bar bar *Pik*on bar
+      bar bar *Pik*on bar bar bar
+      foo foo foo foo foo *Pik*on foo foo
+      foo *Pik*on foo foo foo foo foo foo
+    END
   end
   
   it "ignores case with -i" do
-    strip_ansi(%x{rak six -i}).should == t=<<END
-foo.rb
-  10|foo foo Six foo foo foo Six foo
-  11|foo foo foo foo Six foo foo foo
-
-END
+    rak("six -i").should == <<-END
+      *foo.rb*
+        10|foo foo *Six* foo foo foo *Six* foo
+        11|foo foo foo foo *Six* foo foo foo
+    END
   end
   
   it "inverts the match with -v" do
-    t1=<<END
-quux.py
-   1|quux quux quux quux Virgon quux quux
-END
-    t12=<<END
-dir1/bar.rb
-   1|
-   2|bar bar bar bar Pikon bar
-   3| 
-   4|
-   5|
-   6|
-   7|
-   8|
-   9|bar bar Pikon bar bar bar
-END
-    t2=<<END
-foo.rb
-   1|
-   2|
-   5|
-   7|
-   9|
-  12|
-END
-    t3=<<END
-shebang
-   1|#!/usr/bin/env ruby
-   2|
-   3|goo goo goo Aquaria goo goo
-END
-    t4=<<END
-Rakefile
-   1|rakefile rakefile Canceron rakefile
-END
-    r = strip_ansi(%x{rak foo -v})
-    r.include?(t1).should be_true
-    r.include?(t12).should be_true
-    r.include?(t2).should be_true
-    r.include?(t3).should be_true
-    r.include?(t4).should be_true
-    r.split("\n").length.should == 26
+    t1 = <<-END
+      quux.py
+         1|quux quux quux quux Virgon quux quux
+    END
+    t12 = <<-END
+      dir1/bar.rb
+         1|
+         2|bar bar bar bar Pikon bar
+         3| 
+         4|
+         5|
+         6|
+         7|
+         8|
+         9|bar bar Pikon bar bar bar
+    END
+    t2 = <<-END
+      foo.rb
+         1|
+         2|
+         5|
+         7|
+         9|
+        12|
+    END
+    t3 = <<-END
+      shebang
+         1|#!/usr/bin/env ruby
+         2|
+         3|goo goo goo Aquaria goo goo
+    END
+    t4 = <<-END
+      Rakefile
+         1|rakefile rakefile Canceron rakefile
+    END
+    r = rak("foo -v", :ansi => '')
+    r.should include t1
+    r.should include t12
+    r.should include t2
+    r.should include t3
+    r.should include t4
+    r.lines.length.should == 29
   end
   
   it "doesn't descend into subdirs with -n" do
-    strip_ansi(%x{rak Pikon -n}).should == t=<<END
-foo.rb
-   6|foo foo foo foo foo Pikon foo foo
-   8|foo Pikon foo foo foo foo foo foo
-
-END
+    rak("Pikon -n", :ansi => '').should == <<-END
+      foo.rb
+         6|foo foo foo foo foo Pikon foo foo
+         8|foo Pikon foo foo foo foo foo foo
+    END
   end
   
   it "quotes meta-characters with -Q" do
-    strip_ansi(%x{rak Cap. -Q}).should == ""
+    rak("Cap. -Q").should == ""
   end
   
   it "prints only the matching portion with -o" do
-    strip_ansi(%x{rak Cap -o}).should == t=<<END
-Cap
-Cap
-END
+    rak("Cap -o", :ansi => '').should == <<-END
+      Cap
+      Cap
+    END
   end
   
   it "matches whole words only with -w" do
-    strip_ansi(%x{rak Cap -w}).should == ""
+    rak("'Cap|Hat' -w").should == ""
   end
   
    it "prints the file on each line with --nogroup" do
-    asterize_ansi(%x{rak Cap --nogroup}).should == t=<<END
-*foo.rb*    3|foo foo foo *Cap*rica foo foo foo
-*foo.rb*    4|foo *Cap*sicum foo foo foo foo foo
-END
+    rak("Cap --nogroup").should == <<-END
+      *foo.rb*:3:foo foo foo *Cap*rica foo foo foo
+      *foo.rb*:4:foo *Cap*sicum foo foo foo foo foo
+    END
   end
   
   it "-l means only print filenames with matches" do
-    asterize_ansi(%x{rak Caprica -l}).should == t=<<END
-foo.rb
-END
+    rak("Caprica -l").should == <<-END
+      foo.rb
+    END
   end
   
   it "-L means only print filenames without matches" do
-      t=<<END
-quux.py
-dir1/bar.rb
-shebang
-Rakefile
-END
-    sort_lines(asterize_ansi(%x{rak Caprica -L})).should == sort_lines(t)
+    t = <<-END
+      quux.py
+      dir1/bar.rb
+      shebang
+      Rakefile
+    END
+    rak("Caprica -L", :ansi => '').lines.sort.should == t.lines.sort
   end
   
   it "--passthru means print all lines whether matching or not" do
-     t1=<<END
-quux quux quux quux Virgon quux quux
-END
+     t1 = <<-END
+      quux quux quux quux Virgon quux quux
+    END
 
-    t2=<<END
-*foo.rb*
-   3|foo foo foo *Caprica* foo foo foo
-foo Capsicum foo foo foo foo foo
+    t2 = <<-END
+      *foo.rb*
+         3|foo foo foo *Caprica* foo foo foo
+      foo Capsicum foo foo foo foo foo
 
-foo foo foo foo foo Pikon foo foo
+      foo foo foo foo foo Pikon foo foo
 
-foo Pikon foo foo foo foo foo foo
+      foo Pikon foo foo foo foo foo foo
 
-foo foo Six foo foo foo Six foo
-foo foo foo foo Six foo foo foo
+      foo foo Six foo foo foo Six foo
+      foo foo foo foo Six foo foo foo
 
-foo foo foo Gemenon foo foo foo
-END
-    t3=<<END
-#!/usr/bin/env ruby
+      foo foo foo Gemenon foo foo foo
+    END
+    t3 = <<-END
+      #!/usr/bin/env ruby
 
-goo goo goo Aquaria goo goo
-END
-    r = asterize_ansi(%x{rak Caprica --passthru -n})
-    r.include?(t1).should be_true
-    r.include?(t2).should be_true
-    r.include?(t3).should be_true
-    r.split("\n").length.should < (t1+t2+t3).split("\n").length+5
+      goo goo goo Aquaria goo goo
+    END
+    r = rak("Caprica --passthru -n")
+    r.should include t1
+    r.should include t2
+    r.should include t3
+    r.lines.length.should < (t1+t2+t3).lines.length+5
   end
   
   it "--nocolour means do not colourize the output" do
-    asterize_ansi(%x{rak Cap --nocolour}).should == t=<<END
-foo.rb
-   3|foo foo foo Caprica foo foo foo
-   4|foo Capsicum foo foo foo foo foo
-
-END
+    rak("Cap --nocolour").should == <<-END
+      foo.rb
+         3|foo foo foo Caprica foo foo foo
+         4|foo Capsicum foo foo foo foo foo
+    END
   end
   
   it "-a means to search every file" do
-    asterize_ansi(%x{rak Libris -a}).should == t=<<END
-*qux*
-   1|qux qux qux *Libris* qux qux qux
-
-END
-    
+    rak("Libris -a").should == <<-END
+      *qux*
+         1|qux qux qux *Libris* qux qux qux
+    END
   end
   
   it "--ruby means only ruby files" do
-    asterize_ansi(%x{rak Virgon --ruby}).should == ""
+    rak("Virgon --ruby").should == ""
   end
   
   it "--python means only python files" do
-    asterize_ansi(%x{rak Cap --python}).should == ""
+    rak("Cap --python").should == ""
   end
   
   it "--noruby means exclude ruby files" do
-    asterize_ansi(%x{rak Cap --noruby}).should == ""
+    rak("Cap --noruby").should == ""
   end
   
   it "--type=ruby means only ruby files" do
-    asterize_ansi(%x{rak Virgon --type=ruby}).should == ""
+    rak("Virgon --type=ruby").should == ""
   end
   
   it "--type=python means only python files" do
-    asterize_ansi(%x{rak Cap --type=python}).should == ""
+    rak("Cap --type=python").should == ""
   end
   
   it "--type=noruby means exclude ruby files" do
-    asterize_ansi(%x{rak Cap --type=noruby}).should == ""
+    rak("Cap --type=noruby").should == ""
   end
   
   it "--sort-files" do
-    %x{rak -f --sort-files}.should == t=<<END
-dir1/bar.rb
-foo.rb
-quux.py
-Rakefile
-shebang
-END
+    rak("-f --sort-files").should == <<-END
+      dir1/bar.rb
+      foo.rb
+      quux.py
+      Rakefile
+      shebang
+    END
   end
   
   it "--follow means follow symlinks" do 
-    strip_ansi(%x{rak Sagitarron --follow}).should == t=<<END
-corge.rb
-   1|corge corge corge Sagitarron corge
-
-ln_dir/corge.rb
-   1|corge corge corge Sagitarron corge
+    rak("Sagitarron --follow", :ansi => '').should == <<-END
+      corge.rb
+         1|corge corge corge Sagitarron corge
 
-END
+      ln_dir/corge.rb
+         1|corge corge corge Sagitarron corge
+    END
   end
   
   it "-A NUM means show NUM lines after" do 
-    strip_ansi(%x{rak Caps -A 2}).should == t=<<END
-foo.rb
-   4|foo Capsicum foo foo foo foo foo
-   5|
-   6|foo foo foo foo foo Pikon foo foo
-
-END
+    rak("Caps -A 2", :ansi => '').should == <<-END
+      foo.rb
+         4|foo Capsicum foo foo foo foo foo
+         5|
+         6|foo foo foo foo foo Pikon foo foo
+    END
   end
   
   it "-A should work when there are matches close together" do 
-    strip_ansi(%x{rak foo -A 2}).should == t=<<END
-foo.rb
-   3|foo foo foo Caprica foo foo foo
-   4|foo Capsicum foo foo foo foo foo
-   5|
-   6|foo foo foo foo foo Pikon foo foo
-   7|
-   8|foo Pikon foo foo foo foo foo foo
-   9|
-  10|foo foo Six foo foo foo Six foo
-  11|foo foo foo foo Six foo foo foo
-  12|
-  13|foo foo foo Gemenon foo foo foo
-
-END
+    rak("foo -A 2", :ansi => '').should == <<-END
+      foo.rb
+         3|foo foo foo Caprica foo foo foo
+         4|foo Capsicum foo foo foo foo foo
+         5|
+         6|foo foo foo foo foo Pikon foo foo
+         7|
+         8|foo Pikon foo foo foo foo foo foo
+         9|
+        10|foo foo Six foo foo foo Six foo
+        11|foo foo foo foo Six foo foo foo
+        12|
+        13|foo foo foo Gemenon foo foo foo
+    END
   end
   
   it "-B NUM means show NUM lines before" do 
-    strip_ansi(%x{rak Caps -B 2}).should == t=<<END
-foo.rb
-   2|
-   3|foo foo foo Caprica foo foo foo
-   4|foo Capsicum foo foo foo foo foo
-
-END
+    rak("Caps -B 2", :ansi => '').should == <<-END
+      foo.rb
+         2|
+         3|foo foo foo Caprica foo foo foo
+         4|foo Capsicum foo foo foo foo foo
+    END
   end
   
   it "-C means show 2 lines before and after" do 
-    strip_ansi(%x{rak Caps -C}).should == t=<<END
-foo.rb
-   2|
-   3|foo foo foo Caprica foo foo foo
-   4|foo Capsicum foo foo foo foo foo
-   5|
-   6|foo foo foo foo foo Pikon foo foo
-
-END
+    rak("Caps -C", :ansi => '').should == <<-END
+      foo.rb
+         2|
+         3|foo foo foo Caprica foo foo foo
+         4|foo Capsicum foo foo foo foo foo
+         5|
+         6|foo foo foo foo foo Pikon foo foo
+    END
   end
   
   it "-C 1 means show 1 lines before and after" do 
-    strip_ansi(%x{rak Caps -C 1}).should == t=<<END
-foo.rb
-   3|foo foo foo Caprica foo foo foo
-   4|foo Capsicum foo foo foo foo foo
-   5|
-
-END
+    rak("Caps -C 1", :ansi => '').should == <<-END
+      foo.rb
+         3|foo foo foo Caprica foo foo foo
+         4|foo Capsicum foo foo foo foo foo
+         5|
+    END
   end
   
   it "-C works correctly for nearby results" do
-    strip_ansi(%x{rak Pik -g foo -C}).should == t=<<END
-foo.rb
-   4|foo Capsicum foo foo foo foo foo
-   5|
-   6|foo foo foo foo foo Pikon foo foo
-   7|
-   8|foo Pikon foo foo foo foo foo foo
-   9|
-  10|foo foo Six foo foo foo Six foo
-
-END
+    rak("Pik -g foo -C", :ansi => '').should == <<-END
+      foo.rb
+         4|foo Capsicum foo foo foo foo foo
+         5|
+         6|foo foo foo foo foo Pikon foo foo
+         7|
+         8|foo Pikon foo foo foo foo foo foo
+         9|
+        10|foo foo Six foo foo foo Six foo
+    END
   end
 
   it "-g REGEX only searches in files matching REGEX" do
-    asterize_ansi(%x{rak Pikon -g f.o}).should == t=<<END
-*foo.rb*
-   6|foo foo foo foo foo *Pikon* foo foo
-   8|foo *Pikon* foo foo foo foo foo foo
-
-END
-
+    rak("Pikon -g f.o").should == <<-END
+      *foo.rb*
+         6|foo foo foo foo foo *Pikon* foo foo
+         8|foo *Pikon* foo foo foo foo foo foo
+    END
   end
 
   it "-k REGEX only searches in files not matching REGEX" do
-    asterize_ansi(%x{rak Pikon -k f.o}).should == t=<<END
-*dir1/bar.rb*
-   2|bar bar bar bar *Pikon* bar
-   9|bar bar *Pikon* bar bar bar
-
-END
+    rak("Pikon -k f.o").should == <<-END
+      *dir1/bar.rb*
+         2|bar bar bar bar *Pikon* bar
+         9|bar bar *Pikon* bar bar bar
+    END
   end
   
   it "-x means match only whole lines" do
-    asterize_ansi(%x{rak Cap -x}).should == ""
-    asterize_ansi(%x{rak "(foo )+Cap\\w+( foo)+" -x}).should == t=<<END
-*foo.rb*
-   3|*foo foo foo Caprica foo foo foo*
-   4|*foo Capsicum foo foo foo foo foo*
-
-END
+    rak("Cap -x").should == ""
+    rak('"foo|goo" -x').should == ""
+    rak('"(foo )+Cap\w+( foo)+" -x').should == <<-END
+      *foo.rb*
+         3|*foo foo foo Caprica foo foo foo*
+         4|*foo Capsicum foo foo foo foo foo*
+    END
   end
 
   it "-s means match only at the start of a line" do
-    asterize_ansi(%x{rak -s "foo Cap"}).should == t=<<END
-*foo.rb*
-   4|*foo Cap*sicum foo foo foo foo foo
-
-END
+    rak('-s "foo Cap|Aquaria"').should == <<-END
+      *foo.rb*
+         4|*foo Cap*sicum foo foo foo foo foo
+    END
   end
 
   it "-e means match only at the end of a line" do
-    asterize_ansi(%x{rak -e "kon foo foo"}).should == t=<<END
-*foo.rb*
-   6|foo foo foo foo foo Pi*kon foo foo*
-
-END
+    rak('-e "Aquaria|kon foo foo"').should == <<-END
+      *foo.rb*
+         6|foo foo foo foo foo Pi*kon foo foo*
+    END
   end
   
   it "should not recurse down '..' when used with . " do
-    FileUtils.cd(HERE+"/example/dir1/")
-    asterize_ansi(%x{rak foo .}).should == t=<<END
-END
+    rak("foo .", :dir=>HERE+"example/dir1").should == ""
   end
 end
 
 describe "Rak", "with combinations of options" do
-  before(:all) do
-    ENV['RAK_TEST'] = "true"
-  end
-  before(:each)do 
-    FileUtils.cd(HERE+"/example/")
-  end
-  after(:all) do
-    ENV['RAK_TEST'] = "false"
-  end
-  
   it "should process -c -v " do
-    t1=<<END
-quux.py:1
-dir1/bar.rb:7
-foo.rb:11
-shebang:3
-Rakefile:1
-END
-    sort_lines(strip_ansi(%x{rak Pikon -c -v})).should == sort_lines(t1)
+    t1=<<-END
+      quux.py:1
+      dir1/bar.rb:7
+      foo.rb:11
+      shebang:3
+      Rakefile:1
+    END
+    rak("Pikon -c -v", :ansi => '').lines.sort.should == t1.lines.sort
   end
 
   it "-h and redirection" do
-    ENV['RAK_TEST'] = "false"
-    %x{rak Pik -h | cat}.should == t=<<END
-bar bar bar bar Pikon bar
-bar bar Pikon bar bar bar
-foo foo foo foo foo Pikon foo foo
-foo Pikon foo foo foo foo foo foo
-END
-    ENV['RAK_TEST'] = "true"
+    rak("Pik -h | cat", :test_mode => false).should == <<-END
+      bar bar bar bar Pikon bar
+      bar bar Pikon bar bar bar
+      foo foo foo foo foo Pikon foo foo
+      foo Pikon foo foo foo foo foo foo
+    END
   end
 end
 
+describe "Rak", "with --eval" do 
+  it "should support next" do
+    rak(%Q[--eval 'next unless $. == $_.split.size']).should == <<-END
+      *foo.rb*
+         8|*foo Pikon foo foo foo foo foo foo*
+    END
+  end
+
+  it "should support break" do
+    rak(%Q[--eval 'break if $. == 2']).should == <<-END
+      *dir1/bar.rb*
+         1|*
+
+      *foo.rb*
+         1|*
+
+      *quux.py*
+         1|*quux quux quux quux Virgon quux quux*
+
+      *Rakefile*
+         1|*rakefile rakefile Canceron rakefile*
+
+      *shebang*
+         1|*#!/usr/bin/env ruby*
+    END
+  end
+
+  it "should support highlighting" do
+    rak(%Q[--eval 'next unless $_ =~ /Caprica/']).should == <<-END
+      *foo.rb*
+         3|foo foo foo *Caprica* foo foo foo
+    END
+  end
+
+  it "should support ranges" do
+    rak(%Q[--eval 'next unless $_[/Capsicum/]..$_[/Pikon/]']).should == <<-END
+      *foo.rb*
+         4|*foo Capsicum foo foo foo foo foo*
+         5|*
+         6|foo foo foo foo foo *Pikon* foo foo
+    END
+  end
+
+  it "should support next and contexts" do
+    rak(%Q[-C 2 --eval 'next unless $_ =~ /Pikon/']).should == <<-END
+      *dir1/bar.rb*
+         1|
+         2|bar bar bar bar *Pikon* bar
+         3| 
+         4|
+         7|
+         8|
+         9|bar bar *Pikon* bar bar bar
+
+      *foo.rb*
+         4|foo Capsicum foo foo foo foo foo
+         5|
+         6|foo foo foo foo foo *Pikon* foo foo
+         7|
+         8|foo *Pikon* foo foo foo foo foo foo
+         9|
+        10|foo foo Six foo foo foo Six foo
+    END
+  end
+
+  it "should support break and contexts (and matches past break should get no highlighting)" do
+    rak(%Q[-C 2 --eval 'next unless $_[/Pikon/]...(break; nil)']).should == <<-END
+      *dir1/bar.rb*
+         1|
+         2|bar bar bar bar *Pikon* bar
+         3| 
+         4|
+
+      *foo.rb*
+         4|foo Capsicum foo foo foo foo foo
+         5|
+         6|foo foo foo foo foo *Pikon* foo foo
+         7|
+         8|foo Pikon foo foo foo foo foo foo
+    END
+  end
+
+  it "should support $_ transformations" do
+    rak(%Q[--eval '$_=$_.reverse; next unless $_ =~ /oof/']).should == <<-END
+      *foo.rb*
+         3|*oof* oof oof acirpaC oof oof oof
+         4|*oof* oof oof oof oof mucispaC oof
+         6|*oof* oof nokiP oof oof oof oof oof
+         8|*oof* oof oof oof oof oof nokiP oof
+        10|*oof* xiS oof oof oof xiS oof oof
+        11|*oof* oof oof xiS oof oof oof oof
+        13|*oof* oof oof nonemeG oof oof oof
+    END
+  end
+
+  it "should support multiple matches" do
+    rak(%Q[--eval 'next unless $_ =~ /Pikon/; $_.scan(/\\b\\w{3}\\b/){ matches << $~ }']).should == <<-END
+      *dir1/bar.rb*
+         2|*bar* *bar* *bar* *bar* Pikon *bar*
+         9|*bar* *bar* Pikon *bar* *bar* *bar*
+
+      *foo.rb*
+         6|*foo* *foo* *foo* *foo* *foo* Pikon *foo* *foo*
+         8|*foo* Pikon *foo* *foo* *foo* *foo* *foo* *foo*
+    END
+  end
+end
 
-
-
-
+## Other things --eval could support:
+# * per file   BEGIN{} END{}
+# * global     BEGIN{} END{}
+# * better way to highlight multiple matches
+# 
+# There's also redo but I cannot think of any sensible use
+# (especially if $_ won't persist between runs)
+# (also redo in -nl/-pl is broken)