guard-mocha-node 0.0.3

data/.gitignore

@@ -0,0 +1,6 @@
+*~
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+/.rvmrc

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in guard-mocha-node.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,6 @@
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/README.md

@@ -0,0 +1,135 @@
+Guard::MochaNode
+==================
+
+This is a fork of the Great work from [Dave Nolan](https://github.com/textgoeshere)
+with his gem [Guard::JasmineNode](https://github.com/guard/guard-jasmine-node).
+Only modified to work with mocha
+
+... and then I stole it from [[https://github.com/kanzeon/guard-mocha-node|kanzeon]], and I'd welcome them taking it back at any point :)
+
+MochaNode guard automatically & intelligently executes mocha node specs when files are modified.
+
+* Tested against Node 0.8.14, mocha 1.6.0
+
+Requirements
+------------
+
+* [Node](http://nodejs.org/)
+* Mocha
+* [Ruby](http://ruby-lang.org) and rubygems
+
+Install
+-------
+
+Install the gem:
+
+    $ gem install guard-mocha-node
+
+Add guard definition to your Guardfile by running this command:
+
+    $ guard init mocha-node
+
+Usage
+-----
+
+    $ guard
+
+This will watch your project and execute your specs when files
+change. It's worth checking out [the docs](https://github.com/guard/guard#readme).
+
+Options
+-------
+
+* `:all_on_start     # default => true`
+
+Run all the specs as soon as Guard is started.
+
+* `:all_after_pass   # default => true`
+
+When files are modified and the specs covering the modified files
+pass, run all the specs automatically.
+
+* `:keep_failed      # default => true`
+
+When files are modified, run failing specs as well as specs covering
+the modified files.
+
+* `:notify           # default => true`
+
+Display growl/libnotify notifications.
+
+* `:coffeescript     # default => true`
+
+Load coffeescript and all execution of .coffee files.
+
+* `:livescript       # default => false`
+
+Load livescript and all execution of .ls files.
+
+* `:reporter         # default => "spec"`
+
+To select a mocha reporter
+
+* `:require          # default => nil`
+
+Make mocha require the given modules, it should be a string or a array
+of strings if multiple modules are to be required
+
+* `:color            # default => true`
+
+Enable or disable the mocha color output
+
+* `:recursive        # default => true`
+
+Enable or disable the recursive directory mocha option
+
+* `:paths_for_all_specs  # default => ['spec']`
+
+Paths for run all specs
+
+* `:globals # default => []`
+
+Globals to ignore when performing global leak detection
+
+* `:mocha_bin`
+
+Specify the path to the jasmine-node binary that will execute your specs.
+
+The default `:mocha_bin` in the Guardfile assumes:
+
+* you are running guard from the root of the project
+* you installed mocha using npm
+* you installed mocha locally to node_modules
+
+If you delete the option completely from the Guardfile, it assumes the
+mocha binary is already in your `$PATH`.
+
+So if you have installed jasmine-node globally using e.g. `npm install
+-g mocha`, remove the `:mocha_bin` option from the Guardfile.
+
+Guardfile
+---------
+
+Please read the [guard docs](https://github.com/guard/guard#readme) for
+more information about the Guardfile DSL.
+
+It's powerful stuff.
+
+
+TODO
+----
+
+* write a JsonFormatter for jasmine-node so we have finer-grained
+  control over rendering output
+* write an RSpec-style progress formatter (aka lots of green dots)
+* patch Guard to locate CamelCased modules correctly
+
+Testing
+-------
+
+    $ rake
+
+Author
+------
+
+[Roberto Huelga Díaz](https://github.com/kanzeon)

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/guard-mocha-node.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "guard/mocha_node/version"
+
+Gem::Specification.new do |s|
+  s.name        = "guard-mocha-node"
+  s.version     = Guard::MochaNodeVersion::VERSION
+  s.authors     = ["dave@kapoq.com", "David Schoen <dave@lyte.id.au>"]
+  s.email       = ["dave@kapoq.com", "dave@lyte.id.au"]
+  s.homepage    = "https://github.com/kanzeon/guard-mocha-node"
+  s.summary     = %q{Guard::MochaNode automatically runs your Mocha Node specs when files are modified}
+  s.description = %q{}
+
+  s.rubyforge_project = "guard-mocha-node"
+
+  s.add_dependency "guard", ">= 0.4"
+
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "guard-rspec"
+  s.add_development_dependency "rake"
+  if RUBY_PLATFORM =~ /linux/
+    s.add_development_dependency "rb-inotify"
+    s.add_development_dependency "libnotify"
+  end
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/guard/mocha-node.rb

@@ -0,0 +1,25 @@
+require 'guard/mocha_node'
+
+Guard::Mochanode = Guard::MochaNode
+
+module Guard
+  class Mochanode < Guard
+    GEM_NAME = "mocha-node"
+
+    # Guardfile template needed inside guard gem
+    def self.init(name)
+      if ::Guard::Dsl.guardfile_include?(GEM_NAME)
+        ::Guard::UI.info "Guardfile already includes #{GEM_NAME} guard"
+      else
+        content = File.read('Guardfile')
+        guard   = File.read("#{::Guard.locate_guard(GEM_NAME)}/lib/guard/mocha_node/templates/Guardfile")
+        File.open('Guardfile', 'wb') do |f|
+          f.puts(content)
+          f.puts("")
+          f.puts(guard)
+        end
+        ::Guard::UI.info "#{name} guard added to Guardfile, feel free to edit it"
+      end
+    end
+  end
+end

data/lib/guard/mocha_node/runner.rb

@@ -0,0 +1,90 @@
+require 'open3'
+require 'guard/ui'
+
+module Guard
+  class MochaNode
+    module Runner
+      def self.run(paths = [], options = {})
+        return false if paths.empty?
+
+        @paths   = paths
+        @options = options
+
+        print_message
+        execute_mocha_node_command
+      end
+
+      private
+
+      def self.print_message
+        message = @options[:message]
+	is_all_specs = @paths.sort == @options[:paths_for_all_specs].sort
+        message ||= is_all_specs ? "Running all specs" : "Running: #{@paths.join(' ')}"
+        ::Guard::UI.info(message, :reset => true)
+      end
+
+      def self.execute_mocha_node_command
+        ::Open3.popen3(*mocha_node_command)
+      end
+
+      def self.mocha_node_command
+        argvs = [ @options[:mocha_bin] ]
+        argvs += command_line_options
+        argvs += @paths
+        argvs.map(&:to_s)
+      end
+
+      def self.command_line_options
+        options = []
+	compilers = []
+
+        if @options[:coffeescript]
+          compilers << "coffee:coffee-script"
+        end
+
+	if @options[:livescript]
+          compilers << "ls:LiveScript"
+        end
+
+	if not compilers.empty?
+	  options << "--compilers"
+	  options << compilers.join(",")
+	end
+
+        if @options[:recursive]
+          options << "--recursive"
+        end
+
+	if @options[:require]
+	  r = @options[:require]
+	  r = [r] if not r.instance_of? Array
+
+	  r.each { |e|
+	    options << "-r"
+	    options << e
+	  }
+	end
+
+        if @options[:color]
+          options << "-c"
+        else
+          options << "-C"
+        end
+
+        if @options[:globals] and not @options[:globals].empty?
+          options << "--globals"
+          options << @options[:globals].join(',')
+        end
+
+        if @options[:reporter]
+          options << "--reporter"
+          options << @options[:reporter]
+        end
+
+	# puts "---- printing the options"
+	# puts options
+        options
+      end
+    end
+  end
+end

data/lib/guard/mocha_node/spec_state.rb

@@ -0,0 +1,73 @@
+module Guard
+  class MochaNode
+    class SpecState
+      STDIN  = 0
+      STDOUT = 1
+      STDERR = 2
+      THREAD = 3
+
+      SUCCESS_CODE = 0
+      ERROR_CODE   = 1
+
+      attr_accessor :failing_paths
+
+      def initialize
+        clear!
+      end
+
+      def update(run_paths = [], options = {})
+        @run_paths = run_paths
+        @io = Runner.run(@run_paths, options)
+        @stdout     = @io[STDOUT]
+        @stderr     = @io[STDERR]
+        # stream stdout immediately
+        until @stdout.eof?
+          line = @stdout.gets
+          print line if !line.strip.empty?
+        end
+        @stderr.lines { |line| print line }
+        @exitstatus = @io[THREAD].value rescue ERROR_CODE
+        close_io
+        update_passed_and_fixed
+        update_failing_paths
+        passing?
+      end
+
+      def passing?
+        @passed
+      end
+
+      def fixed?
+        @fixed
+      end
+
+      def clear!
+        @passed = true
+        @fixed  = false
+        @failing_paths = []
+      end
+
+      private
+
+      def close_io
+        @io[STDIN..STDERR].each { |s| s.close }
+      end
+
+      def update_passed_and_fixed
+        previously_failed = !passing?
+        @passed = @exitstatus == SUCCESS_CODE
+        @fixed  = @passed && previously_failed
+      end
+
+      def update_failing_paths
+        if @run_paths.any?
+          @failing_paths = if passing?
+                             @failing_paths - @run_paths
+                           else
+                             @failing_paths + @run_paths
+                           end.uniq
+        end
+      end
+    end
+  end
+end

data/lib/guard/mocha_node/templates/Guardfile

@@ -0,0 +1,17 @@
+# Installed by guard-mocha-node
+
+# JavaScript/CoffeeScript watchers
+
+guard 'mocha-node', :mocha_bin => File.expand_path(File.dirname(__FILE__) + "/node_modules/mocha/bin/mocha") do
+  watch(%r{^spec/(.+)_spec\.(js\.coffee|js|coffee)})  { |m| "spec/#{m[1]}_spec.#{m[2]}" }
+  watch(%r{^lib/(.+)\.(js\.coffee|js|coffee)})        { |m| "spec/lib/#{m[1]}_spec.#{m[2]}" }
+  watch(%r{spec/spec_helper\.(js\.coffee|js|coffee)}) { "spec" }
+end
+
+# JavaScript only watchers
+#
+# guard "mocha-node", :mocha_bin => File.expand_path(File.dirname(__FILE__) + "/node_modules/mocha/bin/mocha")  do
+#   watch(%r{^spec/.+_spec\.js$})
+#   watch(%r{^lib/(.+)\.js$})     { |m| "spec/lib/#{m[1]}_spec.js" }
+#   watch('spec/spec_helper.js')
+# end

data/lib/guard/mocha_node/version.rb

@@ -0,0 +1,5 @@
+module Guard
+  module MochaNodeVersion
+    VERSION = "0.0.3"
+  end
+end

data/lib/guard/mocha_node.rb

@@ -0,0 +1,88 @@
+require 'guard'
+require 'guard/guard'
+
+module Guard
+  class MochaNode < Guard
+    DEFAULT_OPTIONS = {
+      :mocha_bin        => "mocha",
+      :all_after_pass   => true,
+      :all_on_start     => true,
+      :keep_failed      => true,
+      :notify           => true,
+      :coffeescript     => true,
+      :livescript       => false,
+      :verbose          => true,
+      :reporter         => "spec",
+      :color            => true,
+      :recursive        => true,
+      :require          => nil,
+      :paths_for_all_specs => %w(spec),
+      :globals          => []
+    }
+
+    autoload :Runner,    "guard/mocha_node/runner"
+    autoload :SpecState, "guard/mocha_node/spec_state"
+
+    def initialize(watchers = [], options = {})
+      super(watchers, DEFAULT_OPTIONS.merge(options))
+      @state = SpecState.new
+    end
+
+    def start
+      run_all if options[:all_on_start]
+    end
+
+    def run_all
+      run( options[:paths_for_all_specs])
+      notify(:all)
+    end
+
+    def run_on_change(changed_paths = [])
+      run_paths = if options[:keep_failed]
+                    failing_paths + changed_paths
+                  else
+                    changed_paths
+                  end
+
+      run(run_paths)
+      notify(:some)
+
+      run_all if passing? and options[:all_after_pass]
+    end
+
+    def failing_paths
+      @state.failing_paths
+     end
+
+    def passing?
+      @state.passing?
+    end
+
+    def fixed?
+      @state.fixed?
+    end
+
+    private
+
+    def run(run_paths = [], runner_options = {}, notifications = {})
+      ::Guard::Notifier.notify "Guard mocha runs for #{run_paths.join(', ')}"
+      @state.update(run_paths, options.merge(runner_options))
+    end
+
+    def notify(scope = :all)
+      return unless options[:notify]
+
+      message = if passing?
+                  if fixed?
+                    scope == :all ? "All fixed" : "Specs fixed"
+                  else
+                    scope == :all ? "All specs pass" : "Specs pass"
+                  end
+                else
+                  "Some specs failing"
+                end
+      image = passing? ? :success : :failed
+      ::Guard::Notifier.notify(message, :image => image, :title => "mocha-node")
+    end
+  end
+end

data/spec/lib/mocha_node_spec.rb

@@ -0,0 +1,268 @@
+require 'spec_helper'
+
+describe Guard::MochaNode do
+  let(:state)  { Guard::MochaNode::SpecState.new }
+  let(:guard)  { Guard::MochaNode.new }
+
+  before do
+    Guard::MochaNode::SpecState.stub(:new => state)
+    Guard::Notifier.stub(:notify)
+    state.stub(:update => true)
+  end
+
+  describe "#initialize" do
+    context "when no options are given" do
+      it "sets a default path to mocha-node bin" do
+        guard.options[:mocha_bin].should eql "mocha"
+      end
+
+      it "sets :notify option to true" do
+        guard.options[:notify].should eql true
+      end
+
+      it "sets :all_after_pass option to true" do
+        guard.options[:all_after_pass].should be_true
+      end
+
+      it "sets :all_on_start option to true" do
+        guard.options[:all_on_start].should be_true
+      end
+
+      it "sets :keep_failed option to true" do
+        guard.options[:keep_failed].should be_true
+      end
+
+      it "sets :coffescript option to true" do
+        guard.options[:coffeescript].should be_true
+      end
+
+      it "sets :livescript option to true" do
+        guard.options[:livescript].should be_false
+      end
+
+      it "sets :verbose option to true" do
+        guard.options[:verbose].should be_true
+      end
+
+      it "sets :reporter option to 'spec'" do
+        guard.options[:reporter].should eql "spec"
+      end
+
+      it "sets :color option to true" do
+        guard.options[:color].should eql true
+      end
+
+      it "sets :recursive option to true" do
+        guard.options[:recursive].should eql true
+      end
+
+      it "sets :require option to nil" do
+        guard.options[:require].should_not be
+      end
+
+      it "sets :paths_for_all_specs  option to ['spec']" do
+        guard.options[:paths_for_all_specs].should eql ['spec']
+      end
+
+      it "sets :globals option to []" do
+        guard.options[:globals].should eql []
+      end
+
+      it "is passing" do
+        guard.should be_passing
+      end
+
+      it "has no failing paths" do
+        guard.failing_paths.should be_empty
+      end
+    end
+
+    context "when options are given" do
+      let(:a_path) { "/foo/bar/mocha-node" }
+      let(:guard)  { Guard::MochaNode.new([], {
+                                              :mocha_bin        => a_path,
+                                              :all_on_start     => false,
+                                              :all_after_pass   => false,
+                                              :keep_failed      => false,
+                                              :notify           => false,
+																						  :coffeescript     => false,
+																						  :livescript       => true,
+																						  :reporter         => 'spec',
+																						  :color            => false,
+																						  :recursive        => false,
+																						  :require          => "should",
+																						  :paths_for_all_specs => %w(test),
+                                              :globals          => ['Foo']
+                                            }) }
+
+      it "sets the path to mocha bin" do
+        guard.options[:mocha_bin].should eql a_path
+      end
+
+      it "sets the :notify option" do
+        guard.options[:notify].should be_false
+      end
+
+      it "sets the :all_after_pass option" do
+        guard.options[:all_after_pass].should be_false
+      end
+
+      it "sets the :all_on_start option" do
+        guard.options[:all_on_start].should be_false
+      end
+
+      it "sets the :keep_failed option" do
+        guard.options[:keep_failed].should be_false
+      end
+
+      it "sets the :coffeescript option" do
+        guard.options[:coffeescript].should be_false
+      end
+
+      it "sets the :livescript option" do
+        guard.options[:livescript].should be_true
+      end
+
+      it "sets the :reporter option" do
+        guard.options[:reporter].should eql 'spec'
+      end
+      it "sets the :color option" do
+        guard.options[:color].should be_false
+      end
+      it "sets the :recursive option" do
+        guard.options[:recursive].should be_false
+      end
+      it "sets the :require option" do
+        guard.options[:require].should eql "should"
+      end
+      it "sets the :paths_for_all_specs option" do
+        guard.options[:paths_for_all_specs].should eql ['test']
+      end
+      it "sets the :globals option" do
+        guard.options[:globals].should eql ['Foo']
+      end
+    end
+  end
+
+  describe "#start" do
+    context "when :all_on_start is true" do
+      it "runs all" do
+        guard.should_receive(:run_all)
+        guard.start
+      end
+    end
+
+    context "when :all_on_start is false" do
+      let(:guard) { Guard::MochaNode.new([], { :all_on_start => false }) }
+
+      it "does not run all" do
+        guard.should_not_receive(:run_all)
+        guard.start
+      end
+    end
+  end
+
+  describe "#run_all" do
+    it "updates the state with the specs in the spec dir" do
+      state.should_receive(:update).with(["spec"], anything)
+      guard.run_all
+    end
+
+    it "passes the options through to the state" do
+      an_option = { :option => "value" }
+      guard.options.update(an_option)
+      state.should_receive(:update).with(anything, hash_including(an_option))
+      guard.run_all
+    end
+
+    it "notifies the user with the outcome of running all specs" do
+      guard.should_receive(:notify).with(:all)
+      guard.run_all
+    end
+  end
+
+  describe "#run_on_change" do
+    before do
+      guard.options[:all_after_pass] = false
+    end
+
+    it "updates the state with paths" do
+      state.should_receive(:update).with(["/a/path"], anything)
+      guard.run_on_change(["/a/path"])
+    end
+
+    it "passes options through to the state" do
+      an_option = { :option => "value" }
+      guard.options.update(an_option)
+      state.should_receive(:update).with(anything, hash_including(an_option))
+      guard.run_on_change
+    end
+
+    it "notifies the user with the outcome of running the specs" do
+      guard.should_receive(:notify).with(:some)
+      guard.run_on_change
+    end
+
+    context "when specs pass" do
+      before do
+        guard.stub(:passing? => true)
+      end
+
+      context "and :all_after_pass is true" do
+        before do
+          guard.options[:all_after_pass] = true
+        end
+
+        it "runs all" do
+          guard.should_receive(:run_all)
+          guard.run_on_change
+        end
+      end
+
+      context "and :all_after_pass is false" do
+        before do
+          guard.options[:all_after_pass] = false
+        end
+
+        context "if :all_after_pass is true" do
+          it "does not run all" do
+            guard.should_not_receive(:run_all)
+            guard.run_on_change
+          end
+        end
+      end
+    end
+
+    context "when there are failing paths" do
+      let(:failing_paths) { %w(foo/bar zip/zap) }
+      let(:changed_paths) { %w(aaa/bbb ccc/ddd) }
+      let(:all_paths)     { failing_paths + changed_paths }
+
+      before do
+        guard.stub(:failing_paths => failing_paths)
+      end
+
+      context "and :keep_failed is true" do
+        before do
+          guard.options[:keep_failed] = true
+        end
+
+        it "updates state with failing paths and the changed paths" do
+          state.should_receive(:update).with(all_paths, anything)
+          guard.run_on_change(changed_paths)
+        end
+      end
+
+      context "and :keep_failed is false" do
+        before do
+          guard.options[:keep_failed] = false
+        end
+
+        it "updates state with only the changed paths" do
+          state.should_receive(:update).with(changed_paths, anything)
+          guard.run_on_change(changed_paths)
+        end
+      end
+    end
+  end
+end

data/spec/lib/runner_spec.rb

@@ -0,0 +1,231 @@
+require 'spec_helper'
+
+describe Guard::MochaNode::Runner do
+  let(:runner) { Guard::MochaNode::Runner }
+
+  before do
+    Open3.stub(:popen3 => "response")
+  end
+
+  describe ".run" do
+    let(:options) { { :paths_for_all_specs => %w(spec)} }
+    context "when passed no paths" do
+      it "returns false" do
+        runner.run.should be_false
+      end
+    end
+
+    context "when passed paths" do
+      let(:some_paths) { %w(/foo/bar /zip/zap) }
+
+      it "executes mocha node" do
+        Open3.should_receive(:popen3) do |*args|
+	  args[0].should eq "__EXECUTABLE__"
+	end
+        runner.run(some_paths, options.merge({ :mocha_bin => "__EXECUTABLE__"}))
+      end
+
+      it "passes the paths to the executable" do
+        Open3.should_receive(:popen3) do |*args|
+	  last_args = args[(some_paths.length * -1)..(-1)]
+	  last_args.should eql some_paths
+	end
+        runner.run(some_paths, options)
+      end
+
+      context "and coffeescript option is true" do
+        it "passes the --compilers coffee:coffee-script option to mocha node" do
+          Open3.should_receive(:popen3) do |*args|
+	    index_compilers = args.find_index "--compilers"
+	    index_compilers.should_not be nil
+	    args[index_compilers +1].should eql "coffee:coffee-script"
+	  end
+	  runner.run(some_paths, options.merge({ :coffeescript => true}))
+        end
+      end
+
+      context "and coffeescript option is false" do
+        it "does not pass the --compilers coffee:coffee-script option to mocha node" do
+          Open3.should_receive(:popen3) do |*args|
+	    index_compilers = args.find_index "--compilers"
+	    if index_compilers != nil
+	      args[index_compilers +1].should_not match /coffee:coffee-script/
+	    end
+	  end
+          runner.run(some_paths, options.merge({ :coffeescript => false}))
+        end
+      end
+
+      context "and livescript option is true" do
+        it "passes the --compilers ls:LiveScript option to mocha node" do
+          Open3.should_receive(:popen3) do |*args|
+	    index_compilers = args.find_index "--compilers"
+	    index_compilers.should_not be nil
+	    args[index_compilers +1].should eql "ls:LiveScript"
+	  end
+	  runner.run(some_paths, options.merge({ :livescript => true}))
+        end
+      end
+
+      context "and livescript option is false" do
+        it "does not pass the --compilers ls:LiveScript option to mocha node" do
+          Open3.should_receive(:popen3) do |*args|
+	    index_compilers = args.find_index "--compilers"
+	    if index_compilers != nil
+	      args[index_compilers +1].should_not match /ls:LiveScript/
+	    end
+	  end
+          runner.run(some_paths, options.merge({ :livescript => false}))
+        end
+      end
+
+      context "and both coffeescript and livescript  option are true" do
+        it "passes the --compilers coffee:coffee-script,ls:LiveScript option to mocha node" do
+          Open3.should_receive(:popen3) do |*args|
+	    index_compilers = args.find_index "--compilers"
+	    index_compilers.should_not be nil
+	    args[index_compilers +1].should eql "coffee:coffee-script,ls:LiveScript"
+	  end
+	  runner.run(some_paths, options.merge({ :livescript => true, :coffeescript => true }))
+        end
+      end
+
+      context "and color option is true" do
+        it "passes the -c option to mocha node" do
+          Open3.should_receive(:popen3) do |*args|
+	    args.should include "-c"
+	  end
+          runner.run(some_paths, options.merge({ :color => true}))
+        end
+      end
+
+      context "and color option is false" do
+        it "passes the -C option to mocha node" do
+          Open3.should_receive(:popen3) do |*args|
+	    args.should include "-C"
+	  end
+          runner.run(some_paths, options.merge({ :color => false}))
+        end
+      end
+
+      context "and globals option is set" do
+        it "passes the --globals option to mocha node" do
+          Open3.should_receive(:popen3) do |*args|
+	    args.should include("--globals", "Foo")
+            # ensure ordering
+            args[args.index("--globals") + 1].should eql("Foo")
+	  end
+          runner.run(some_paths, options.merge({ :globals => ['Foo']}))
+        end
+      end
+
+      context "and globals option is empty" do
+        it "does not pass the --globals option to mocha node" do
+          Open3.should_receive(:popen3) do |*args|
+	    args.should_not include "--globals"
+	  end
+          runner.run(some_paths, options.merge({ :globals => []}))
+        end
+      end
+
+      context "and reporter option is set" do
+        it "passes the --reporter option to mocha node" do
+          Open3.should_receive(:popen3) do |*args|
+            args.should include("--reporter", "Foo")
+            # ensure ordering
+            args[args.index("--reporter") + 1].should eql("Foo")
+          end
+          runner.run(some_paths, options.merge({ :reporter => 'Foo' }))
+        end
+      end
+
+      context "and reporter option is not set" do
+        it "does not pass the --reporter option to mocha node" do
+          Open3.should_receive(:popen3) do |*args|
+            args.should_not include "--reporter"
+          end
+          runner.run(some_paths, options)
+        end
+      end
+
+      context "and recursive option is true" do
+        it "passes the --recursive option to mocha node" do
+          Open3.should_receive(:popen3) do |*args|
+	    args.should include "--recursive"
+	  end
+          runner.run(some_paths, options.merge({ :recursive => true}))
+        end
+      end
+
+      context "and recursive option is false" do
+        it "does not pass the --recursive option to mocha node" do
+          Open3.should_receive(:popen3) do |*args|
+	    args.should_not include "--recursive"
+	  end
+          runner.run(some_paths, options.merge({ :recursive => false}))
+        end
+      end
+
+      context "and require option is 'should'" do
+        it "passes the '-r should' option to mocha node" do
+          Open3.should_receive(:popen3) do |*args|
+	    require_index = args.find_index '-r'
+	    require_index.should_not eq nil
+	    args[require_index+1].should eql "should"
+	  end
+          runner.run(some_paths, options.merge({ :require => 'should'}))
+        end
+      end
+
+      context "and require option is ['should', 'chai']" do
+        it "passes the '-r should -r chai' option to mocha node" do
+          Open3.should_receive(:popen3) do |*args|
+	    args.each_with_index.
+	      reject{ |e,i| e != '-r' }.
+	      map{ |e,i| args[i+1] }.should eql ["should", "chai"]
+
+	  end
+          runner.run(some_paths, options.merge({ :require => ['should', 'chai'] }))
+        end
+      end
+
+      context "and require option is nil" do
+        it "does not pass the -r option to mocha node" do
+          Open3.should_receive(:popen3) do |*args|
+	    args.should_not include "-r"
+	  end
+          runner.run(some_paths, options.merge({ :require => nil}))
+        end
+      end
+
+      it "returns IO object" do
+        io_obj = double("io obj")
+        Open3.stub(:popen3 => io_obj)
+        runner.run(some_paths, options).should eql io_obj
+      end
+
+      context "when message option is given" do
+        it "outputs message" do
+          Guard::UI.should_receive(:info).with("hello", anything)
+          runner.run(some_paths, options.merge({ :message => "hello"}))
+        end
+      end
+
+      context "when no message option is given" do
+        context "and running all specs" do
+          it "outputs message confirming all specs are being run" do
+            Guard::UI.should_receive(:info).with("Running all specs", anything)
+            runner.run(%w(spec),  options )
+          end
+        end
+
+        context "and running some specs" do
+          it "outputs paths of specs being run" do
+            Guard::UI.should_receive(:info).with("Running: /foo/bar /zip/zap", anything)
+            runner.run(some_paths, options)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/spec_state_spec.rb

@@ -0,0 +1,127 @@
+require 'spec_helper'
+
+describe Guard::MochaNode::SpecState do
+  let(:state)  { Guard::MochaNode::SpecState.new }
+  let(:runner) { Guard::MochaNode::Runner }
+
+  describe "#initialize" do
+    it "is passing" do
+      state.should be_passing
+    end
+
+    it "has no failing paths" do
+      state.failing_paths.should be_empty
+    end
+
+    it "is has not been fixed" do
+      state.should_not be_fixed
+    end
+  end
+
+  describe "#update" do
+    let(:io) { [
+                double("stdin",  :close => true),
+                double("stdout", :close => true, :lines => [], :eof? => true),
+                double("stderr", :close => true, :lines => []),
+                double("thread", :value => 0)
+               ] }
+    let(:some_paths)   { %w(some paths) }
+    let(:some_options) { double("some options") }
+
+    before do
+      runner.stub(:run => io)
+    end
+
+    it "runs the runner with the paths and options" do
+      runner.should_receive(:run).with(some_paths, some_options).and_return(io)
+      state.update(some_paths, some_options)
+    end
+
+    it "closes stdin, stdout, and stderr of the subprocess" do
+      io[0..2].each { |i| i.should_receive(:close) }
+      state.update
+    end
+
+    context "when the runner process exit value is zero" do
+      before do
+        io[3].stub(:value => 0)
+        state.update
+      end
+
+      it "is passing" do
+        state.should be_passing
+      end
+
+      context "and there are run paths" do
+        it "removes the run paths from the failing paths" do
+          state.failing_paths = %w(/keep /remove)
+          state.update(%w(/remove))
+          state.failing_paths.should eql %w(/keep)
+        end
+      end
+
+      context "and there are no run paths" do
+        it "does not change the current failing paths" do
+          original_failing_paths = %w(/keep1 /keep2)
+          state.failing_paths = original_failing_paths
+          state.update
+          state.failing_paths.should eql original_failing_paths
+        end
+      end
+
+      context "and the previous spec failed" do
+        before do
+          state.stub(:passing? => false)
+          state.update
+        end
+
+        it "is fixed" do
+          state.should be_fixed
+        end
+      end
+
+      context "and the previous spec passed" do
+        before do
+          state.stub(:passing? => true)
+          state.update
+        end
+
+        it "is not fixed" do
+          state.should_not be_fixed
+        end
+      end
+    end
+
+    context "when the runner process exit value is not zero" do
+      before do
+        io[3].stub(:value => 1)
+        state.update(some_paths, some_options)
+      end
+
+      it "is not passing" do
+        state.should_not be_passing
+      end
+
+      it "is not fixed" do
+        state.should_not be_fixed
+      end
+
+      context "and there are run paths" do
+        it "updates the failing paths with the union of the failing paths and the run paths" do
+          state.failing_paths = %w(/dupe /other)
+          state.update(%w(/dupe /another))
+          state.failing_paths.should =~ %w(/dupe /other /another)
+        end
+      end
+
+      context "and there are no run paths" do
+        it "does not change the current failing paths" do
+          original_failing_paths = %w(/keep1 /keep2)
+          state.failing_paths = original_failing_paths
+          state.update
+          state.failing_paths.should eql original_failing_paths
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+require 'rspec'
+require 'guard/mocha_node'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+  config.filter_run :focus => true
+  config.run_all_when_everything_filtered = true
+
+  config.before do
+    ENV["GUARD_ENV"] = "test"
+    @project_path = Pathname.new(File.expand_path("../../", __FILE__))
+  end
+
+  config.after do
+    ENV["GUARD_ENV"] = nil
+  end
+end

metadata

@@ -0,0 +1,161 @@
+--- !ruby/object:Gem::Specification
+name: guard-mocha-node
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+  prerelease: 
+platform: ruby
+authors:
+- dave@kapoq.com
+- David Schoen <dave@lyte.id.au>
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rb-inotify
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: libnotify
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ''
+email:
+- dave@kapoq.com
+- dave@lyte.id.au
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- CHANGELOG.md
+- Gemfile
+- Guardfile
+- README.md
+- Rakefile
+- guard-mocha-node.gemspec
+- lib/guard/mocha-node.rb
+- lib/guard/mocha_node.rb
+- lib/guard/mocha_node/runner.rb
+- lib/guard/mocha_node/spec_state.rb
+- lib/guard/mocha_node/templates/Guardfile
+- lib/guard/mocha_node/version.rb
+- spec/lib/mocha_node_spec.rb
+- spec/lib/runner_spec.rb
+- spec/lib/spec_state_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/kanzeon/guard-mocha-node
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: guard-mocha-node
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Guard::MochaNode automatically runs your Mocha Node specs when files are
+  modified
+test_files: []