guard-jasmine 0.2.2 → 0.3.0

data/README.md

@@ -135,6 +135,12 @@ There following options can be passed to Guard::Jasmine:
     :all_on_start => false                        # Run all specs on start.
                                                   # default: true
 
+    :keep_failed => false                         # Keep failed specs and add them the next run again.
+                                                  # default: true
+
+    :all_after_pass => false                      # Run all specs after a single spec has passed.
+                                                  # default: true
+
     :notifications => false                       # Show success and error messages.
                                                   # default: true
 
@@ -144,7 +150,7 @@ There following options can be passed to Guard::Jasmine:
 
 ## Alternatives
 
-* [guard-jasmine-headless-webkit][], a Guard for [jasmine-headless-webkit][], but doesn't run in JRuby.
+* [guard-jasmine-headless-webkit][], a Guard for [jasmine-headless-webkit][], but doesn't run on JRuby.
 * [Evergreen][], runs CoffeeScript specs headless, but has no
 continuous testing support.
 * [Jezebel][] a Node.js REPL and continuous test runner for [Jessie][], a Node runner for Jasmine, but has no full
@@ -168,26 +174,17 @@ For questions please join us on our [Google group](http://groups.google.com/grou
 
 ## Acknowledgment
 
-[Ariya Hidayat][] for [PhantomJS][], a powerfull headless WebKit browser.
-
-[Brad Phelan][] for [Jasminerice][], an elegant solution for [Jasmine][] in the Rails 3.1 asset pipeline.
-
-[Pivotal Labs][] for their beautiful [Jasmine][] BDD testing framework that makes JavaScript testing fun.
-
-[Jeremy Ashkenas][] for [CoffeeScript][], that little language that compiles into JavaScript and makes me enjoy the
+- [Ariya Hidayat][] for [PhantomJS][], a powerfull headless WebKit browser.
+- [Brad Phelan][] for [Jasminerice][], an elegant solution for [Jasmine][] in the Rails 3.1 asset pipeline.
+- [Pivotal Labs][] for their beautiful [Jasmine][] BDD testing framework that makes JavaScript testing fun.
+- [Jeremy Ashkenas][] for [CoffeeScript][], that little language that compiles into JavaScript and makes me enjoy the
 frontend.
-
-The [Guard Team][] for giving us such a nice piece of software that is so easy to extend, one *has* to make a plugin
+- The [Guard Team][] for giving us such a nice piece of software that is so easy to extend, one *has* to make a plugin
 for it!
-
-All the authors of the numerous [Guards][] available for making the Guard ecosystem so much growing and comprehensive.
+- All the authors of the numerous [Guards][] available for making the Guard ecosystem so much growing and comprehensive.
 
 ## License
 
-The Jasmine PhantomJS runner file [run-jasmine.coffee][] from [Roejames12][] is licensed under the BSD license.
-
-The Guard::Jasmine itself is released under:
-
 (The MIT License)
 
 Copyright (c) 2011 Michael Kessler
@@ -218,8 +215,6 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 [PhantomJS]: http://www.phantomjs.org/
 [the PhantomJS download section]: http://code.google.com/p/phantomjs/downloads/list
 [PhantomJS build instructions]: http://code.google.com/p/phantomjs/wiki/BuildInstructions
-[Roejames12]: https://github.com/Roejames12
-[run-jasmine.coffee]: https://github.com/ariya/phantomjs/blob/master/examples/run-jasmine.coffee
 [Brad Phelan]: http://twitter.com/#!/bradgonesurfing
 [Jasminerice]: https://github.com/bradphelan/jasminerice
 [Pivotal Labs]: http://pivotallabs.com/

data/lib/guard/jasmine.rb

@@ -1,6 +1,7 @@
 require 'guard'
 require 'guard/guard'
 require 'guard/watcher'
+require 'net/http'
 
 module Guard
 
@@ -13,6 +14,8 @@ module Guard
     autoload :Inspector, 'guard/jasmine/inspector'
     autoload :Runner, 'guard/jasmine/runner'
 
+    attr_accessor :last_run_failed, :last_failed_paths
+
     # Initialize Guard::Jasmine.
     #
     # @param [Array<Guard::Watcher>] watchers the watchers in the Guard block
@@ -22,17 +25,24 @@ module Guard
     # @option options [Boolean] :notification show notifications
     # @option options [Boolean] :hide_success hide success message notification
     # @option options [Boolean] :all_on_start run all suites on start
+    # @option options [Boolean] :keep_failed keep failed specs and add them the next run again
+    # @option options [Boolean] :all_after_pass run all specs after a single spec has passed
     #
     def initialize(watchers = [], options = { })
       defaults = {
-          :jasmine_url   => 'http://localhost:3000/jasmine',
-          :phantomjs_bin => '/usr/local/bin/phantomjs',
-          :notification  => true,
-          :hide_success  => false,
-          :all_on_start  => true
+          :jasmine_url    => 'http://localhost:3000/jasmine',
+          :phantomjs_bin  => '/usr/local/bin/phantomjs',
+          :notification   => true,
+          :hide_success   => false,
+          :all_on_start   => true,
+          :keep_failed    => true,
+          :all_after_pass => true
       }
 
       super(watchers, defaults.merge(options))
+
+      self.last_run_failed   = false
+      self.last_failed_paths = []
     end
 
     # Gets called once when Guard starts.
@@ -40,7 +50,20 @@ module Guard
     # @return [Boolean] when the start was successful
     #
     def start
-      run_all if options[:all_on_start]
+      if jasmine_runner_available?(options[:jasmine_url])
+        run_all if options[:all_on_start]
+      end
+
+      true
+    end
+
+    # Gets called when the Guard should reload itself.
+    #
+    # @return [Boolean] when the reload was successful
+    #
+    def reload
+      self.last_run_failed   = false
+      self.last_failed_paths = []
 
       true
     end
@@ -50,7 +73,12 @@ module Guard
     # @return [Boolean] when running all specs was successful
     #
     def run_all
-      Runner.run(['spec/javascripts'], options)
+      passed, failed_specs = Runner.run(['spec/javascripts'], options)
+
+      self.last_failed_paths = failed_specs
+      self.last_run_failed   = !passed
+
+      passed
     end
 
     # Gets called when watched paths and files have changes.
@@ -59,9 +87,63 @@ module Guard
     # @return [Boolean] when running the changed specs was successful
     #
     def run_on_change(paths)
-      Runner.run(Inspector.clean(paths), options)
+      paths += self.last_failed_paths if options[:keep_failed]
+
+      passed, failed_specs = Runner.run(Inspector.clean(paths), options)
 
-      #TODO: Evaluate result
+      if passed
+        self.last_failed_paths = self.last_failed_paths - paths
+        run_all if self.last_run_failed && options[:all_after_pass]
+      else
+        self.last_failed_paths = self.last_failed_paths + failed_specs
+      end
+
+      self.last_run_failed = !passed
+
+      passed
+    end
+
+    private
+
+    # Verifies if the Jasmine test runner is available.
+    #
+    # @param [String] url the location of the test runner
+    # @return [Boolean] when the runner is available
+    #
+    def jasmine_runner_available?(url)
+      url = URI.parse(url)
+
+      begin
+        Net::HTTP.start(url.host, url.port) do |http|
+          response = http.request(Net::HTTP::Head.new(url.path))
+
+          if response.code.to_i == 200
+            Formatter.info("Jasmine test runner is available at #{ url }")
+          else
+            notify_jasmine_runner_failure(url) if options[:notification]
+          end
+
+          response.code.to_i == 200
+        end
+
+      rescue Errno::ECONNREFUSED => e
+        notify_jasmine_runner_failure(url)
+
+        false
+      end
+    end
+
+    # Notify that the Jasmine runner is not available.
+    #
+    # @param [String] url the url of the Jasmine runner
+    #
+    def notify_jasmine_runner_failure(url)
+      message = "Jasmine test runner not available at #{ url }"
+      Formatter.error(message)
+      Formatter.notify(message,
+                       :title    => 'Jasmine test runner not available',
+                       :image    => :failed,
+                       :priority => 2)
     end
 
   end

data/lib/guard/jasmine/formatter.rb

@@ -48,6 +48,24 @@ module Guard
           ::Guard::UI.info(color(message, ';32'), options)
         end
 
+        # Print a red spec failed message to the console.
+        #
+        # @param [String] message the message to print
+        # @param [Hash] options the output options
+        #
+        def spec_failed(message, options = { })
+           ::Guard::UI.info(color(message, ';31'), options)
+        end
+
+        # Print a red spec failed message to the console.
+        #
+        # @param [String] message the message to print
+        # @param [Hash] options the output options
+        #
+        def suite_name(message, options = { })
+           ::Guard::UI.info(color(message, ';33'), options)
+        end
+
         # Outputs a system notification.
         #
         # @param [String] message the message to print

data/lib/guard/jasmine/phantomjs/run-jasmine.coffee

@@ -1,29 +1,85 @@
+# This file is the script that runs within PhantomJS and requests the Jasmine specs,
+# waits until they are ready, extracts the result form the dom and outputs a JSON
+# structure that is the parsed by Guard::Jasmine.
+#
+# This scripts needs the TrivialReporter to report the results.
+#
+# This file is inspired by the Jasmine runner that comes with the PhantomJS examples:
+# https://github.com/ariya/phantomjs/blob/master/examples/run-jasmine.coffee, by https://github.com/Roejames12
+#
+# This file is licensed under the BSD license.
+
 # Wait until the test condition is true or a timeout occurs.
 #
-# @param [Function] testFx the condition that evaluates to a boolean
-# @param [Function] onReady the action when the condition is fulfilled
-# @param [Number] timeOutMillis the max amount of time to wait
+# @param [Function] condition the condition that evaluates to a boolean
+# @param [Function] ready the action when the condition is fulfilled
+# @param [Number] timeout the max amount of time to wait
 #
-waitFor = (testFx, onReady, timeOutMillis=3000) ->
+waitFor = (condition, ready, timeout = 3000) ->
   start = new Date().getTime()
-  condition = false
   wait = ->
-    if (new Date().getTime() - start < timeOutMillis) and not condition
-      condition = (if typeof testFx is 'string' then eval testFx else testFx())
+    if new Date().getTime() - start > timeout
+      console.log JSON.stringify({ error: "Timeout requesting Jasmine test runner!" })
+      phantom.exit(1)
     else
-      if not condition
-        console.log JSON.stringify { error: "Timeout requesting Jasmine test runner!" }
-        phantom.exit(1)
-      else
-        if typeof onReady is 'string' then eval onReady else onReady()
+      if condition()
+        ready()
         clearInterval interval
 
   interval = setInterval wait, 100
 
+# Test if the specs have finished.
+#
+specsReady = ->
+  page.evaluate -> if document.body.querySelector('.finished-at') then true else false
+
+# Extract the data from a Jasmine TrivialReporter generated DOM
+#
+extractResult = ->
+  page.evaluate ->
+    stats = /(\d+) specs, (\d+) failures? in (\d+.\d+)s/.exec document.body.querySelector('.description').innerText
+
+    result = {
+      passed: true
+      stats: {
+        specs: parseInt stats[1]
+        failures: parseInt stats[2]
+        time: parseFloat stats[3]
+      }
+      suites: []
+    }
+
+    for suite in document.body.querySelectorAll('div.jasmine_reporter > div.suite')
+      description = suite.querySelector('a.description')
+
+      suite_ = {
+        description: description.innerText
+        specs: []
+      }
+
+      for spec in suite.querySelectorAll('div.spec')
+        passed = spec.getAttribute('class').indexOf('passed') isnt -1
+        result['passed'] = false if not passed
+
+        spec_ = {
+          description: spec.querySelector('a.description').getAttribute 'title'
+          passed: passed
+        }
+
+        spec_['error_message'] = spec.querySelector('div.resultMessage').innerText if not passed
+
+        suite_['specs'].push spec_
+
+      result['suites'].push suite_
+
+    console.log "JSON_RESULT: #{ JSON.stringify(result, undefined, 2) }"
+
+  phantom.exit()
+
 # Check arguments of the script.
 #
 if phantom.args.length isnt 1
-  console.log JSON.stringify { error: "Wrong usage of PhantomJS script!" }
+  console.log JSON.stringify({ error: "Wrong usage of PhantomJS script!" })
   phantom.exit()
 else
   url = phantom.args[0]
@@ -31,66 +87,16 @@ else
 page = new WebPage()
 
 # Output the Jasmine test runner result as JSON object.
-# Ignore all other calls to console.log
+# Ignore all other calls to console.log that may come from the specs.
 #
 page.onConsoleMessage = (msg) ->
-  console.log(RegExp.$1) if /^JasmineResult: ([\s\S]*)$/.test(msg)
+  console.log(RegExp.$1) if /^JSON_RESULT: ([\s\S]*)$/.test(msg)
 
 # Open web page and run the Jasmine test runner
 #
 page.open url, (status) ->
-
   if status isnt 'success'
-
-    console.log "JasmineResult: #{ JSON.stringify { error: "Unable to access Jasmine specs at #{ url }" } }"
+    console.log "JSON_RESULT: #{ JSON.stringify({ error: "Unable to access Jasmine specs at #{ url }" }) }"
     phantom.exit()
-
   else
-    # Wait until the Jasmine test is run
-    waitFor ->
-      page.evaluate ->
-        if document.body.querySelector '.finished-at' then true else false
-    , ->
-        # Jasmine test runner has finished, extract the result from the DOM
-        page.evaluate ->
-
-          # JSON response to Guard::Jasmine
-          result = {
-            suites: []
-          }
-
-          # Extract runner stats from the HTML
-          stats = /(\d+) specs, (\d+) failures? in (\d+.\d+)s/.exec document.body.querySelector('.description').innerText
-
-          # Add stats to the result
-          result['stats'] = {
-            specs: parseInt stats[1]
-            failures: parseInt stats[2]
-            time: parseFloat stats[3]
-          }
-
-          # Extract failed suites
-          for failedSuite in document.body.querySelectorAll 'div.jasmine_reporter > div.suite.failed'
-            description = failedSuite.querySelector('a.description')
-
-            # Add suite information to the result
-            suite = {
-              description: description.innerText
-              filter: description.getAttribute('href')
-              specs: []
-            }
-
-            # Collect information about each **failing** spec
-            for failedSpec in failedSuite.querySelectorAll 'div.spec.failed'
-              spec = {
-                description: failedSpec.querySelector('a.description').getAttribute 'title'
-                error_message: failedSpec.querySelector('div.messages div.resultMessage').innerText
-              }
-              suite['specs'].push spec
-
-            result['suites'].push suite
-
-          # Write result as JSON string that is parsed by Guard::Jasmine
-          console.log "JasmineResult: #{ JSON.stringify result, undefined, 2 }"
-
-        phantom.exit()
+    waitFor specsReady, extractResult

data/lib/guard/jasmine/runner.rb

@@ -1,3 +1,5 @@
+# coding: utf-8
+
 require 'multi_json'
 
 module Guard
@@ -18,30 +20,50 @@ module Guard
         # @option options [String] :phantomjs_bin the location of the PhantomJS binary
         # @option options [Boolean] :notification show notifications
         # @option options [Boolean] :hide_success hide success message notification
-        # @return [Array<Object>] the result for each suite
+        # @return [Boolean, Array<String>] the status of the run and the failed files
         #
         def run(paths, options = { })
-          return false if paths.empty?
+          return [false, []] if paths.empty?
 
           message = options[:message] || (paths == ['spec/javascripts'] ? 'Run all specs' : "Run specs #{ paths.join(' ') }")
           UI.info message, :reset => true
 
-          paths.inject([]) do |results, file|
-            results << evaluate_result(run_jasmine_spec(file, options), options)
+          results = paths.inject([]) do |results, file|
+            results << evaluate_result(run_jasmine_spec(file, options), file, options)
 
             results
           end.compact
+
+          [response_status_for(results), failed_paths_from(results)]
         end
 
         private
 
+        # Returns the failed spec file names.
+        #
+        # @param [Array<Object>] results the spec runner results
+        # @return [Array<String>] the list of failed spec files
+        #
+        def failed_paths_from(results)
+          results.map { |r| !r['passed'] ? r['file']: nil }.compact
+        end
+
+        # Returns the response status for the given result set.
+        #
+        # @param [Array<Object>] results the spec runner results
+        # @return [Boolean] whether it has passed or not
+        #
+        def response_status_for(results)
+          results.none? { |r| r.has_key?('error') || !r['passed'] }
+        end
+
         # Run the Jasmine spec by executing the PhantomJS script.
         #
         # @param [String] path the path of the spec
         #
         def run_jasmine_spec(file, options)
           suite = jasmine_suite(file, options)
-          Formatter.info("Run Jasmine tests: #{ suite }")
+          Formatter.info("Run Jasmine tests at #{ suite }")
           IO.popen(phantomjs_command(options) + ' ' + suite)
         end
 
@@ -101,16 +123,18 @@ module Guard
         # actions.
         #
         # @param [String] output the JSON output the spec run
+        # @param [String] file the file name of the spec
         # @param [Hash] options the options for the execution
         # @return [Hash] the suite result
         #
-        def evaluate_result(output, options)
+        def evaluate_result(output, file, options)
           result = MultiJson.decode(output.read)
           output.close
 
           if result['error']
             notify_runtime_error(result, options)
           else
+            result['file'] = file
             notify_spec_result(result, options)
           end
 
@@ -144,39 +168,38 @@ module Guard
           time     = result['stats']['time']
           plural   = failures == 1 ? '' : 's'
 
-          message = "Jasmine ran #{ specs } specs, #{ failures } failure#{ plural } in #{ time }s."
+          message = "#{ specs } specs, #{ failures } failure#{ plural }\nin #{ time } seconds"
 
           if failures != 0
-            notify_spec_failures(result, message, options)
+            notify_specdoc(result, message, options)
           else
             Formatter.success(message)
-            Formatter.notify(message, :title => 'Jasmine results') if options[:notification] && !options[:hide_success]
+            Formatter.notify(message, :title => 'Jasmine specs passed') if options[:notification] && !options[:hide_success]
           end
         end
 
-        # Notification about spec failures. This combines the suite
-        # error messages into a single notification.
+        # Specdoc like formatting of the result.
         #
         # @param [Hash] result the suite result
         # @param [String] stats the status information
-        # @param [Hash] options the options for the execution
-        # @option options [Boolean] :notification show notifications
+        # @option options [Boolean] :hide_success hide success message notification
         #
-        def notify_spec_failures(result, stats, options)
-          messages = result['suites'].inject('') do |messages, suite|
+        def notify_specdoc(result, stats, options)
+          result['suites'].each do |suite|
+            Formatter.suite_name("➥ #{ suite['description'] }")
+
             suite['specs'].each do |spec|
-              messages << "Spec '#{ spec['description'] }' failed with '#{ spec['error_message'] }'!\n"
+              if spec['passed']
+                Formatter.success(" ✔ #{ spec['description'] }") if !options[:hide_success]
+              else
+                Formatter.spec_failed(" ✘ #{ spec['description'] } ➤ #{ spec['error_message'] }")
+                Formatter.notify(stats, :title => "#{ spec['description'] }: #{ spec['error_message'] }", :image => :failed, :priority => 2) if options[:notification]
+              end
             end
-
-            messages
           end
 
-          messages << stats
-
-          Formatter.error(messages)
-          Formatter.notify(messages, :title => 'Jasmine results', :image => :failed, :priority => 2) if options[:notification]
+          Formatter.info(stats)
         end
-
       end
     end
   end

data/lib/guard/jasmine/version.rb

@@ -1,6 +1,6 @@
 module Guard
   module JasmineVersion
     # Guard::Jasmine version that is used for the Gem specification
-    VERSION = '0.2.2'
+    VERSION = '0.3.0'
   end
 end

metadata

@@ -5,9 +5,9 @@ version: !ruby/object:Gem::Version
   prerelease: 
   segments: 
   - 0
-  - 2
-  - 2
-  version: 0.2.2
+  - 3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Michael Kessler