guard-jasmine-node 0.0.1 → 0.0.3

data/README.md

@@ -0,0 +1,112 @@
+Guard::JasmineNode ![travis-ci](https://secure.travis-ci.org/textgoeshere/guard-jasmine-node.png)
+==================
+
+JasmineNode guard automatically & intelligently executes jasmine node specs when files are modified.
+
+It works brilliantly with Node projects whereas [guard-jasmine](https://github.com/netzpirat/guard-jasmine)
+looks better for jasmine specs in the context of e.g. a Rails app.
+
+* Tested against Node 0.4, jasmine-node 1.0.10
+
+Requirements
+------------
+
+* [Node](http://nodejs.org/)
+* [jasmine-node](https://github.com/mhevery/jasmine-node)
+* [Ruby](http://ruby-lang.org) and rubygems
+
+Install
+-------
+
+Install the gem:
+
+    $ gem install guard-jasmine-node
+
+Add guard definition to your Guardfile by running this command:
+
+    $ guard init jasmine-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.
+
+* `:jasmine_node_bin`
+
+Specify the path to the jasmine-node binary that will execute your specs.
+
+The default `:jasmine_node_bin` in the Guardfile assumes:
+
+* you are running guard from the root of the project
+* you installed jasmine-node using npm
+* you installed jasmine-node locally to node_modules
+
+If you delete the option completely from the Guardfile, it assumes the
+jasmine-node binary is already in your `$PATH`.
+
+So if you have installed jasmine-node globally using e.g. `npm install
+-g jasmine-node`, remove the `:jasmine_node_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.
+
+Development
+-----------
+
+* Source hosted at [GitHub](https://github.com/kapoq/guard-jasmine-node)
+* Report issues/Questions/Feature requests on [GitHub Issues](https://github.com/kapoq/guard-jasmine-node/issues)
+* CI at [Travis](http://travis-ci.org/#!/textgoeshere/guard-jasmine-node)
+
+Pull requests are very welcome! Make sure your patches are well tested. Please create a topic branch for every separate change
+you make.
+
+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
+------
+
+[Dave Nolan](https://github.com/textgoeshere)

data/guard-jasmine-node.gemspec

@@ -17,6 +17,7 @@ Gem::Specification.new do |s|
   
   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"

data/lib/guard/jasmine_node.rb

@@ -7,14 +7,19 @@ module Guard
       :jasmine_node_bin => "jasmine-node",
       :all_after_pass   => true,
       :all_on_start     => true,
-      :keep_failed      => true
+      :keep_failed      => true,
+      :notify           => true,
+      :coffeescript     => true
     }
-
-    autoload :Runner, "guard/jasmine_node/runner"
     
+    PATHS_FOR_ALL_SPECS = %w(spec)
+
+    autoload :Runner,    "guard/jasmine_node/runner"
+    autoload :SpecState, "guard/jasmine_node/spec_state"
+
     def initialize(watchers = [], options = {})
       super(watchers, DEFAULT_OPTIONS.merge(options))
-      clear_pass_state
+      @state = SpecState.new
     end
 
     def start
@@ -22,8 +27,8 @@ module Guard
     end
 
     def run_all
-      outcome = Runner.run(["spec"], options.merge(:message => "Running all specs"))
-      set_pass_state(outcome)
+      run(PATHS_FOR_ALL_SPECS)
+      notify(:all)
     end
 
     def run_on_change(changed_paths = [])
@@ -33,38 +38,44 @@ module Guard
                     changed_paths
                   end
 
-      outcome = Runner.run(run_paths, options)
-      set_pass_state(outcome, run_paths)
-      
-      if passing?
-        run_all if options[:all_after_pass]
-      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?
-      @passing
+      @state.passing?
     end
 
-    def failing_paths
-      @failing_paths
+    def fixed?
+      @state.fixed?
     end
 
     private
 
-    def clear_pass_state
-      @passing       = true
-      @failing_paths = []
+    def run(run_paths = [], runner_options = {}, notifications = {})
+      @state.update(run_paths, options.merge(runner_options))
     end
-    
-    def set_pass_state(passed, run_paths = [])
-      @passing = passed
-      if run_paths.any?
-        @failing_paths = if passing?
-                           @failing_paths - run_paths
-                         else
-                           @failing_paths && run_paths
-                         end
-      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 => "jasmine-node")
     end
   end
 end

data/lib/guard/jasmine_node/runner.rb

@@ -1,3 +1,4 @@
+require 'open3'
 require 'guard/ui'
 
 module Guard
@@ -5,17 +6,32 @@ module Guard
     module Runner
       def self.run(paths = [], options = {})
         return false if paths.empty?
-        
-        message = options.fetch(:message, "Running: #{paths.join(' ')}")
-        ::Guard::UI.info(message, :reset => true)
 
-        system(jasmine_node_command(paths, options))
+        @paths   = paths
+        @options = options
+
+        print_message
+        execute_jasmine_node_command
       end
 
       private
 
-      def self.jasmine_node_command(paths = [], options = {})
-        "#{options[:jasmine_node_bin]} #{paths.join(' ')}"
+      def self.print_message
+        message = @options[:message]
+        message ||= @paths == PATHS_FOR_ALL_SPECS ? "Running all specs" : "Running: #{@paths.join(' ')}"
+        ::Guard::UI.info(message, :reset => true)
+      end
+
+      def self.execute_jasmine_node_command
+        ::Open3.popen3(jasmine_node_command)
+      end
+
+      def self.jasmine_node_command
+        "#{@options[:jasmine_node_bin]} #{command_line_options} #{@paths.join(' ')}"
+      end
+
+      def self.command_line_options
+        "--coffee" if @options[:coffeescript]
       end
     end
   end

data/lib/guard/jasmine_node/spec_state.rb

@@ -0,0 +1,67 @@
+module Guard
+  class JasmineNode
+    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]
+        @exitstatus = @io[THREAD].value rescue ERROR_CODE
+        @stdout.lines { |line| print line }
+        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/jasmine_node/templates/Guardfile

@@ -1,5 +1,17 @@
-guard "jasmine-node", :jasmine_node_bin => File.expand_path(File.dirname(__FILE__) + "/node_modules/jasmine-node/bin/jasmine-node")  do
-  watch(%r{^spec/.+_spec\.js$})
-  watch(%r{^lib/(.+)\.js$})     { |m| "spec/lib/#{m[1]}_spec.js" }
-  watch('spec/spec_helper.js')
+# Installed by guard-jasmine-node
+
+# JavaScript/CoffeeScript watchers
+
+guard 'jasmine-node', :jasmine_node_bin => File.expand_path(File.dirname(__FILE__) + "/node_modules/jasmine-node/bin/jasmine-node") 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 "jasmine-node", :jasmine_node_bin => File.expand_path(File.dirname(__FILE__) + "/node_modules/jasmine-node/bin/jasmine-node")  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/jasmine_node/version.rb

@@ -1,5 +1,5 @@
 module Guard
   module JasmineNodeVersion
-    VERSION = "0.0.1"
+    VERSION = "0.0.3"
   end
 end

data/spec/{spec → lib}/jasmine_node_spec.rb

@@ -1,8 +1,14 @@
 require 'spec_helper'
 
 describe Guard::JasmineNode do
+  let(:state)  { Guard::JasmineNode::SpecState.new }
   let(:guard)  { Guard::JasmineNode.new }
-  let(:runner) { Guard::JasmineNode::Runner }
+
+  before do
+    Guard::JasmineNode::SpecState.stub(:new => state)
+    Guard::Notifier.stub(:notify)
+    state.stub(:update => true)
+  end
   
   describe "#initialize" do
     context "when no options are given" do
@@ -10,18 +16,26 @@ describe Guard::JasmineNode do
         guard.options[:jasmine_node_bin].should eql "jasmine-node"
       end
 
-      it "sets a default :all_after_pass option" do
+      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 a default :all_on_start option" do
+      it "sets :all_on_start option to true" do
         guard.options[:all_on_start].should be_true
       end
       
-      it "sets a default :keep_failed option" do
+      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 "is passing" do
         guard.should be_passing
       end
@@ -37,12 +51,18 @@ describe Guard::JasmineNode do
                                               :jasmine_node_bin => a_path,
                                               :all_on_start     => false,
                                               :all_after_pass   => false,
-                                              :keep_failed      => false
+                                              :keep_failed      => false,
+                                              :notify           => false,
+                                              :coffeescript     => false
                                             }) }
 
       it "sets the path to jasmine-node bin" do
         guard.options[:jasmine_node_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
@@ -55,6 +75,10 @@ describe Guard::JasmineNode do
       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
     end
   end
 
@@ -77,78 +101,49 @@ describe Guard::JasmineNode do
   end
 
   describe "#run_all" do
-    it "runs the runner with the spec dir" do
-      runner.should_receive(:run).with(["spec"], anything)
-      guard.run_all
-    end
-
-    it "tells the message to the runner" do
-      runner.should_receive(:run).with(anything, hash_including(:message => "Running all specs"))
+    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 on to the runner" do
+    it "passes the options through to the state" do
       an_option = { :option => "value" }
       guard.options.update(an_option)
-      runner.should_receive(:run).with(anything, hash_including(an_option))
+      state.should_receive(:update).with(anything, hash_including(an_option))
       guard.run_all
     end
 
-    context "when specs pass" do
-      before do
-        runner.stub(:run => true)
-        guard.run_all
-      end
-
-      it "is passing" do
-        guard.should be_passing
-      end
-
-      it "has no failed paths" do
-        guard.failing_paths.should be_empty
-      end
-    end
-
-    context "when specs fail" do
-      before do
-        runner.stub(:run => false)
-      end
-
-      it "is not passing" do
-        guard.run_all
-        guard.should_not be_passing
-      end
-
-      it "keeps previously failing specs" do
-        failing_paths = %w(foo bar)
-        guard.run_on_change(failing_paths)
-        guard.run_all
-        guard.failing_paths.should eql failing_paths
-      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
-    it "runs the runner with paths" do
-      runner.should_receive(:run).with(["/a/path"], anything)
+    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 runner" do
+    it "passes options through to the state" do
       an_option = { :option => "value" }
       guard.options.update(an_option)
-      runner.should_receive(:run).with(anything, hash_including(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
-        runner.stub(:run => true)
-      end
-
-      it "is passing" do
-        guard.run_on_change
-        guard.should be_passing
+        guard.stub(:passing? => true)
       end
       
       context "and :all_after_pass is true" do
@@ -176,17 +171,6 @@ describe Guard::JasmineNode do
       end
     end
 
-    context "when specs fail" do
-      before do
-        runner.stub(:run => false)
-      end
-
-      it "is not passing" do
-        guard.run_on_change
-        guard.should_not be_passing
-      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) }
@@ -201,8 +185,8 @@ describe Guard::JasmineNode do
           guard.options[:keep_failed] = true
         end
 
-        it "runs the runner failing paths and the changed paths" do
-          runner.should_receive(:run).with(all_paths, anything)
+        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
@@ -212,8 +196,8 @@ describe Guard::JasmineNode do
           guard.options[:keep_failed] = false
         end
 
-        it "runs the runner with only the changed paths" do
-          runner.should_receive(:run).with(changed_paths, anything)
+        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

data/spec/lib/runner_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe Guard::JasmineNode::Runner do
+  let(:runner) { Guard::JasmineNode::Runner }
+
+  before do
+    Open3.stub(:popen3 => "response")
+  end
+  
+  describe ".run" do
+    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 jasmine node" do
+        Open3.should_receive(:popen3).with(/__EXECUTABLE__/)
+        runner.run(some_paths, :jasmine_node_bin => "__EXECUTABLE__")
+      end
+
+      it "passes the paths to the executable" do
+        Open3.should_receive(:popen3).with(/#{some_paths.join(" ")}/)
+        runner.run(some_paths)
+      end
+
+      context "and coffeescript option is true" do
+        it "passes the --coffee option to jasmine node" do
+          Open3.should_receive(:popen3).with(/--coffee/)
+          runner.run(some_paths, :coffeescript => true)
+        end
+      end
+
+      context "and coffeescript option is false" do
+        it "does not pass the --coffee option to jasmine node" do
+          Open3.should_not_receive(:popen3).with(/--coffee/)
+          runner.run(some_paths, :coffeescript => false)
+        end
+      end
+
+      it "returns IO object" do
+        io_obj = double("io obj")
+        Open3.stub(:popen3 => io_obj)
+        runner.run(some_paths).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, :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(Guard::JasmineNode::PATHS_FOR_ALL_SPECS)
+          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)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/spec_state_spec.rb

@@ -0,0 +1,127 @@
+require 'spec_helper'
+
+describe Guard::JasmineNode::SpecState do
+  let(:state)  { Guard::JasmineNode::SpecState.new }
+  let(:runner) { Guard::JasmineNode::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 => []),
+                double("stderr", :close => true),
+                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

metadata

@@ -1,78 +1,117 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: guard-jasmine-node
-version: !ruby/object:Gem::Version
-  version: 0.0.1
+version: !ruby/object:Gem::Version 
+  hash: 25
   prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 3
+  version: 0.0.3
 platform: ruby
-authors:
+authors: 
 - dave@kapoq.com
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-22 00:00:00.000000000Z
-dependencies:
-- !ruby/object:Gem::Dependency
+
+date: 2011-09-23 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
   name: guard
-  requirement: &21459700 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0.4'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        - 4
+        version: "0.4"
   type: :runtime
-  prerelease: false
-  version_requirements: *21459700
-- !ruby/object:Gem::Dependency
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
   name: rspec
-  requirement: &21459280 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
   type: :development
-  prerelease: false
-  version_requirements: *21459280
-- !ruby/object:Gem::Dependency
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
   name: guard-rspec
-  requirement: &21458820 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
   type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rake
   prerelease: false
-  version_requirements: *21458820
-- !ruby/object:Gem::Dependency
-  name: rb-inotify
-  requirement: &21458360 !ruby/object:Gem::Requirement
+  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
   type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rb-inotify
   prerelease: false
-  version_requirements: *21458360
-- !ruby/object:Gem::Dependency
-  name: libnotify
-  requirement: &21457940 !ruby/object:Gem::Requirement
+  requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
   type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: libnotify
   prerelease: false
-  version_requirements: *21457940
-description: ''
-email:
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id006
+description: ""
+email: 
 - dave@kapoq.com
 executables: []
+
 extensions: []
+
 extra_rdoc_files: []
-files:
+
+files: 
 - .gitignore
 - .travis.yml
 - CHANGELOG.md
@@ -84,34 +123,45 @@ files:
 - lib/guard/jasmine-node.rb
 - lib/guard/jasmine_node.rb
 - lib/guard/jasmine_node/runner.rb
+- lib/guard/jasmine_node/spec_state.rb
 - lib/guard/jasmine_node/templates/Guardfile
 - lib/guard/jasmine_node/version.rb
-- spec/spec/jasmine_node_spec.rb
-- spec/spec/runner_spec.rb
+- spec/lib/jasmine_node_spec.rb
+- spec/lib/runner_spec.rb
+- spec/lib/spec_state_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/kapoq/guard-jasmine-node
 licenses: []
+
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
+required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
 requirements: []
+
 rubyforge_project: guard-jasmine-node
-rubygems_version: 1.8.10
+rubygems_version: 1.8.6
 signing_key: 
 specification_version: 3
-summary: Guard::JasmineNode automatically runs your Jasmine Node specs when files
-  are modified
+summary: Guard::JasmineNode automatically runs your Jasmine Node specs when files are modified
 test_files: []
+

data/spec/spec/runner_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-describe Guard::JasmineNode::Runner do
-  let(:runner) { Guard::JasmineNode::Runner }
-  
-  describe ".run" do
-    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 jasmine node" do
-        runner.should_receive(:system).with(/__EXECUTABLE__/)
-        runner.run(some_paths, :jasmine_node_bin => "__EXECUTABLE__")
-      end
-      
-      context "when message option is given" do
-        it "outputs message" do
-          Guard::UI.should_receive(:info).with("hello", anything)
-          runner.run(some_paths, :message => "hello")
-        end
-      end
-
-      context "when no message option is given" do
-        it "outputs default message" do
-          Guard::UI.should_receive(:info).with("Running: /foo/bar /zip/zap", anything)
-          runner.run(some_paths)
-        end
-      end
-    end
-  end
-end