guard-haskell 1.2.0 → 1.3.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NmQxYWQ2YzZiMmUwOGY3YTMzNjIzM2IyYTNjNjcxODk5ZGMyYzFlMQ==
+    M2MzMTgzOGIwYWRkNTkyYmNmYzBiNGM4YmEwMDA0Mzk2YTgxYmUzZQ==
   data.tar.gz: !binary |-
-    YjEzZjFmZjk3ZWUyNTA4Yjc3MDkwOTgwZTJjNzQ1YzViYjU3NWMyNw==
+    NmQxZTYxM2NkNDgyZGUzNDFiZTc1YjdkOTMzZjg4OTk5N2MyNmZmMg==
 SHA512:
   metadata.gz: !binary |-
-    OTE2OTEzZWNjMmZmZjllNTEzMDBlMWMwNmJiYTFmOGMzOGU0NDc2MjNjOWRh
-    YjQ2MjI0NjkwODNjMDZiMWNkYTRlNzE2MjhiODkyMDBjMTE3OGI3ZGY1MDQ1
-    YWQ2NjU1ZjFiZjAwOWFhNTVmNjFjNjhhYWQ3NTQ4NTkzNmM2ZGQ=
+    Y2M2ZTc4ODU1NWRhNWI1MTUzOThhYjQ4NzFhNmEyZDc1NWIzMDhhYmQ0NWJi
+    MmNkNDAzYmQ0MmIxMDhkNWUyZTMxMjAwZTk1NjQyMmQzZGRmZmM4NTU2ZGQ3
+    YWU2MzgzODkyYmE1NTBjZWE0OTYzODhkYWJiMzZiMzU0MjBhMjg=
   data.tar.gz: !binary |-
-    ZDljODRhOGVmZTYzZjcwNjlhOWUxODcxZDM2ZDliNGE1MjM4YTJmODA0ZDUx
-    MTY2NTQ1MzdlNjM2NjBmY2Y3NWM3OGI4ZWM1ZGQxNTNhYjgzOGEzNDE3MWY3
-    MjY3NDM4MTFjMTQ1YzMxN2IyMzBlMTVmMzMyYzc5NDc1MDU4ODI=
+    YTc3MWI3NjcwYTllNTVmOTBmMTc0ZThiYTZjMTI1YWE5ZTM1ODIxZTA5N2U2
+    ZjU4MTZjMzg5M2QzMWY0ZTNiZmE3YTQ3ZTQ0NDNlOTQ1ZmQ4ZDM3Y2NmYTM2
+    MzVhYjlmZmU4NGZlMzUwMjJkNmViNTdlMTgwMDg0NTRlODIxZTE=

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+1.3.0
+=====
+
+  * Ignore user cabal package database if sandbox is found
+  * Catch CPP failures (previously did n'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

@@ -20,7 +20,7 @@ guard-haskell
 
 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 their success, 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 style:
 
   * `hspec` is your testing framework and
 
@@ -57,11 +57,15 @@ end
 
 ### `all_on_start`
 
-Run all specs on start (default: `false`).
+Run all examples on start (default: `false`).
 
 ### `all_on_pass`
 
-Run all specs after previously failing spec _finally_ passes (default: `false`).
+Run all examples after previously failing spec _finally_ passes (default: `false`).
+
+### `focus_on_fail`
+
+Rerun only failed examples until they pass (default: `true`).
 
 ### `ghci_options`
 

data/lib/guard/haskell.rb

@@ -23,16 +23,29 @@ module ::Guard
     require 'guard/haskell/repl'
 
     attr_reader :repl, :top_spec, :ghci_options, :targets, :last_run
-    attr_reader :all_on_start, :all_on_pass
+    attr_reader :all_on_start, :all_on_pass, :focus_on_fail
 
-    def initialize options = {}
+    DEFAULT_OPTIONS = {
+      top_spec:      "test/Spec.hs",
+      ghci_options:  [],
+      all_on_start:  false,
+      all_on_pass:   false,
+      focus_on_fail: true,
+    }
+
+    def initialize(user_options = {})
       super
-      @last_run     = :success # try to prove it wasn't :-)
-      @top_spec     = options[:top_spec] || "test/Spec.hs"
-      @ghci_options = options[:ghci_options] || []
-      @all_on_start = options[:all_on_start] || false
-      @all_on_pass  = options[:all_on_pass] || false
-      @repl         = Repl.new
+
+      @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
     end
 
     def start
@@ -61,7 +74,7 @@ module ::Guard
     end
 
     def run pattern
-      if last_run == :runtime_failure
+      if focus_on_fail and last_run == :runtime_failure
         repl.rerun
       else
         repl.run(pattern)

data/lib/guard/haskell/repl.rb

@@ -1,65 +1,57 @@
 require 'open3'
 
 class ::Guard::Haskell::Repl
-  attr_reader :stdin, :reader, :thread, :result
+  attr_reader :stdin, :listener, :thread, :result
 
   def initialize
     @running = false
     @result  = :success
   end
 
+  def self.test(str)
+    case str
+    when /\d+ examples?, 0 failures/
+      :success
+    when /\d+ examples?, \d+ failures?/
+      :runtime_failure
+    when /Failed, modules loaded:/,
+         /\*{3} Exception:/,
+         /phase `C pre-processor' failed/,
+         /GHCi runtime linker: fatal error:/
+      :compile_failure
+    end
+  end
+
   def start ghci_options
     cmd = ["ghci"]
     Dir["*"].each { |d| cmd << "-i#{d}" if File.directory?(d) }
     sandbox = ::Dir[".cabal-sandbox/*packages.conf.d"].first
-    cmd << "-package-db=#{sandbox}" if sandbox
+    cmd.concat(["-no-user-package-db", "-package-db=#{sandbox}"]) if sandbox
     cmd.concat(ghci_options)
 
     @stdin, stdout, @thread = ::Open3.popen2e(*cmd)
-    @reader = ::Thread.new do
-      loop do
-        while (out = stdout.gets)
-          print out
-          if @running
-            case out
-            when /\d+ examples?, 0 failures/
-              @result  = :success
-              @running = false
-            when /\d+ examples?, \d+ failures?/
-              @result  = :runtime_failure
-              @running = false
-            when /Failed, modules loaded:/,
-                 /\*{3} Exception:/,
-                 /phase `C preprocessor' failed/,
-                 /^GHCi runtime linker: fatal error:/
-              @result  = :compile_failure
-              @running = false
-            end
-          end
-        end
-      end
-    end
+    @listener = ::Thread.new { listen(stdout, STDOUT) }
   end
 
-  def init spec
-    _repl ":load #{spec}\n"
+  def init(spec)
+    repl(":load #{spec}\n")
   end
 
   def exit
-    ::Process::kill "TERM", thread.pid
-    ::Thread.kill(reader)
+    ::Process::kill("TERM", thread.pid)
+    ::Thread.kill(listener)
   end
 
-  def run pattern = nil
+  def run(pattern = nil)
     if pattern.nil?
-      _repl ":reload\n:main --color\n"
+      repl(":reload\n:main --color\n")
     else
-      _repl ":reload\n:main --color --match #{pattern}\n"
+      repl(":reload\n:main --color --match #{pattern}\n")
     end
   end
 
   def rerun
-    _repl ":reload\n:main --color --rerun\n"
+    repl(":reload\n:main --color --rerun\n")
   end
 
   def result
@@ -67,8 +59,24 @@ class ::Guard::Haskell::Repl
     @result
   end
 
-  def _repl command
-    @running = true
-    stdin.write command
-  end
+  private
+
+    def repl(command)
+      @running = true
+      stdin.write(command)
+    end
+
+    def listen(in_stream, out_stream)
+      while (str = in_stream.gets)
+        out_stream.print(str)
+        if @running
+          res = self.class.test(str)
+          case res
+          when :success, :runtime_failure, :compile_failure
+            @result  = res
+            @running = false
+          end
+        end
+      end
+    end
 end

data/lib/guard/haskell/version.rb

@@ -1,5 +1,5 @@
 module Guard
   module HaskellVersion
-    VERSION = '1.2.0'
+    VERSION = '1.3.0'
   end
 end

data/spec/guard/haskell/repl_spec.rb

@@ -0,0 +1,195 @@
+require 'spec_helper'
+require 'guard/notifier'
+
+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(:repl).with(/:load/)
+      repl.init("Spec.hs")
+    end
+
+    it "loads provided spec" do
+      expect(repl).to receive(:repl).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
+    end
+
+    it "reloads the spec if a pattern is provided" do
+      expect(repl).to receive(:repl).with(/:reload/)
+      repl.run("FooBar")
+    end
+
+    it "provides a pattern for spec to match" do
+      expect(repl).to receive(:repl).with(/--match FooBar/)
+      repl.run("FooBar")
+    end
+  end
+
+  describe '#rerun' do
+    it "reloads the spec" do
+      expect(repl).to receive(:repl).with(/:reload/)
+      repl.rerun
+    end
+
+    it "reruns the spec" do
+      expect(repl).to receive(:repl).with(/--rerun/)
+      repl.rerun
+    end
+  end
+
+  describe '#test' do
+    it "handles zero examples/failures" do
+      expect(::Guard::Haskell::Repl.test("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)
+    end
+
+    it "handles multiple examples/zero failures" do
+      expect(::Guard::Haskell::Repl.test("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)
+    end
+
+    it "handles multiple examples/multiple failures" do
+      expect(::Guard::Haskell::Repl.test("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)
+    end
+
+    it "handles uncaught exceptions" do
+      expect(::Guard::Haskell::Repl.test("*** 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)
+    end
+
+    it "handles runtime linker errors" do
+      expect(::Guard::Haskell::Repl.test("GHCi runtime linker: fatal error:")).to eq(:compile_failure)
+    end
+  end
+
+  describe '#listen' do
+    context 'real world' do
+      it "handles typical passed run" do
+        in_stream = ::StringIO.open(<<-FOO)
+          Useful.Git
+            fromGraph
+              - creates `git init' script from empty graph
+              - creates git script from two-node graph
+              - creates git script from three-node graph
+              - creates git script from three-node chain graph
+
+          Finished in 0.0054 seconds
+          4 examples, 0 failures
+        FOO
+        out_stream = File.open("/dev/null", "w")
+        repl.instance_variable_set(:@running, true)
+
+        repl.send(:listen, in_stream, out_stream)
+
+        expect(repl.instance_variable_get(:@running)).to eq(false)
+        expect(repl.instance_variable_get(:@result)).to eq(:success)
+      end
+
+      it "handles typical failed spec run" do
+        in_stream = ::StringIO.open(<<-FOO)
+          Useful.Git
+            fromGraph
+              - creates `git init' script from empty graph
+              - creates git script from two-node graph FAILED [1]
+              - creates git script from three-node graph
+              - creates git script from three-node chain graph
+
+          1) Useful.Git.fromGraph creates git script from two-node graph
+          expected: Just [InitE,OrphanE "foo" "7",CommitE "bar" ["1"] "2"]
+           but got: Just [InitE,OrphanE "foo" "1",CommitE "bar" ["1"] "2"]
+
+          Randomized with seed 4611685481380198536
+
+          Finished in 0.0089 seconds
+          4 examples, 1 failure
+          *** Exception: ExitFailure 1
+        FOO
+        out_stream = File.open("/dev/null", "w")
+        repl.instance_variable_set(:@running, true)
+
+        repl.send(:listen, in_stream, out_stream)
+
+        expect(repl.instance_variable_get(:@running)).to eq(false)
+        expect(repl.instance_variable_get(:@result)).to eq(:runtime_failure)
+      end
+
+      it "handles runtime linker error" do
+        in_stream = ::StringIO.open(<<-FOO)
+          GHCi runtime linker: fatal error: I found a duplicate definition for symbol
+             HUnitzm1zi2zi5zi2_TestziHUnitziBase_zdwzdcshowsPrec_slow
+          whilst processing object file
+             /home/maksenov/.cabal/lib/HUnit-1.2.5.2/ghc-7.6.2/HSHUnit-1.2.5.2.o
+          This could be caused by:
+             * Loading two different object files which export the same symbol
+             * Specifying the same object file twice on the GHCi command line
+             * An incorrect `package.conf' entry, causing some object to be
+               loaded twice.
+          GHCi cannot safely continue in this situation.  Exiting now.  Sorry.
+        FOO
+        out_stream = File.open("/dev/null", "w")
+        repl.instance_variable_set(:@running, true)
+
+        repl.send(:listen, in_stream, out_stream)
+
+        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 = ::StringIO.open(<<-FOO)
+          *Main> Ok, modules loaded: Main, Useful.Parser, Useful.Graph, Useful.Git.
+          *Main>
+          *** Exception: Prelude.undefined
+        FOO
+        out_stream = File.open("/dev/null", "w")
+        repl.instance_variable_set(:@running, true)
+
+        repl.send(:listen, in_stream, out_stream)
+
+        expect(repl.instance_variable_get(:@running)).to eq(false)
+        expect(repl.instance_variable_get(:@result)).to eq(:compile_failure)
+      end
+
+      it "handles CPP exceptions" do
+        in_stream = ::StringIO.open(<<-FOO)
+          *Main>
+          test/Useful/GitSpec.hs:4:0:
+               error: invalid preprocessing directive #ifd
+               #ifd
+               ^
+          phase `C pre-processor' failed (exitcode = 1)
+        FOO
+        out_stream = File.open("/dev/null", "w")
+        repl.instance_variable_set(:@running, true)
+
+        repl.send(:listen, in_stream, out_stream)
+
+        expect(repl.instance_variable_get(:@running)).to eq(false)
+        expect(repl.instance_variable_get(:@result)).to eq(:compile_failure)
+      end
+    end
+  end
+end

data/spec/guard/haskell_spec.rb

@@ -46,19 +46,23 @@ describe ::Guard::Haskell do
 
   describe ".initialize" do
     it "has :all_on_start option" do
-      expect(guard.instance_variable_defined?(:@all_on_start)).to be_true
+      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 be_true
+      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 be_true
+      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 be_true
+      expect(guard.instance_variable_defined?(:@top_spec)).to eq(true)
     end
   end
 
@@ -69,14 +73,14 @@ describe ::Guard::Haskell do
       guard.start
     end
 
-    it "does not run all specs on start by default" do
+    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
 
-    it "runs all specs on start with :all_on_start option enabled" 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)
@@ -120,7 +124,7 @@ describe ::Guard::Haskell do
       guard.run("Foo")
     end
 
-    it "runs specs matching pattern if last run was a success" do
+    it "runs examples matching pattern if last run was a success" do
       expect_any_instance_of(::Guard::Haskell::Repl).to receive(:run).with("Foo")
       guard.instance_variable_set(:@last_run, :success)
 
@@ -128,7 +132,7 @@ describe ::Guard::Haskell do
       guard.run("Foo")
     end
 
-    it "runs specs matching pattern if last run was a compile time failure" do
+    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")
       guard.instance_variable_set(:@last_run, :compile_failure)
 
@@ -136,9 +140,21 @@ describe ::Guard::Haskell do
       guard.run("Foo")
     end
 
-    it "reruns previous specs if last run was a runtime failure" do
+    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")
+      guard.instance_variable_set(:@last_run, :runtime_failure)
+      guard.instance_variable_set(:@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")
       guard.instance_variable_set(:@last_run, :runtime_failure)
+      guard.instance_variable_set(:@focus_on_fail, false)
 
       guard.start
       guard.run("Foo")
@@ -232,7 +248,7 @@ describe ::Guard::Haskell do
       guard.success?
     end
 
-    it "runs all specs on success after runtime failure with :all_on_pass option" do
+    it "runs all examples on success after runtime failure with :all_on_pass option" do
       ::Guard::Haskell::Repl.any_instance.stub(:result) { :success }
       custom_guard = ::Guard::Haskell.new(all_on_pass: true)
       custom_guard.instance_variable_set(:@last_run, :runtime_failure)
@@ -243,7 +259,7 @@ describe ::Guard::Haskell do
       custom_guard.success?
     end
 
-    it "runs all specs on success after compile time failure with :all_on_pass option" do
+    it "runs all examples on success after compile time failure with :all_on_pass option" do
       ::Guard::Haskell::Repl.any_instance.stub(:result) { :success }
       custom_guard = ::Guard::Haskell.new(all_on_pass: true)
       custom_guard.instance_variable_set(:@last_run, :compile_failure)
@@ -274,7 +290,7 @@ describe ::Guard::Haskell do
   end
 
   describe "#run_on_modifications" do
-    it "run specs for simple haskell files" 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(:result)
 
@@ -282,7 +298,7 @@ describe ::Guard::Haskell do
       guard.run_on_modifications(["Foo.hs"])
     end
 
-    it "run specs for simple literate haskell files" do
+    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(:result)
 
@@ -290,7 +306,7 @@ describe ::Guard::Haskell do
       guard.run_on_modifications(["Foo.lhs"])
     end
 
-    it "run specs for *complex* haskell files" do
+    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(:result)
 
@@ -298,7 +314,7 @@ describe ::Guard::Haskell do
       guard.run_on_modifications(["foo/Bar/Baz.hs"])
     end
 
-    it "run specs for simple haskell spec files" do
+    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(:result)
 
@@ -306,7 +322,7 @@ describe ::Guard::Haskell do
       guard.run_on_modifications(["FooSpec.hs"])
     end
 
-    it "run specs for simple literate haskell spec files" do
+    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(:result)
 
@@ -314,7 +330,7 @@ describe ::Guard::Haskell do
       guard.run_on_modifications(["FooSpec.lhs"])
     end
 
-    it "run specs for *complex* haskell spec files" do
+    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(:result)
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: guard-haskell
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Matvey Aksenov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-02 00:00:00.000000000 Z
+date: 2014-01-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: guard
@@ -99,6 +99,7 @@ files:
 - lib/guard/haskell/repl.rb
 - lib/guard/haskell/templates/Guardfile
 - lib/guard/haskell/version.rb
+- spec/guard/haskell/repl_spec.rb
 - spec/guard/haskell_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/supki/guard-haskell#readme
@@ -126,5 +127,6 @@ signing_key:
 specification_version: 4
 summary: Guard gem for Haskell
 test_files:
+- spec/guard/haskell/repl_spec.rb
 - spec/guard/haskell_spec.rb
 - spec/spec_helper.rb