guard-haskell 1.0.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MmZhYzE5OTQ2MTEyZDZhYzMzNTAyNWFlOWIzNTU3ODAzZmU5ZGE2ZQ==
+  data.tar.gz: !binary |-
+    YTJiMDZhMTg4NGIzY2IyZDhhODBjMjRjYTBlYzBhMDVjOTQ5NTUyNQ==
+SHA512:
+  metadata.gz: !binary |-
+    OGI4NjEzNTc5MmJmMGNmYmQ2MjBkN2Q1MWI0NDkxZTJiZTc3NDFjNDZmMmU3
+    ZmMxMGZhZTFlZDBkZjA0MTk0ZWNjMjY1OWQ3NTAwYWFiMTRlNWIzZGQ1Y2Q3
+    ZDE3ZGIzODFjMWIwMjBjYTBjZjM0NTg1NzQyZTk4MWNmNzU1ODU=
+  data.tar.gz: !binary |-
+    ZDIwNDFkZjc1Yzc1YTkyZGE0NmU5MWIwMDJmZDE4ODRhZWRjOTliZWFjOTVh
+    YjFkYWVhMjZlNTgwYjI0MTg5ZDIwMWQ5NWIzYzE5NTI0MDZlMzAwYWJmZjdk
+    YWIyNmYyNDc3MjZmNWJjNTk1Zjc0OGRiNmM5NDhiOWYwNDQ1NGY=

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+    - 1.9.3
+    - 2.0.0
+    - ruby-head
+matrix:
+    allow_failures:
+        - rvm: ruby-head

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2013, Matvey B. Aksenov
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice, this
+  list of conditions and the following disclaimer in the documentation and/or
+  other materials provided with the distribution.
+
+* Neither the name of the {organization} nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,82 @@
+guard-haskell
+=============
+[![Gem Version](https://badge.fury.io/rb/guard-haskell.png)](http://badge.fury.io/rb/guard-haskell)
+[![Build Status](https://secure.travis-ci.org/supki/guard-haskell.png?branch=master)](http://travis-ci.org/supki/guard-haskell)
+[![Dependencies Status](https://gemnasium.com/supki/guard-haskell.png)](https://gemnasium.com/supki/guard-haskell)
+
+
+`Guard::Haskell` automatically runs your specs
+
+# Install
+
+```shell
+% cabal install hspec
+% gem install guard
+% git clone https://github.com/supki/guard-haskell
+% cd guard-haskell
+% gem build guard-haskell.gemspec
+% gem install guard-haskell-0.1.0.0.gem
+```
+
+# Usage
+
+## 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 their success, so it makes some assumptions about your code style:
+
+  * `hspec` is your testing framework and
+
+  * [`hspec-discover`][2] (or similar tool) organizes your specs,
+  i.e. there is a "top" spec (usually `test/Spec.hs`) that pulls others in
+
+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.
+
+## Guardfile examples
+
+Typical haskell project:
+
+```ruby
+guard :haskell do
+  watch(%r{.*\.cabal$})
+  watch(%r{test/.+Spec.l?hs$})
+  watch(%r{src/.+.l?hs$})
+end
+```
+
+Customized haskell project:
+
+```ruby
+guard :haskell, all_on_pass: true, ghci_options: ["-DTEST"] do
+  watch(%r{.*\.cabal$})
+  watch(%r{test/.+Spec.l?hs$})
+  watch(%r{lib/.+.l?hs$})
+  watch(%r{bin/.+.l?hs$})
+end
+```
+
+## Options
+
+`Guard::Haskell` has a bunch of options:
+
+### `all_on_start`
+
+Run all specs on start (default: `false`).
+
+### `all_on_pass`
+
+Run all specs after previously failing spec _finally_ passes (default: `false`).
+
+### `ghci_options`
+
+Pass custom ghci options, for example, `-XCPP` directives like `-DTEST` (default: `[]`).
+
+### `top_spec`
+
+"Top" spec location (default: `test/Spec.hs`).
+
+  [0]: https://github.com/guard/guard#readme
+  [1]: http://hspec.github.io/
+  [2]: http://hspec.github.io/hspec-discover.html

data/Rakefile

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+require "bundler/gem_tasks"
+require "bundler/version"
+require 'rspec/core/rake_task'
+
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/guard-haskell.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'guard/haskell/version'
+
+Gem::Specification.new do |s|
+  s.name = 'guard-haskell'
+  s.version = Guard::HaskellVersion::VERSION
+  s.author = 'Matvey Aksenov'
+  s.email = 'matvey.aksenov@gmail.com'
+  s.summary = 'Guard gem for Haskell'
+  s.description = 'Guard::Haskell automatically runs your specs'
+  s.homepage = 'https://github.com/supki/guard-haskell#readme'
+  s.license = 'BSD3'
+
+  s.files = `git ls-files`.split($/)
+  s.test_files = s.files.grep(%r{^spec/})
+  s.require_path = 'lib'
+
+  s.add_dependency 'guard', '>= 2.1.1'
+  s.add_development_dependency 'bundler', '>= 1.3.5'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
+end

data/lib/guard/haskell.rb

@@ -0,0 +1,102 @@
+require 'bundler/setup'
+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(/\//, ".")
+  end
+end
+
+module ::Guard
+  class Haskell < ::Guard::Plugin
+
+    require 'guard/haskell/repl'
+
+    attr_reader :repl, :top_spec, :ghci_options, :targets
+    attr_reader :all_on_start, :all_on_pass
+
+    def initialize 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
+    end
+
+    def start
+      repl.start(ghci_options)
+      repl.init(top_spec)
+
+      @targets = ::Set.new(::Dir.glob("**/*.{hs,lhs}"))
+
+      if all_on_start
+        run_all
+        success?
+      end
+    end
+
+    def stop
+      repl.exit
+    end
+
+    def reload
+      stop
+      start
+    end
+
+    def run_all
+      repl.run
+    end
+
+    def run pattern
+      if @last_run == :success
+        repl.run(pattern)
+      else
+        repl.rerun
+      end
+    end
+
+    def success?
+      if repl.success?
+        if @last_run == :failure
+          @last_run = :success
+          if all_on_pass
+            run_all
+            success?
+          end
+        end
+        Notifier.notify('Success')
+      else
+        @last_run = :failure
+        Notifier.notify('Failure', image: :failed)
+      end
+    end
+
+    def run_on_additions paths
+      unless paths.all? { |path| targets.include? path }
+        @targets += paths
+        repl.init(top_spec)
+      end
+    end
+
+    def run_on_modifications paths
+      case paths.first
+      when /(.+)Spec\.l?hs$/, /(.+)\.l?hs$/
+        run($1.strip_lowercase_directories.path_to_module_name)
+        success?
+      end
+    end
+  end
+end

data/lib/guard/haskell/repl.rb

@@ -0,0 +1,71 @@
+require 'io/wait'
+require 'open3'
+
+class ::Guard::Haskell::Repl
+  attr_reader :stdin, :reader, :thread, :success
+
+  def start ghci_options
+    cmd = ["ghci"]
+    Dir["*"].each { |x| cmd << "-i#{x}" }
+    sandbox = ::Dir[".cabal-sandbox/*packages.conf.d"].first
+    cmd << "-package-db=#{sandbox}" if sandbox
+    cmd.concat(ghci_options)
+
+    @stdin, stdout, @thread = ::Open3.popen2e(*cmd)
+    @reader = ::Thread.new do
+      loop do
+        n = stdout.nread
+        if n > 0
+          out = stdout.read(n)
+          print out
+          if @running
+            case out
+            when /\d+ examples?, 0 failures/
+              @success = true
+              @running = false
+            when /\d+ examples?, \d+ failures?/,
+                 /Failed, modules loaded:/,
+                 /\*{3} Exception:/,
+                 /phase `C preprocessor' failed/
+              @success = false
+              @running = false
+            end
+          end
+        else
+          sleep(0.1)
+        end
+      end
+    end
+  end
+
+  def init spec
+    _repl ":load #{spec}\n"
+  end
+
+  def exit
+    ::Process::kill "TERM", thread.pid
+    ::Thread.kill(reader)
+  end
+
+  def run pattern = nil
+    if pattern.nil?
+      _repl ":reload\n:main --color\n"
+    else
+      _repl ":reload\n:main --color --match #{pattern}\n"
+    end
+  end
+
+  def rerun
+    _repl ":reload\n:main --color --rerun\n"
+  end
+
+  def success?
+    while @running do sleep(0.01) end
+    @success
+  end
+
+  def _repl command
+    @running = true
+    stdin.write command
+  end
+end

data/lib/guard/haskell/version.rb

@@ -0,0 +1,5 @@
+module Guard
+  module HaskellVersion
+    VERSION = '1.0.0'
+  end
+end

data/spec/haskell_spec.rb

@@ -0,0 +1,243 @@
+require 'spec_helper'
+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("")
+      end
+
+      it "works on string without lowercase directory prefixes" do
+        expect("Foo".strip_lowercase_directories).to eq("Foo")
+      end
+
+      it "works on string with lowercase directory prefix" do
+        expect("foo/Bar".strip_lowercase_directories).to eq("Bar")
+      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")
+      end
+    end
+  end
+end
+
+describe ::Guard::Haskell do
+  let(:guard) do
+    ::Guard::Haskell.new
+  end
+
+  before :each do
+    ::Guard.stub(:add_group)
+    ::Guard::Haskell::Repl.any_instance.stub(:start)
+    ::Guard::Haskell::Repl.any_instance.stub(:init)
+  end
+
+  describe ".initialize" do
+    it "has :all_on_start option" do
+      expect(guard.instance_variable_defined?(:@all_on_start)).to be_true
+    end
+
+    it "has :all_on_pass option" do
+      expect(guard.instance_variable_defined?(:@all_on_pass)).to be_true
+    end
+
+    it "has :ghci_options option" do
+      expect(guard.instance_variable_defined?(:@ghci_options)).to be_true
+    end
+
+    it "has :top_spec option" do
+      expect(guard.instance_variable_defined?(:@top_spec)).to be_true
+    end
+  end
+
+  describe "#start" do
+    it "starts repl" do
+      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:init).with("test/Spec.hs")
+
+      guard.start
+    end
+
+    it "does not run all specs 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
+      custom_guard = ::Guard::Haskell.new(all_on_start: true)
+
+      expect(custom_guard).to receive(:run_all)
+      expect(custom_guard).to receive(:success?)
+
+      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")
+
+      custom_guard = ::Guard::Haskell.new(top_spec: "test/CustomSpec.hs")
+      custom_guard.start
+    end
+  end
+
+  describe "#stop" do
+    it "stops repl" do
+      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:exit)
+
+      guard.start
+      guard.stop
+    end
+  end
+
+  describe "#reload" do
+    it "restarts repl" do
+      expect(guard).to receive(:stop)
+      expect(guard).to receive(:start)
+      guard.reload
+    end
+  end
+
+  describe "#run" do
+    it "runs specs 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)
+
+      guard.start
+      guard.run("Foo")
+    end
+
+    it "reruns previous specs if last run was a failure" do
+      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:rerun)
+      guard.instance_variable_set(:@last_run, :failure)
+
+      guard.start
+      guard.run("Foo")
+    end
+  end
+
+  describe "#success" do
+    it "notifies on success" do
+      ::Guard::Haskell::Repl.any_instance.stub(:success?) { true }
+      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:success?)
+      expect(::Guard::Notifier).to receive(:notify).with('Success')
+      guard.instance_variable_set(:@last_run, :failure)
+
+      guard.start
+      guard.success?
+      expect(guard.instance_variable_get(:@last_run)).to eq(:success)
+    end
+
+    it "notifies on failure" do
+      ::Guard::Haskell::Repl.any_instance.stub(:success?) { false }
+      expect_any_instance_of(::Guard::Haskell::Repl).to receive(:success?)
+      expect(::Guard::Notifier).to receive(:notify).with('Failure', image: :failed)
+      guard.instance_variable_set(:@last_run, :success)
+
+      guard.start
+      guard.success?
+      expect(guard.instance_variable_get(:@last_run)).to eq(:failure)
+    end
+
+    it "does not run all specs on success after failure by default" do
+      ::Guard::Haskell::Repl.any_instance.stub(:success?) { true }
+      guard.instance_variable_set(:@last_run, :failure)
+
+      expect(guard).not_to receive(:run_all)
+
+      guard.start
+      guard.success?
+    end
+
+    it "runs all specs on success after failure with :all_on_pass option" do
+      ::Guard::Haskell::Repl.any_instance.stub(:success?) { true }
+      custom_guard = ::Guard::Haskell.new(all_on_pass: true)
+      custom_guard.instance_variable_set(:@last_run, :failure)
+
+      expect(custom_guard).to receive(:run_all)
+
+      custom_guard.start
+      custom_guard.success?
+    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"]
+    end
+  end
+
+  describe "#run_on_modifications" do
+    it "run specs 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(:success?)
+
+      guard.start
+      guard.run_on_modifications(["Foo.hs"])
+    end
+
+    it "run specs 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(:success?)
+
+      guard.start
+      guard.run_on_modifications(["Foo.lhs"])
+    end
+
+    it "run specs 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(:success?)
+
+      guard.start
+      guard.run_on_modifications(["foo/Bar/Baz.hs"])
+    end
+
+    it "run specs 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(:success?)
+
+      guard.start
+      guard.run_on_modifications(["FooSpec.hs"])
+    end
+
+    it "run specs 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(:success?)
+
+      guard.start
+      guard.run_on_modifications(["FooSpec.lhs"])
+    end
+
+    it "run specs 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(:success?)
+
+      guard.start
+      guard.run_on_modifications(["foo/Bar/BazSpec.hs"])
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'rspec'
+require 'guard/haskell'
+
+RSpec.configure do |c|
+  c.color = true
+  c.order = :random
+  c.expect_with :rspec do |r|
+    r.syntax = :expect
+  end
+  c.warnings = true
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: guard-haskell
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Matvey Aksenov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.1.1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.3.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.3.5
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- guard-haskell.gemspec
+- lib/guard/haskell.rb
+- lib/guard/haskell/repl.rb
+- lib/guard/haskell/version.rb
+- spec/haskell_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/supki/guard-haskell#readme
+licenses:
+- BSD3
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: Guard gem for Haskell
+test_files:
+- spec/haskell_spec.rb
+- spec/spec_helper.rb