guard-haskell 1.4.0 → 1.5.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZGVmNTAyMjBkMDZhNGJiYmI5ZDhhNmNkYTA5YTU0MDNmZDQ5MTVkNg==
+    ODI3NmViYzJlOThiNjQxYjNlM2VlZWRhY2Y4MTIyODc0MThiOGRhMw==
   data.tar.gz: !binary |-
-    ODdjMjQxNTc3Y2ZmOTI0MjQ1OTIzNGE2YjFjMDJjZDQ3ZDA4NmQxOQ==
+    ODYyZTU5ZTM1YzM2OWJlNTU2ZTcxMDRmMTFjOTE2YzkxMTY5MDcyMA==
 SHA512:
   metadata.gz: !binary |-
-    MDkyM2Y2Nzg3YWYxMzliNTI1MmY3ZjAwN2JjMDJlM2ZiOTg1NWJjZmQyYjRm
-    ODE0Y2Y1MTQ3YTBkNDEwMDc5YWU4OTQ2MTNkOGI0MTFkMmYxY2VkYzRlODg4
-    ZmE1YjBjNmEwNzE1NzNkNDgxMzQzOTBiM2Y1YWU0MTg1ZGRkMzE=
+    NjVjYmNiOTIwNGM1NzZmYTBkZWYwZTRkMWE1NDY0M2Y1MWEyYzNlOTBjZDU3
+    NmQ3Y2IzMDhlYjBiZmQ2OTQ2OTc5YmVhOGJiZjg5MGMxNDkzMGM1MDBmYjE4
+    NjlkNmU3ZmUyMGYwMTQ4NzUxODVlODc0YjRkYjRiZmM1MWQ5MmI=
   data.tar.gz: !binary |-
-    OTUzOWIyZDE4NjU2MGU1ZTAwMDEyNDgyZTlkMzViYTQ5MzY4ZWExNjliZTAw
-    OTgxMzZiNmRjZjdhYTQzYzkyNDA2ZmI4NWM1ZGRiYzgzZTk4ODY3ODdlNGMz
-    MmQyYzJjMGNhZDAwMjM0ZTRkNDhkMGViOGJiOWE4MzMxZmIzZGE=
+    NWU4YmJkYmRkY2ZhNTZlMDI1NDI4ODllN2YyMDQ0ZGViODI2NWYwNWI3OWUz
+    MGJmZDkxMjAxMTRiYjE1ZmVhYTVkYzU3NmYzYTU1ZTFhOWE4ZjI1ODcyYWQ3
+    MGNkNzQyYTNhMjE1NWFiMjI2Mzg2OTNjN2NiNjc3NTc3YjYzMTI=

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+1.5.0
+=====
+
+  * Add `sandbox_glob` option
+  * Separate stages for [re]loading and rerunning specs
+
 1.4.0
 =====
 

data/README.md

@@ -30,6 +30,17 @@ For explanation what `guard` is and how to use it, please refer to the [`guard m
 When you type in `guard`, `guard-haskell` fires up an `ghci` instance which it talks to, reloading
 and rerunning (parts of) "top" spec on files modifications.
 
+## Guard::Haskell setup
+
+For `guard-haskell` to be ready to work we need a top level spec file and a Guardfile:
+
+```shell
+mkdir --parents test
+echo '{-# OPTIONS_GHC -F -pgmF hspec-discover #-}' > test/Spec.hs
+guard init haskell
+guard
+```
+
 ## Guardfile examples
 
 Typical haskell project:
@@ -75,6 +86,10 @@ Pass custom ghci options, for example, `-XCPP` directives like `-DTEST` (default
 
 "Top" spec location (default: `test/Spec.hs`).
 
+### `sandbox_glob`
+
+A glob that matches cabal sandboxes (default: `.cabal-sandbox/*packages.conf.d`)
+
 ## Known problems
 
 ### App you test uses the GHC API

data/guard-haskell.gemspec

@@ -22,4 +22,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'rake'
   s.add_development_dependency 'rspec'
   s.add_development_dependency 'guard-rspec'
+  s.add_development_dependency 'fakefs'
 end

data/lib/guard/haskell.rb

@@ -22,8 +22,16 @@ module ::Guard
 
     require 'guard/haskell/repl'
 
-    attr_reader :repl, :top_spec, :ghci_options, :targets, :last_run
-    attr_reader :all_on_start, :all_on_pass, :focus_on_fail
+    attr_reader :repl, :targets, :last_run, :opts
+
+    Options = Struct.new(
+      :top_spec,
+      :ghci_options,
+      :all_on_start,
+      :all_on_pass,
+      :focus_on_fail,
+      :sandbox_glob,
+    )
 
     DEFAULT_OPTIONS = {
       top_spec:      "test/Spec.hs",
@@ -31,30 +39,24 @@ module ::Guard
       all_on_start:  false,
       all_on_pass:   false,
       focus_on_fail: true,
+      sandbox_glob: ".cabal-sandbox/*packages.conf.d",
     }
 
     def initialize(user_options = {})
       super
 
-      @last_run      = :success # try to prove it wasn't :-)
-
-      options        = DEFAULT_OPTIONS.merge(user_options)
-      @top_spec      = options[:top_spec]
-      @ghci_options  = options[:ghci_options]
-      @all_on_start  = options[:all_on_start]
-      @all_on_pass   = options[:all_on_pass]
-      @focus_on_fail = options[:focus_on_fail]
-
-      @repl          = Repl.new
+      @last_run = :success # try to prove it wasn't :-)
+      @opts     = Options.new(*DEFAULT_OPTIONS.merge(user_options).values)
+      @repl     = Repl.new
     end
 
     def start
-      repl.start(ghci_options)
-      repl.init(top_spec)
+      repl.start(opts.ghci_options, opts.sandbox_glob)
+      repl.init(opts.top_spec)
 
       @targets = ::Set.new(::Dir.glob("**/*.{hs,lhs}"))
 
-      if all_on_start
+      if opts.all_on_start
         run_all
       end
     end
@@ -69,15 +71,15 @@ module ::Guard
     end
 
     def run_all
-      repl.run
+      repl.reload_and_run_matching
       success?
     end
 
     def run pattern
-      if focus_on_fail and last_run == :runtime_failure
-        repl.rerun
+      if opts.focus_on_fail and last_run == :runtime_failure
+        repl.reload_and_rerun
       else
-        repl.run(pattern)
+        repl.reload_and_run_matching(pattern)
       end
       success?
     end
@@ -88,7 +90,7 @@ module ::Guard
           [:compile_failure, :success]
         @last_run = :success
         Notifier.notify('Success')
-        if all_on_pass
+        if opts.all_on_pass
           run_all
         end
       when [:success, :success]
@@ -110,7 +112,7 @@ module ::Guard
     def run_on_additions paths
       unless paths.all? { |path| targets.include? path }
         @targets += paths
-        repl.init(top_spec)
+        repl.init(opts.top_spec)
       end
     end
 

data/lib/guard/haskell/repl.rb

@@ -10,12 +10,14 @@ class ::Guard::Haskell::Repl
 
   def self.test(str)
     case str
-    when /\d+ examples?, 0 failures/
+    when /\d+ examples?, 0 failures/,
+         /Ok, modules loaded:/
       :success
     when /\d+ examples?, \d+ failures?/
       :runtime_failure
     when /Failed, modules loaded:/,
          /\*{3} Exception:/,
+         /cannot find object file for module/,
          /phase `C pre-processor' failed/,
          /GHCi runtime linker: fatal error:/,
          /During interactive linking, GHCi couldn't find the following symbol:/
@@ -23,19 +25,29 @@ class ::Guard::Haskell::Repl
     end
   end
 
-  def start ghci_options
+  def start(ghci_options, sandbox_glob)
     cmd = ["ghci"]
+
     Dir["*"].each { |d| cmd << "-i#{d}" if File.directory?(d) }
-    sandbox = ::Dir[".cabal-sandbox/*packages.conf.d"].first
-    cmd.concat(["-no-user-package-db", "-package-db=#{sandbox}"]) if sandbox
+    lookup_sandbox(cmd, sandbox_glob)
     cmd.concat(ghci_options)
 
     @stdin, stdout, @thread = ::Open3.popen2e(*cmd)
     @listener = ::Thread.new { listen(stdout, STDOUT) }
   end
 
+  def lookup_sandbox(cmd, sandbox_glob)
+    sandboxes = Sandbox.new(sandbox_glob)
+    sandboxes.with_best_sandbox(->(str) { str.scan(/\d+/).map(&:to_i) }) do |best_sandbox|
+      puts "Cabal sandboxes found:"
+      sandboxes.each { |sandbox| puts "  #{sandbox}" }
+      puts "Cabal sandbox used:\n  #{best_sandbox}"
+      cmd.concat(["-no-user-package-db", "-package-db=#{best_sandbox}"])
+    end
+  end
+
   def init(spec)
-    repl(":load #{spec}\n")
+    run_command_and_wait_for_result(":load #{spec}\n")
   end
 
   def exit
@@ -43,26 +55,54 @@ class ::Guard::Haskell::Repl
     ::Thread.kill(listener)
   end
 
-  def run(pattern = nil)
-    if pattern.nil?
-      repl(":reload\n:main --color\n")
-    else
-      repl(":reload\n:main --color --match #{pattern}\n")
+  def reload_and_run_matching(pattern = nil)
+    if run_command_and_wait_for_result(":reload\n")
+      if pattern.nil?
+        run_command_and_wait_for_result(":main --color\n")
+      else
+        run_command_and_wait_for_result(":main --color --match #{pattern}\n")
+      end
     end
   end
 
-  def rerun
-    repl(":reload\n:main --color --rerun\n")
+  def reload_and_rerun
+    if run_command_and_wait_for_result(":reload\n")
+      run_command_and_wait_for_result(":main --color --rerun\n")
+    end
   end
 
-  def result
-    while @running do sleep(0.01) end
-    @result
+  class Sandbox
+    attr_reader :sandboxes
+
+    include ::Enumerable
+
+    def initialize(glob)
+      @sandboxes = ::Dir[glob]
+    end
+
+    def each(&block)
+      sandboxes.each(&block)
+    end
+
+    def with_best_sandbox(ordering)
+      best = sandboxes.max_by(&ordering)
+      yield best if best
+      best
+    end
   end
 
   private
+    def run_command_and_wait_for_result(command)
+      talk_to_repl(command)
+      wait_for_result == :success
+    end
+
+    def wait_for_result
+      while @running do sleep(0.01) end
+      @result
+    end
 
-    def repl(command)
+    def talk_to_repl(command)
       @running = true
       stdin.write(command)
     end

data/lib/guard/haskell/version.rb

@@ -1,5 +1,5 @@
 module Guard
   module HaskellVersion
-    VERSION = '1.4.0'
+    VERSION = '1.5.0'
   end
 end

data/spec/guard/haskell/repl_spec.rb

@@ -1,3 +1,4 @@
+require 'fakefs/spec_helpers'
 require 'spec_helper'
 require 'guard/notifier'
 
@@ -11,42 +12,53 @@ describe ::Guard::Haskell::Repl do
 
   describe '#init' do
     it "calls :load on ghci instance" do
-      expect(repl).to receive(:repl).with(/:load/)
+      expect(repl).to receive(:run_command_and_wait_for_result).with(/:load/)
       repl.init("Spec.hs")
     end
 
     it "loads provided spec" do
-      expect(repl).to receive(:repl).with(/FooBarSpec.hs/)
+      expect(repl).to receive(:run_command_and_wait_for_result).with(/FooBarSpec.hs/)
       repl.init("FooBarSpec.hs")
     end
   end
 
-  describe '#run' do
-    it "reloads the spec if no pattern is provided" do
-      expect(repl).to receive(:repl).with(/:reload/)
-      repl.run
+  context "running spec" do
+    before(:each) do
+      repl.stub(:run_command_and_wait_for_result) { |_| true }
     end
 
-    it "reloads the spec if a pattern is provided" do
-      expect(repl).to receive(:repl).with(/:reload/)
-      repl.run("FooBar")
-    end
+    describe '#reload_and_run_matching' do
+      it "reloads the spec if no pattern is provided" do
+        expect(repl).to receive(:run_command_and_wait_for_result).with(/:reload/)
+        repl.reload_and_run_matching
+      end
 
-    it "provides a pattern for spec to match" do
-      expect(repl).to receive(:repl).with(/--match FooBar/)
-      repl.run("FooBar")
-    end
-  end
+      it "reloads the spec if a pattern is provided" do
+        expect(repl).to receive(:run_command_and_wait_for_result).with(/:reload/)
+        repl.reload_and_run_matching
+      end
+
+      it "provides a pattern for spec to match" do
+        expect(repl).to receive(:run_command_and_wait_for_result).with(/--match FooBar/)
+        repl.reload_and_run_matching("FooBar")
+      end
 
-  describe '#rerun' do
-    it "reloads the spec" do
-      expect(repl).to receive(:repl).with(/:reload/)
-      repl.rerun
+      it "provides no pattern for spec to match if an argument is nil" do
+        expect(repl).not_to receive(:run_command_and_wait_for_result).with(/--match FooBar/)
+        repl.reload_and_run_matching(nil)
+      end
     end
 
-    it "reruns the spec" do
-      expect(repl).to receive(:repl).with(/--rerun/)
-      repl.rerun
+    describe '#reload_and_rerun' do
+      it "reloads the spec" do
+        expect(repl).to receive(:run_command_and_wait_for_result).with(/:reload/)
+        repl.reload_and_rerun
+      end
+
+      it "reruns the spec" do
+        expect(repl).to receive(:run_command_and_wait_for_result).with(/--rerun/)
+        repl.reload_and_rerun
+      end
     end
   end
 
@@ -131,6 +143,17 @@ describe ::Guard::Haskell::Repl do
         expect(repl.instance_variable_get(:@result)).to eq(:compile_failure)
       end
 
+      # This one's even trickier to reproduce than the previous one
+      it 'handles "cannot find object file" runtime linker error' do
+        in_stream  = ::File.open(run_file["runtime-linker-cannot-find-object-file.error"])
+        repl.instance_variable_set(:@running, true)
+
+        repl.send(:listen, in_stream, dev_null)
+
+        expect(repl.instance_variable_get(:@running)).to eq(false)
+        expect(repl.instance_variable_get(:@result)).to eq(:compile_failure)
+      end
+
       it "handles hspec exceptions" do
         in_stream  = ::File.open(run_file["hspec-exception.error"])
         repl.instance_variable_set(:@running, true)
@@ -152,4 +175,78 @@ describe ::Guard::Haskell::Repl do
       end
     end
   end
+
+  describe "#lookup_sandbox" do
+    include FakeFS::SpecHelpers
+
+    before(:each) { ::IO.any_instance.stub(:puts) }
+
+    it "does not find anything if there are no sandboxes" do
+      expect_any_instance_of(::IO).not_to receive(:puts)
+      expect(repl.lookup_sandbox([], "*packages.conf.d")).to be_nil
+    end
+
+    it "finds a sandbox" do
+      ::FileUtils.mkdir_p(["ghc-7.6.3-packages.conf.d"])
+      expect_any_instance_of(::IO).to receive(:puts).with("Cabal sandboxes found:")
+      expect(repl.lookup_sandbox([], "*packages.conf.d")).to eq("/ghc-7.6.3-packages.conf.d")
+    end
+
+    it "finds a sandbox with the default settings" do
+      ::FileUtils.mkdir_p([".cabal-sandbox/foo-bar-ghc-7.6.3-packages.conf.d"])
+      expect_any_instance_of(::IO).to receive(:puts).with("Cabal sandboxes found:")
+      expect(repl.lookup_sandbox([], ::Guard::Haskell::DEFAULT_OPTIONS[:sandbox_glob])).to eq("/.cabal-sandbox/foo-bar-ghc-7.6.3-packages.conf.d")
+    end
+
+    it "compares sandboxes cleverly" do
+      ::FileUtils.mkdir_p(
+          [ "ghc-1.0-packages.conf.d",
+            "ghc-1.1-packages.conf.d",
+            "ghc-1.2-packages.conf.d",
+            "ghc-1.10-packages.conf.d",
+          ])
+      expect(repl.lookup_sandbox([], "*packages.conf.d")).to eq("/ghc-1.10-packages.conf.d")
+    end
+  end
+end
+
+describe ::Guard::Haskell::Repl::Sandbox do
+  ::Sandbox = ::Guard::Haskell::Repl::Sandbox
+  include FakeFS::SpecHelpers
+
+  let(:id) { ->(x) { x } }
+  let(:reversed) { ->(str) { str.reverse } }
+
+  before(:each) { ::IO.any_instance.stub(:puts) }
+
+  it "has an empty list of sandboxes if no sandboxes are found" do
+    expect(::Sandbox.new("*").sandboxes).to eq([])
+  end
+
+  it "has a singleton list of sandboxes if one sandbox is found" do
+    ::FileUtils.touch(["foo", "bar", "baz"])
+    expect(::Sandbox.new("foo").sandboxes).to eq(["/foo"])
+  end
+
+  it "has a list of sandboxes if more than one sandbox is found" do
+    ::FileUtils.touch(["foo", "bar", "baz"])
+    expect(::Sandbox.new("ba*").sandboxes).to eq(["/bar", "/baz"])
+  end
+
+  it "has a nil for the best sandbox of an empty list of sandboxes" do
+    expect_any_instance_of(::IO).not_to receive(:puts)
+    expect(::Sandbox.new("*").with_best_sandbox(id) { |s| puts s }).to be_nil
+  end
+
+  it "chooses a \"maximum\" for the best sandbox" do
+    ::FileUtils.touch(["foo", "bar", "baz"])
+    expect_any_instance_of(::IO).to receive(:puts).with("/foo")
+    expect(::Sandbox.new("*").with_best_sandbox(id) { |s| puts s }).to eq("/foo")
+  end
+
+  it "chooses a \"maximum\" of the complex ordering for the best sandbox" do
+    ::FileUtils.touch(["foo", "bar", "baz", "zap"])
+    expect_any_instance_of(::IO).to receive(:puts).with("/baz")
+    expect(::Sandbox.new("*").with_best_sandbox(reversed) { |s| puts s }).to eq("/baz")
+  end
 end

data/spec/guard/haskell_spec.rb

@@ -34,9 +34,7 @@ describe "monkey patching" do
 end
 
 describe ::Guard::Haskell do
-  let(:guard) do
-    ::Guard::Haskell.new
-  end
+  let(:guard) { ::Guard::Haskell.new }
 
   before :each do
     ::Guard.stub(:add_group)
@@ -45,24 +43,10 @@ describe ::Guard::Haskell do
   end
 
   describe ".initialize" do
-    it "has :all_on_start option" do
-      expect(guard.instance_variable_defined?(:@all_on_start)).to eq(true)
-    end
-
-    it "has :all_on_pass option" do
-      expect(guard.instance_variable_defined?(:@all_on_pass)).to eq(true)
-    end
-
-    it "has :focus_on_fail option" do
-      expect(guard.instance_variable_defined?(:@focus_on_fail)).to eq(true)
-    end
-
-    it "has :ghci_options option" do
-      expect(guard.instance_variable_defined?(:@ghci_options)).to eq(true)
-    end
-
-    it "has :top_spec option" do
-      expect(guard.instance_variable_defined?(:@top_spec)).to eq(true)
+    ::Guard::Haskell::DEFAULT_OPTIONS.each do |key, value|
+      it "has :#{key} option" do
+        expect(::Guard::Haskell.new.opts.send(key)).to eq(value)
+      end
     end
   end
 
@@ -83,7 +67,7 @@ describe ::Guard::Haskell do
     it "runs all examples on start with :all_on_start option enabled" do
       custom_guard = ::Guard::Haskell.new(all_on_start: true)
 
-      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:run)
+      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:reload_and_run_matching).with(no_args)
       expect(custom_guard).to receive(:success?)
 
       custom_guard.start
@@ -116,7 +100,7 @@ describe ::Guard::Haskell do
 
   describe "#run" do
     it "checks success after run" do
-      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:run).with("Foo")
+      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:reload_and_run_matching).with("Foo")
       expect(guard).to receive(:success?)
       guard.instance_variable_set(:@last_run, :success)
 
@@ -125,7 +109,7 @@ describe ::Guard::Haskell do
     end
 
     it "runs examples matching pattern if last run was a success" do
-      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:run).with("Foo")
+      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:reload_and_run_matching).with("Foo")
       guard.instance_variable_set(:@last_run, :success)
 
       guard.start
@@ -133,7 +117,7 @@ describe ::Guard::Haskell do
     end
 
     it "runs examples matching pattern if last run was a compile time failure" do
-      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:run).with("Foo")
+      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:reload_and_run_matching).with("Foo")
       guard.instance_variable_set(:@last_run, :compile_failure)
 
       guard.start
@@ -141,20 +125,20 @@ describe ::Guard::Haskell do
     end
 
     it "reruns failing examples if last run was a runtime failure and @focus_on_fail is set" do
-      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:rerun)
-      expect_any_instance_of(::Guard::Haskell::Repl).not_to receive(:run).with("Foo")
+      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:reload_and_rerun)
+      expect_any_instance_of(::Guard::Haskell::Repl).not_to receive(:reload_and_run_matching).with("Foo")
       guard.instance_variable_set(:@last_run, :runtime_failure)
-      guard.instance_variable_set(:@focus_on_fail, true)
+      guard.opts.focus_on_fail = true
 
       guard.start
       guard.run("Foo")
     end
 
     it "runs examples matching pattern if last run was a runtime failure but @focus_on_fail is unset" do
-      expect_any_instance_of(::Guard::Haskell::Repl).not_to receive(:rerun)
-      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:run).with("Foo")
+      expect_any_instance_of(::Guard::Haskell::Repl).not_to receive(:reload_and_rerun)
+      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:reload_and_run_matching).with("Foo")
       guard.instance_variable_set(:@last_run, :runtime_failure)
-      guard.instance_variable_set(:@focus_on_fail, false)
+      guard.opts.focus_on_fail = false
 
       guard.start
       guard.run("Foo")
@@ -163,7 +147,7 @@ describe ::Guard::Haskell do
 
   describe "#run_all" do
     it "checks success after run" do
-      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:run)
+      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:reload_and_run_matching)
       expect(guard).to receive(:success?)
       guard.instance_variable_set(:@last_run, :success)
 
@@ -291,7 +275,7 @@ describe ::Guard::Haskell do
 
   describe "#run_on_modifications" do
     it "run examples for simple haskell files" do
-      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:run).with("Foo")
+      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:reload_and_run_matching).with("Foo")
       expect_any_instance_of(::Guard::Haskell::Repl).to receive(:result)
 
       guard.start
@@ -299,7 +283,7 @@ describe ::Guard::Haskell do
     end
 
     it "run examples for simple literate haskell files" do
-      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:run).with("Foo")
+      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:reload_and_run_matching).with("Foo")
       expect_any_instance_of(::Guard::Haskell::Repl).to receive(:result)
 
       guard.start
@@ -307,7 +291,7 @@ describe ::Guard::Haskell do
     end
 
     it "run examples for *complex* haskell files" do
-      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:run).with("Bar.Baz")
+      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:reload_and_run_matching).with("Bar.Baz")
       expect_any_instance_of(::Guard::Haskell::Repl).to receive(:result)
 
       guard.start
@@ -315,7 +299,7 @@ describe ::Guard::Haskell do
     end
 
     it "run examples for simple haskell spec files" do
-      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:run).with("Foo")
+      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:reload_and_run_matching).with("Foo")
       expect_any_instance_of(::Guard::Haskell::Repl).to receive(:result)
 
       guard.start
@@ -323,7 +307,7 @@ describe ::Guard::Haskell do
     end
 
     it "run examples for simple literate haskell spec files" do
-      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:run).with("Foo")
+      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:reload_and_run_matching).with("Foo")
       expect_any_instance_of(::Guard::Haskell::Repl).to receive(:result)
 
       guard.start
@@ -331,7 +315,7 @@ describe ::Guard::Haskell do
     end
 
     it "run examples for *complex* haskell spec files" do
-      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:run).with("Bar.Baz")
+      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:reload_and_run_matching).with("Bar.Baz")
       expect_any_instance_of(::Guard::Haskell::Repl).to receive(:result)
 
       guard.start

data/spec/run-files/hspec-exception.error

@@ -1,3 +1,2 @@
-*Main> Ok, modules loaded: Main, Useful.Parser, Useful.Graph, Useful.Git.
 *Main>
 *** Exception: Prelude.undefined

data/spec/run-files/runtime-linker-cannot-find-object-file.error

@@ -0,0 +1,3 @@
+*Main> <interactive session>:
+   cannot find object file for module `main:Penirka'
+   while linking an interpreted expression

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: guard-haskell
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Matvey Aksenov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-21 00:00:00.000000000 Z
+date: 2014-04-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: guard
@@ -80,6 +80,20 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: fakefs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Guard::Haskell automatically runs your specs
 email: matvey.aksenov@gmail.com
 executables: []
@@ -103,6 +117,7 @@ files:
 - spec/guard/haskell_spec.rb
 - spec/run-files/cpp-exception.error
 - spec/run-files/hspec-exception.error
+- spec/run-files/runtime-linker-cannot-find-object-file.error
 - spec/run-files/runtime-linker-couldn't-find-symbol.error
 - spec/run-files/runtime-linker-duplicate-definition-for-symbol.error
 - spec/run-files/spec-failure.error
@@ -137,6 +152,7 @@ test_files:
 - spec/guard/haskell_spec.rb
 - spec/run-files/cpp-exception.error
 - spec/run-files/hspec-exception.error
+- spec/run-files/runtime-linker-cannot-find-object-file.error
 - spec/run-files/runtime-linker-couldn't-find-symbol.error
 - spec/run-files/runtime-linker-duplicate-definition-for-symbol.error
 - spec/run-files/spec-failure.error