guard-haskell 1.6.0 → 2.0.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MTlhNDgyMGFhYTJhZDQxMjQyNjhlMWQxMmMwMTE5YzljYzY4NzNhYw==
+    Y2MzNjQ5MjQ2NjNmMzU0ODQxZWIwMDU4MTZhZTA3OTE4NmFkNDc2NA==
   data.tar.gz: !binary |-
-    NDk2ZjBjMjI0MjdiMDJkMDM5ZDY4ZTg2Y2VjNTk5MWQ3ZmE2ODM5MA==
+    YWRkOThmYzYxOWE1ZmQ3ZmQ4YmFhNGVkN2JiNTJmNTM2NTE1YWZmZg==
 SHA512:
   metadata.gz: !binary |-
-    MWNhODA4OWM5NDU3ZGJmNzUyYjVmMTUzMWU2Mjc3YmQxMTgyYzkzZjUxMTA5
-    ZTk4Y2FiYTc3YWQwYmIzNTMyOGNhYTdhMTQ3ODZiZjY4M2RkZTE4OWNiODNj
-    NzA0MTliMDgyZDVmMzI3MGRjODE1ZDkwMDNlOTFlYTdkOGMwOTU=
+    ZjYyNTMxYzVkNjM1YjljMDZkNTg5Mzc1ZjFhZWMwNTQ1OTUwNjI0MTc5OTk2
+    ZjY5OGQ1YjY3NjVmNTQzOTMzMDE5MzNlYjNjNjJkNDNkOTE5MDIyYzkyMTlh
+    ZmVmY2ZmNWFhMTI0NzA0NGRiMzk0ZWIxYjUwY2I2YzQzMWVhNTI=
   data.tar.gz: !binary |-
-    MWExZTU3Mjg0ZDVkODJjMzQzYzg2NzYwYjM3YmE4Y2QwOTg5MThiMjBjMTk3
-    MTJmMDNkZTc5ZmE4MWE0ZThlMzhjZTI5NThkMzcwNDMxY2MyOTIyNzVlYjM1
-    YWM5YjFmYmVlYzFiNzI1MzM1YTBlM2Y2ODJhZGM1N2U1YzNhYjY=
+    MjgyMGZlYTcwMjMxMTU5ZDc0MDM3N2Q2ZTQ1NGNjMDM1MGQ4NTZkNWRkNDli
+    MWVlOWM5ZTc2NjEzMmM3NjI2ZGIyMzk3OGZhYmJjYWUzNWEyNWZlZmU3ZDAw
+    MmFkNjA0ZGNiOGIwYThiYmIxYmFkY2FkZDIxNjNkYmZkOWRkZDY=

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+2.0.0
+=====
+
+  * Switch to `cabal repl` as an inferior shell
+
+  * Fix the bug where the cursor does not reappear on guard shutdown
+
 1.6.0
 =====
 
@@ -11,6 +18,7 @@
 =====
 
   * Add `sandbox_glob` option
+
   * Separate stages for [re]loading and rerunning specs
 
 1.4.0
@@ -22,14 +30,18 @@
 =====
 
   * Ignore user cabal package database if sandbox is found
+
   * Catch CPP failures (previously didn't work because of the typo)
+
   * Add `focus_on_fail` option
 
 1.2.0
 =====
 
   * Catch GHCI runtime linker failures
+
   * Separate runtime and compile time failures for `--rerun` to work better
+
   * Fix ignored spec results if spec was run directly from guard repl
 
 1.1.0

data/README.md

@@ -7,43 +7,40 @@ guard-haskell
 
 `Guard::Haskell` automatically runs your specs
 
-# Install
+Install
+-------
 
 ```shell
 % cabal install hspec
 % gem install guard-haskell
 ```
 
-# Usage
+Usage
+-----
 
-## How does it work?
+### How does it work?
 
 For explanation what `guard` is and how to use it, please refer to the [`guard manual`][0]
 
-`guard-haskell` uses [`hspec`][1] to run specs and check results, so it makes some assumptions about your code style:
+`guard-haskell` uses [`hspec`][1] to run specs and check results, so it makes
+some assumptions about your code organization and style:
 
-  * `hspec` is your testing framework and
+  * `hspec` is your testing framework of choice; therefore,
 
-  * [`hspec-discover`][2] (or similar tool) organizes your specs,
-  i.e. there is a "top" spec (usually `test/Spec.hs`) that pulls others in
+  * [`hspec-discover`][2] organizes your specs
 
-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.
+When you type `guard` in the terminal, `guard-haskell` fires up a `cabal repl` instance
+to talk to, running (parts of) examples when files are modified.
 
-## Guard::Haskell setup
+### Guard::Haskell setup
 
-For `guard-haskell` to be ready to work we need a top level spec file and a Guardfile:
+For `guard-haskell` to be ready to work we need a test suite named "spec" (that's
+configurable, any test suite name will do) defined in the cabal file and a Guardfile
+(which you can get by running `guard init haskell`)
 
-```shell
-mkdir --parents test
-echo '{-# OPTIONS_GHC -F -pgmF hspec-discover #-}' > test/Spec.hs
-guard init haskell
-guard
-```
-
-## Guardfile examples
+### Guardfile examples
 
-Typical haskell project:
+A typical haskell project:
 
 ```ruby
 guard :haskell do
@@ -52,17 +49,41 @@ guard :haskell do
 end
 ```
 
-Customized haskell project:
+A customized haskell project:
+
+```ruby
+options = ["--ghc-options=-ignore-dot-ghci -DTEST"]
+
+guard :haskell, all_on_start: true, repl_options: options do
+  watch(%r{test/.+Spec\.l?hs$})
+  watch(%r{lib/.+\.l?hs$})
+  watch(%r{bin/.+\.l?hs$})
+end
+```
+
+Another customized haskell project:
 
 ```ruby
-guard :haskell, all_on_pass: true, ghci_options: ["-DTEST"] do
+guard :haskell, all_on_start: true, all_on_pass: true, cabal_target: "not-spec" do
   watch(%r{test/.+Spec\.l?hs$})
   watch(%r{lib/.+\.l?hs$})
   watch(%r{bin/.+\.l?hs$})
 end
 ```
 
-## Options
+#### Gemfile
+
+It's also advised to have a trivial `Gemfile` in the repository for
+`bundler exec guard` to be able to pick the correct versions of the dependencies:
+
+```ruby
+source "https://rubygems.org"
+
+gem "guard-haskell", "~>2.0"
+```
+
+Options
+-------
 
 `Guard::Haskell` has a bunch of options:
 
@@ -72,25 +93,22 @@ Run all examples on start (default: `false`).
 
 ### `all_on_pass`
 
-Run all examples after previously failing spec _finally_ passes (default: `false`).
+Run all examples when a failed spec passes again (default: `false`).
 
 ### `focus_on_fail`
 
 Rerun only failed examples until they pass (default: `true`).
 
-### `ghci_options`
-
-Pass custom ghci options, for example, `-XCPP` directives like `-DTEST` (default: `[]`).
-
-### `top_spec`
+### `repl_options`
 
-"Top" spec location (default: `test/Spec.hs`).
+Pass custom cabal repl options (default: `[]`).
 
-### `sandbox_glob`
+### `cabal_target`
 
-A glob that matches cabal sandboxes (default: `.cabal-sandbox/*packages.conf.d`)
+The cabal build target to load (default: `spec`).
 
-## Known problems
+Known problems
+--------------
 
 ### App you test uses the GHC API
 

data/asset/failed/phase-linker-failed.err

@@ -0,0 +1,4 @@
+*Main> /usr/bin/ld: dist/build/spec/spec-tmp/Paths_X.o: relocation R_X86_64_32S against `stg_bh_upd_frame_info' can not be used when making a shared object; recompile with -fPIC
+dist/build/spec/spec-tmp/Paths_X.o: could not read symbols: Bad value
+collect2: error: ld returned 1 exit status
+phase `Linker' failed (exitcode = 1)

data/lib/guard/haskell.rb

@@ -3,17 +3,8 @@ require 'guard/plugin'
 require 'set'
 
 class ::String
-  def strip_lowercase_directories
-    matches = self.match(/^\p{Lower}[^\/]+\/(.+)/)
-    if matches
-      matches[1].strip_lowercase_directories
-    else
-      self
-    end
-  end
-
-  def path_to_module_name
-    self.gsub(/\//, ".")
+  def to_module_name
+    self.split('/').drop_while{|x| /^[[:lower:]]/.match(x)}.join('.')
   end
 end
 
@@ -25,22 +16,20 @@ module ::Guard
     attr_accessor :opts, :repl
     attr_reader :targets, :last_run
 
-    Options = Struct.new(
-      :top_spec,
-      :ghci_options,
+    Options = ::Struct.new(
+      :cabal_target,
+      :repl_options,
       :all_on_start,
       :all_on_pass,
       :focus_on_fail,
-      :sandbox_glob,
     )
 
     DEFAULT_OPTIONS = {
-      top_spec:      "test/Spec.hs",
-      ghci_options:  [],
+      cabal_target:  "spec",
+      repl_options:  [],
       all_on_start:  false,
       all_on_pass:   false,
       focus_on_fail: true,
-      sandbox_glob: ".cabal-sandbox/*packages.conf.d",
     }
 
     def initialize(user_options = {})
@@ -50,8 +39,9 @@ module ::Guard
 
     def start
       @last_run = :success # try to prove it wasn't :-)
-      self.repl = Repl.new(opts.ghci_options, opts.sandbox_glob)
-      repl.init(opts.top_spec)
+      self.repl = Repl.new(opts.cabal_target, opts.repl_options)
+      throw :cabal_repl_initialization_has_failed if self.repl.status == :loading_failure
+      success?
 
       @targets = ::Set.new(::Dir.glob("**/*.{hs,lhs}"))
 
@@ -74,7 +64,7 @@ module ::Guard
       success?
     end
 
-    def run pattern
+    def run(pattern)
       if opts.focus_on_fail and last_run == :runtime_failure
         repl.reload_and_rerun
       else
@@ -84,7 +74,7 @@ module ::Guard
     end
 
     def success?
-      case [last_run, repl.result]
+      case [last_run, repl.status]
       when [:runtime_failure, :success],
           [:compile_failure, :success]
         @last_run = :success
@@ -108,17 +98,17 @@ module ::Guard
       end
     end
 
-    def run_on_additions paths
-      unless paths.all? { |path| targets.include? path }
+    def run_on_additions(paths)
+      unless paths.all? { |path| targets.include?(path) }
         @targets += paths
-        repl.init(opts.top_spec)
+        reload
       end
     end
 
-    def run_on_modifications paths
+    def run_on_modifications(paths)
       case paths.first
       when /(.+)Spec\.l?hs$/, /(.+)\.l?hs$/
-        run($1.strip_lowercase_directories.path_to_module_name)
+        run($1.to_module_name)
       end
     end
   end

data/lib/guard/haskell/repl.rb

@@ -1,9 +1,9 @@
 require 'open3'
 
 class ::Guard::Haskell::Repl
-  attr_reader :stdin, :listener, :thread, :result
+  attr_reader :stdin, :listener, :inferior, :status
 
-  def self.test(str)
+  def self.finished_with(str)
     case str
     when /\d+ examples?, 0 failures/,
          /Ok, modules loaded:/
@@ -15,6 +15,7 @@ class ::Guard::Haskell::Repl
          /cannot find object file for module/,
          /phase `C pre-processor' failed/,
          /phase `Haskell pre-processor' failed/,
+         /phase `Linker' failed/,
          /GHCi runtime linker: fatal error:/,
          /During interactive linking, GHCi couldn't find the following symbol:/,
          /ghc: could not execute:/
@@ -22,36 +23,21 @@ class ::Guard::Haskell::Repl
     end
   end
 
-  def initialize(ghci_options, sandbox_glob)
-    @running = false
-    @result  = :success
-
-    cmd = ["ghci"]
-
-    Dir["*"].each { |d| cmd << "-i#{d}" if File.directory?(d) }
-    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
+  def initialize(cabal_target, repl_options)
+    @listening = false
+    @status = :success
+    start("cabal", "repl", cabal_target, *repl_options)
   end
 
-  def init(spec)
-    run_command_and_wait_for_result(":load #{spec}\n")
+  def start(*cmd)
+    @listening = true
+    @stdin, stdout, @inferior = ::Open3.popen2e(*cmd)
+    @listener = ::Thread.new { listen_or_die(stdout, STDOUT) }
+    wait_for_result
   end
 
   def exit
-    ::Process::kill("TERM", thread.pid)
+    stdin.write(":quit\n")
     ::Thread.kill(listener)
   end
 
@@ -71,53 +57,43 @@ class ::Guard::Haskell::Repl
     end
   end
 
-  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)
+      @listening = true
+      stdin.write(command)
       wait_for_result == :success
     end
 
     def wait_for_result
-      while @running do sleep(0.01) end
-      @result
+      while @listening do sleep(0.01) end
+      @status
     end
 
-    def talk_to_repl(command)
-      @running = true
-      stdin.write(command)
+    def listen_or_die(in_stream, out_stream)
+      listen(in_stream, out_stream) # should never return
+      stop(:loading_failure)
     end
 
     def listen(in_stream, out_stream)
-      while (str = in_stream.gets)
-        out_stream.print(str)
-        if @running
-          res = self.class.test(str)
+      while (line = in_stream.gets)
+        out_stream.print(line)
+        if @listening
+          res = self.class.finished_with(line)
           case res
           when :success, :runtime_failure, :compile_failure
-            @result  = res
-            @running = false
+            # A horrible hack to show the cursor again
+            #
+            # The problem is that '\e[?25h' code from hspec is waiting on
+            # the next line, which we probably will never read :-(
+            out_stream.print("\e[?25h")
+            stop(res)
           end
         end
       end
     end
+
+    def stop(status)
+      @status = status
+      @listening = false
+    end
 end

data/lib/guard/haskell/templates/Guardfile

@@ -1,8 +1,8 @@
-ghci_options =
-  [ "-ignore-dot-ghci" \
+repl_options =
+  [ "--ghc-options=-ignore-dot-ghci" \
   ]
 
-guard :haskell, ghci_options: ghci_options do
+guard :haskell, repl_options: repl_options do
   watch(%r{test/.+Spec\.l?hs$})
   watch(%r{src/.+\.l?hs$})
 end

data/lib/guard/haskell/version.rb

@@ -1,5 +1,5 @@
 module Guard
   module HaskellVersion
-    VERSION = '1.6.0'
+    VERSION = '2.0.0'
   end
 end

data/spec/guard/haskell/repl_spec.rb

@@ -3,25 +3,13 @@ require 'spec_helper'
 require 'guard/notifier'
 
 dev_null = ::File.open("/dev/null", "w")
-run_file = ->(file) { "spec/run-files/#{file}" }
+asset = ->(file) { "asset/#{file}" }
 
 describe ::Guard::Haskell::Repl do
   let(:repl) do
     ::Guard::Haskell::Repl.new
   end
 
-  describe '#init' do
-    it "calls :load on ghci instance" do
-      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(:run_command_and_wait_for_result).with(/FooBarSpec.hs/)
-      repl.init("FooBarSpec.hs")
-    end
-  end
-
   context "running spec" do
     before(:each) do
       repl.stub(:run_command_and_wait_for_result) { |_| true }
@@ -62,215 +50,151 @@ describe ::Guard::Haskell::Repl do
     end
   end
 
-  describe '#test' do
+  describe '#finished_with' do
     it "handles zero examples/failures" do
-      expect(::Guard::Haskell::Repl.test("0 examples, 0 failures")).to eq(:success)
+      expect(::Guard::Haskell::Repl.finished_with("0 examples, 0 failures")).to eq(:success)
     end
 
     it "handles one example/zero failures" do
-      expect(::Guard::Haskell::Repl.test("1 example, 0 failures")).to eq(:success)
+      expect(::Guard::Haskell::Repl.finished_with("1 example, 0 failures")).to eq(:success)
     end
 
     it "handles multiple examples/zero failures" do
-      expect(::Guard::Haskell::Repl.test("37 examples, 0 failures")).to eq(:success)
+      expect(::Guard::Haskell::Repl.finished_with("37 examples, 0 failures")).to eq(:success)
     end
 
     it "handles one example/failure" do
-      expect(::Guard::Haskell::Repl.test("1 example, 1 failure")).to eq(:runtime_failure)
+      expect(::Guard::Haskell::Repl.finished_with("1 example, 1 failure")).to eq(:runtime_failure)
     end
 
     it "handles multiple examples/multiple failures" do
-      expect(::Guard::Haskell::Repl.test("26 examples, 2 failures")).to eq(:runtime_failure)
+      expect(::Guard::Haskell::Repl.finished_with("26 examples, 2 failures")).to eq(:runtime_failure)
     end
 
     it "handles failure to load the module" do
-      expect(::Guard::Haskell::Repl.test("Failed, modules loaded:")).to eq(:compile_failure)
+      expect(::Guard::Haskell::Repl.finished_with("Failed, modules loaded:")).to eq(:compile_failure)
     end
 
     it "handles uncaught exceptions" do
-      expect(::Guard::Haskell::Repl.test("*** Exception: Prelude.undefined")).to eq(:compile_failure)
+      expect(::Guard::Haskell::Repl.finished_with("*** Exception: Prelude.undefined")).to eq(:compile_failure)
     end
 
     it "handles CPP errors" do
-      expect(::Guard::Haskell::Repl.test("phase `C pre-processor' failed")).to eq(:compile_failure)
+      expect(::Guard::Haskell::Repl.finished_with("phase `C pre-processor' failed")).to eq(:compile_failure)
     end
 
     it "handles Haskell pre-processor errors" do
-      expect(::Guard::Haskell::Repl.test("phase `Haskell pre-processor' failed")).to eq(:compile_failure)
+      expect(::Guard::Haskell::Repl.finished_with("phase `Haskell pre-processor' failed")).to eq(:compile_failure)
     end
 
     it "handles runtime linker errors" do
-      expect(::Guard::Haskell::Repl.test("GHCi runtime linker: fatal error:")).to eq(:compile_failure)
+      expect(::Guard::Haskell::Repl.finished_with("GHCi runtime linker: fatal error:")).to eq(:compile_failure)
     end
   end
 
   describe '#listen' do
     context 'real world' do
       it "handles typical pass run" do
-        in_stream  = ::File.open(run_file["spec-pass.success"])
-        repl.instance_variable_set(:@running, true)
+        in_stream  = ::File.open(asset["passed/spec-pass.ok"])
+        repl.instance_variable_set(:@listening, 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(:success)
+        expect(repl.instance_variable_get(:@listening)).to eq(false)
+        expect(repl.instance_variable_get(:@status)).to eq(:success)
       end
 
       it "handles typical failure run" do
-        in_stream  = ::File.open(run_file["spec-failure.error"])
-        repl.instance_variable_set(:@running, true)
+        in_stream  = ::File.open(asset["failed/spec-failure.err"])
+        repl.instance_variable_set(:@listening, 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(:runtime_failure)
+        expect(repl.instance_variable_get(:@listening)).to eq(false)
+        expect(repl.instance_variable_get(:@status)).to eq(:runtime_failure)
       end
 
       it 'handles "duplicate definition" runtime linker error' do
-        in_stream  = ::File.open(run_file["runtime-linker-duplicate-definition-for-symbol.error"])
-        repl.instance_variable_set(:@running, true)
+        in_stream  = ::File.open(asset["failed/runtime-linker-duplicate-definition-for-symbol.err"])
+        repl.instance_variable_set(:@listening, 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)
+        expect(repl.instance_variable_get(:@listening)).to eq(false)
+        expect(repl.instance_variable_get(:@status)).to eq(:compile_failure)
       end
 
       # Unfortunately I can't remember why it happened :-(
       it 'handles "couldn\'t find symbol" runtime linker error' do
-        in_stream  = ::File.open(run_file["runtime-linker-couldn't-find-symbol.error"])
-        repl.instance_variable_set(:@running, true)
+        in_stream  = ::File.open(asset["failed/runtime-linker-couldn't-find-symbol.err"])
+        repl.instance_variable_set(:@listening, 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)
+        expect(repl.instance_variable_get(:@listening)).to eq(false)
+        expect(repl.instance_variable_get(:@status)).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)
+        in_stream  = ::File.open(asset["failed/runtime-linker-cannot-find-object-file.err"])
+        repl.instance_variable_set(:@listening, 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)
+        expect(repl.instance_variable_get(:@listening)).to eq(false)
+        expect(repl.instance_variable_get(:@status)).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)
+        in_stream  = ::File.open(asset["failed/exception.err"])
+        repl.instance_variable_set(:@listening, 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)
+        expect(repl.instance_variable_get(:@listening)).to eq(false)
+        expect(repl.instance_variable_get(:@status)).to eq(:compile_failure)
       end
 
       it "handles CPP exceptions" do
-        in_stream  = ::File.open(run_file["cpp-exception.error"])
-        repl.instance_variable_set(:@running, true)
+        in_stream  = ::File.open(asset["failed/phase-c-pre-processor-failed.err"])
+        repl.instance_variable_set(:@listening, 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)
+        expect(repl.instance_variable_get(:@listening)).to eq(false)
+        expect(repl.instance_variable_get(:@status)).to eq(:compile_failure)
       end
 
       it "handles preprocessor phase failures" do
-        in_stream  = ::File.open(run_file["preprocessor-phase-failed.error"])
-        repl.instance_variable_set(:@running, true)
+        in_stream  = ::File.open(asset["failed/phase-haskell-pre-processor-failed.err"])
+        repl.instance_variable_set(:@listening, 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)
+        expect(repl.instance_variable_get(:@listening)).to eq(false)
+        expect(repl.instance_variable_get(:@status)).to eq(:compile_failure)
       end
 
       it "handles missing preprocessor error" do
-        in_stream  = ::File.open(run_file["missing-preprocessor.error"])
-        repl.instance_variable_set(:@running, true)
+        in_stream  = ::File.open(asset["failed/invalid-preprocessor.err"])
+        repl.instance_variable_set(:@listening, 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)
+        expect(repl.instance_variable_get(:@listening)).to eq(false)
+        expect(repl.instance_variable_get(:@status)).to eq(:compile_failure)
       end
-    end
-  end
-
-  describe "#lookup_sandbox" do
-    include FakeFS::SpecHelpers
 
-    before(:each) { ::IO.any_instance.stub(:puts) }
+      it "handles linker phase failures" do
+        in_stream  = ::File.open(asset["failed/phase-linker-failed.err"])
+        repl.instance_variable_set(:@listening, true)
 
-    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
+        repl.send(:listen, in_stream, dev_null)
 
-    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")
+        expect(repl.instance_variable_get(:@listening)).to eq(false)
+        expect(repl.instance_variable_get(:@status)).to eq(:compile_failure)
+      end
     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

@@ -3,31 +3,21 @@ require 'guard/notifier'
 
 describe "monkey patching" do
   describe ::String do
-    describe "#strip_lowercase_directories" do
-      it "works on empty string" do
-        expect("".strip_lowercase_directories).to eq("")
+    describe "#to_module_name" do
+      it "converts the empty string to the empty module name" do
+        expect("".to_module_name).to eq("")
       end
 
-      it "works on string without lowercase directory prefixes" do
-        expect("Foo".strip_lowercase_directories).to eq("Foo")
+      it "is identity for very simple module paths" do
+        expect("Foo".to_module_name).to eq("Foo")
       end
 
-      it "works on string with lowercase directory prefix" do
-        expect("foo/Bar".strip_lowercase_directories).to eq("Bar")
+      it "drops lowercase directory prefixes and substitutes / with ." do
+        expect("foo/bar/Qux/Quux".to_module_name).to eq("Qux.Quux")
       end
 
-      it "works on string with multiple lowercase directory prefixes" do
-        expect("foo/bar/Baz".strip_lowercase_directories).to eq("Baz")
-      end
-    end
-
-    describe "#path_to_module_name" do
-      it "works on string without path separators" do
-        expect("Foo".path_to_module_name).to eq("Foo")
-      end
-
-      it "works on string with path separators" do
-        expect("Foo/Bar/Baz".path_to_module_name).to eq("Foo.Bar.Baz")
+      it "does not deal with extensions in the path" do
+        expect("foo/bar/Qux/Quux.hs".to_module_name).to eq("Qux.Quux.hs")
       end
     end
   end
@@ -36,6 +26,10 @@ end
 class ::Guard::Haskell::Repl
   def initialize(*args)
   end
+
+  def status
+    :success
+  end
 end
 
 describe ::Guard::Haskell do
@@ -56,14 +50,19 @@ describe ::Guard::Haskell do
 
   describe "#start" do
     it "starts repl" do
-      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:init).with("test/Spec.hs")
+      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:initialize).with("spec", [])
+
+      guard.start
+    end
+
+    it "checks the repl has been loaded successfully" do
+      expect(guard).to receive(:success?)
 
       guard.start
     end
 
     it "does not run all examples on start by default" do
       expect(guard).not_to receive(:run_all)
-      expect(guard).not_to receive(:success?)
 
       guard.start
     end
@@ -72,15 +71,23 @@ describe ::Guard::Haskell do
       custom_guard = ::Guard::Haskell.new(all_on_start: true)
 
       expect_any_instance_of(::Guard::Haskell::Repl).to receive(:reload_and_run_matching).with(no_args)
-      expect(custom_guard).to receive(:success?)
+      expect(custom_guard).to receive(:success?).twice
 
       custom_guard.start
     end
 
-    it "starts repl with custom spec specified with :top_spec option" do
-      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:init).with("test/CustomSpec.hs")
+    it "starts repl with custom target specified with :cabal_target option" do
+      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:initialize).with("not-spec", [])
 
-      custom_guard = ::Guard::Haskell.new(top_spec: "test/CustomSpec.hs")
+      custom_guard = ::Guard::Haskell.new(cabal_target: "not-spec")
+      custom_guard.start
+    end
+
+    it "starts repl with custom options specified with :repl_options option" do
+      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:initialize)
+        .with("spec", ["--ghc-options=-Werror"])
+
+      custom_guard = ::Guard::Haskell.new(repl_options: ["--ghc-options=-Werror"])
       custom_guard.start
     end
   end
@@ -105,10 +112,10 @@ describe ::Guard::Haskell do
   describe "#run" do
     it "checks success after run" do
       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)
-
       guard.start
+
+      expect(guard).to receive(:success?)
       guard.run("Foo")
     end
 
@@ -152,20 +159,20 @@ describe ::Guard::Haskell do
   describe "#run_all" do
     it "checks success after run" do
       expect_any_instance_of(::Guard::Haskell::Repl).to receive(:reload_and_run_matching)
-      expect(guard).to receive(:success?)
-
       guard.start
+
+      expect(guard).to receive(:success?)
       guard.run_all
     end
   end
 
   describe "#success" do
     def notify(before, received, after)
-      ::Guard::Haskell::Repl.any_instance.stub(:result) { received }
-      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:result)
+      guard.start
+      ::Guard::Haskell::Repl.any_instance.stub(:status) { received }
+      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:status)
       yield
 
-      guard.start
       guard.instance_variable_set(:@last_run, before)
       guard.success?
       expect(guard.instance_variable_get(:@last_run)).to eq(after)
@@ -235,7 +242,7 @@ describe ::Guard::Haskell do
     end
 
     it "runs all examples on success after runtime failure with :all_on_pass option" do
-      ::Guard::Haskell::Repl.any_instance.stub(:result) { :success }
+      ::Guard::Haskell::Repl.any_instance.stub(:status) { :success }
       custom_guard = ::Guard::Haskell.new(all_on_pass: true)
       expect(custom_guard).to receive(:run_all)
 
@@ -245,7 +252,7 @@ describe ::Guard::Haskell do
     end
 
     it "runs all examples on success after compile time failure with :all_on_pass option" do
-      ::Guard::Haskell::Repl.any_instance.stub(:result) { :success }
+      ::Guard::Haskell::Repl.any_instance.stub(:status) { :success }
       custom_guard = ::Guard::Haskell.new(all_on_pass: true)
       expect(custom_guard).to receive(:run_all)
 
@@ -255,28 +262,14 @@ describe ::Guard::Haskell do
     end
   end
 
-  describe "#run_on_additions" do
-    it "reinitializes the repl on new files" do
-      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:init).twice
-
-      guard.start
-      guard.instance_variable_set(:@targets, [])
-      guard.run_on_additions ["foo", "bar"]
-    end
-
-    it "does not reinitialize the repl if new files were seen before" do
-      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:init).once
-
-      guard.start
-      guard.instance_variable_set(:@targets, ["foo", "bar"])
-      guard.run_on_additions ["foo", "bar"]
+  describe "#run_on_modifications" do
+    before :each do
+      ::Guard::Haskell::Repl.any_instance.stub(:status) { :success }
     end
-  end
 
-  describe "#run_on_modifications" do
     it "run examples for simple haskell files" do
       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)
+      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:status)
 
       guard.start
       guard.run_on_modifications(["Foo.hs"])
@@ -284,7 +277,7 @@ describe ::Guard::Haskell do
 
     it "run examples for simple literate haskell files" do
       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)
+      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:status)
 
       guard.start
       guard.run_on_modifications(["Foo.lhs"])
@@ -292,7 +285,7 @@ describe ::Guard::Haskell do
 
     it "run examples for *complex* haskell files" do
       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)
+      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:status)
 
       guard.start
       guard.run_on_modifications(["foo/Bar/Baz.hs"])
@@ -300,7 +293,7 @@ describe ::Guard::Haskell do
 
     it "run examples for simple haskell spec files" do
       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)
+      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:status)
 
       guard.start
       guard.run_on_modifications(["FooSpec.hs"])
@@ -308,7 +301,7 @@ describe ::Guard::Haskell do
 
     it "run examples for simple literate haskell spec files" do
       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)
+      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:status)
 
       guard.start
       guard.run_on_modifications(["FooSpec.lhs"])
@@ -316,10 +309,28 @@ describe ::Guard::Haskell do
 
     it "run examples for *complex* haskell spec files" do
       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)
+      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:status)
 
       guard.start
       guard.run_on_modifications(["foo/Bar/BazSpec.hs"])
     end
   end
+
+  describe "#run_on_additions" do
+    it "reinitializes the repl on new files" do
+      expect_any_instance_of(::Guard::Haskell).to receive(:reload).once
+
+      guard.start
+      guard.instance_variable_set(:@targets, [])
+      guard.run_on_additions(["foo", "bar"])
+    end
+
+    it "does not reinitialize the repl if new files were seen before" do
+      expect_any_instance_of(::Guard::Haskell).not_to receive(:reload).once
+
+      guard.start
+      guard.instance_variable_set(:@targets, ["foo", "bar"])
+      guard.run_on_additions(["foo", "bar"])
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: guard-haskell
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Matvey Aksenov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-15 00:00:00.000000000 Z
+date: 2014-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: guard
@@ -108,6 +108,16 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- asset/failed/exception.err
+- asset/failed/invalid-preprocessor.err
+- asset/failed/phase-c-pre-processor-failed.err
+- asset/failed/phase-haskell-pre-processor-failed.err
+- asset/failed/phase-linker-failed.err
+- asset/failed/runtime-linker-cannot-find-object-file.err
+- asset/failed/runtime-linker-couldn't-find-symbol.err
+- asset/failed/runtime-linker-duplicate-definition-for-symbol.err
+- asset/failed/spec-failure.err
+- asset/passed/spec-pass.ok
 - guard-haskell.gemspec
 - lib/guard/haskell.rb
 - lib/guard/haskell/repl.rb
@@ -115,15 +125,6 @@ files:
 - lib/guard/haskell/version.rb
 - spec/guard/haskell/repl_spec.rb
 - spec/guard/haskell_spec.rb
-- spec/run-files/cpp-exception.error
-- spec/run-files/hspec-exception.error
-- spec/run-files/missing-preprocessor.error
-- spec/run-files/preprocessor-phase-failed.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
-- spec/run-files/spec-pass.success
 - spec/spec_helper.rb
 homepage: https://github.com/supki/guard-haskell#readme
 licenses:
@@ -152,13 +153,4 @@ summary: Guard gem for Haskell
 test_files:
 - spec/guard/haskell/repl_spec.rb
 - spec/guard/haskell_spec.rb
-- spec/run-files/cpp-exception.error
-- spec/run-files/hspec-exception.error
-- spec/run-files/missing-preprocessor.error
-- spec/run-files/preprocessor-phase-failed.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
-- spec/run-files/spec-pass.success
 - spec/spec_helper.rb