guard-jasmine 1.14.0 → 1.15.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 35f755fd7988fb41009cc1377514706c7d2d8700
+  data.tar.gz: 2d67d8daefc22be085e6d883778766a8e10e1795
+SHA512:
+  metadata.gz: a563757370395d7a09befdea85915bebcbff02c4fda5d0244894ea0b86b29a2f0dc85c74e3d558b7a1c83d246a4d45040540f7f1dfa43cd5212c103a5beddd5e
+  data.tar.gz: 9433f80970d0d1a4b6347c15e0b580658ed2bd4939db6bb157ef538c62eff82ab125294807852c7938e5221a1702db8250e11380a4c373261a6f48a36875b868

data/README.md

@@ -2,7 +2,7 @@
 
 Guard::Jasmine automatically tests your Jasmine specs when files are modified.
 
-Tested on MRI Ruby 1.8.7, 1.9.2, 1.9.3, REE and the latest versions of JRuby and Rubinius.
+Tested on MRI Ruby 1.9.2, 1.9.3, 2.0.0 and the latest version of JRuby.
 
 If you have any questions please join us on our [Google group](http://groups.google.com/group/guard-dev) or on `#guard`
 (irc.freenode.net).
@@ -170,7 +170,7 @@ Now you can access `/jasmine-stories` when you start your Rails server normally.
 accordingly:
 
 ```ruby
-guard :jasmine, :port => 8888, :jasmine_url => 'http://127.0.0.1:8888/jasmine-stories' do
+guard :jasmine, port: 8888, jasmine_url: 'http://127.0.0.1:8888/jasmine-stories' do
   ...
 end
 ```
@@ -234,8 +234,8 @@ It is also possible to use CoffeeScript in this setup, by using [Guard::CoffeeSc
 specs. Just add something like this *before* Guard::Jasmine:
 
 ```ruby
-guard 'coffeescript', :input => 'app/coffeescripts',  :output => 'public/javascripts'
-guard 'coffeescript', :input => 'spec/coffeescripts', :output => 'spec/javascripts'
+guard 'coffeescript', input: 'app/coffeescripts',  output: 'public/javascripts'
+guard 'coffeescript', input: 'spec/coffeescripts', output: 'spec/javascripts'
 ```
 
 ## Ruby projects
@@ -279,7 +279,7 @@ require 'jquery-rails'
 
 class JasmineTest < Rails::Application
   routes.append do
-    mount Jasminerice::Engine => '/jasmine'
+    mount Jasminerice::Engine: '/jasmine'
   end
 
   config.cache_classes = true
@@ -329,7 +329,7 @@ There are many options that can customize Guard::Jasmine to your needs. Options
 defining the Guard in your `Guardfile`:
 
 ```ruby
-guard 'jasmine', :all_on_start => false, :specdoc => :always do
+guard 'jasmine', all_on_start: false, specdoc: :always do
   ...
 end
 ```
@@ -339,27 +339,27 @@ end
 The server options configures the server environment that is needed to run Guard::Jasmine:
 
 ```ruby
-:server => :jasmine_gem                       # Jasmine server to use, either :auto, :none,
+server:  :jasmine_gem                         # Jasmine server to use, either :auto, :none,
                                               # :webrick, :mongrel, :thin, :unicorn, :jasmine_gem, :puma
                                               # default: :auto
 
-:server_env => :test                          # Jasmine server Rails environment to set,
+server_env:  :test                            # Jasmine server Rails environment to set,
                                               # e.g. :development or :test
                                               # default: RAILS_ENV is exists, otherwise :development
 
-:server_timeout => 30                         # The number of seconds to wait for the Jasmine spec server
+server_timeout:  30                           # The number of seconds to wait for the Jasmine spec server
                                               # default: 15
 
-:port => 8888                                 # Jasmine server port to use.
+port:  8888                                   # Jasmine server port to use.
                                               # default: a random, free server port
 
-:phantomjs_bin => '~/bin/phantomjs'           # Path to phantomjs.
+phantomjs_bin:  '~/bin/phantomjs'             # Path to phantomjs.
                                               # default: auto-detect 'phantomjs'
 
-:timeout => 20                                # The time in seconds to wait for the spec runner to finish.
+timeout:  20                                  # The time in seconds to wait for the spec runner to finish.
                                               # default: 10
 
-:rackup_config => 'spec/dummy/config.ru'      # Path to rackup config file (i.e. for webrick, mongrel, thin, unicorn, puma).
+rackup_config:  'spec/dummy/config.ru'        # Path to rackup config file (i.e. for webrick, mongrel, thin, unicorn, puma).
                                               # default: ./config.ru
                                               # This option is useful when using guard-jasmine in a mountable engine
                                               # and the config.ru is within the dummy app
@@ -369,7 +369,7 @@ If you're setting the `:server` option to `:none` or need to access your specs o
 supply the Jasmine runner url manually:
 
 ```ruby
-:jasmine_url => 'http://192.168.1.5:1234/jasmine'  # URL where Jasmine is served.
+jasmine_url:  'http://192.168.1.5:1234/jasmine'  # URL where Jasmine is served.
                                                    # default: nil
 ```
 You may want to have also a fixed port instead of the random generated one.
@@ -382,7 +382,7 @@ instead of a ridiculous high line number in a single, very large JavaScript.
 
 If you supply an unknown server name as the `:server` option, then Guard::Jasmine will execute
 a `rake` task with the given server name as task in a child process. For example, if you configure
-`:server => 'start_my_server'`, then the command `rake start_my_server` will be executed and
+`server:  'start_my_server'`, then the command `rake start_my_server` will be executed and
 you have to make sure the server starts on the port that you can get from the `JASMINE_PORT`
 environment variable.
 
@@ -391,19 +391,19 @@ environment variable.
 The spec runner options configures the behavior driven development (or BDD) cycle:
 
 ```ruby
-:spec_dir => 'app/spec'                       # Directory with the Jasmine specs.
+spec_dir:  'app/spec'                         # Directory with the Jasmine specs.
                                               # default: 'spec/javascripts'
 
-:clean => false                               # Clean the spec list by only keep Jasmine specs within the project.
+clean:  false                                 # Clean the spec list by only keep Jasmine specs within the project.
                                               # default: true
 
-:all_on_start => false                        # Run all suites on start.
+all_on_start:  false                          # Run all suites on start.
                                               # default: true
 
-:keep_failed => false                         # Keep failed suites and add them to the next run again.
+keep_failed:  false                           # Keep failed suites and add them to the next run again.
                                               # default: true
 
-:all_after_pass => false                      # Run all suites after a suite has passed again
+all_after_pass:  false                        # Run all suites after a suite has passed again
                                               # after failing.
                                               # default: true
 ```
@@ -422,19 +422,19 @@ Guard::Jasmine can generate an RSpec like specdoc in the console after running t
 be shown in the console:
 
 ```ruby
-:specdoc => :always                           # Specdoc output options,
+specdoc: :always                              # Specdoc output options,
                                               # either :always, :never or :failure
                                               # default: :failure
 
-:focus => false                               # Specdoc focus to hide successful specs when
+focus: false                                  # Specdoc focus to hide successful specs when
                                               # at least one spec fails.
                                               # default: true
 
-:console => :always                           # Console.log output options,
+console: :always                              # Console.log output options,
                                               # either :always, :never or :failure
                                               # default: :failure
 
-:errors => :always                            # Error output options,
+errors: :always                               # Error output options,
                                               # either :always, :never or :failure
                                               # default: :failure
 ```
@@ -455,7 +455,7 @@ You may want to have different options when the spec runner runs all specs. You
 as a Hash that contains any valid runner option and will overwrite the general options.
 
 ```ruby
-:run_all => { :specdoc => :never }            # Run all options,
+run_all: { specdoc:  :never }                 # Run all options,
                                               # Takes any valid option
                                               # default: {}
 ```
@@ -499,7 +499,7 @@ $ npm install -g istanbul
 You also need to explicit enable the coverage support in the options:
 
 ```ruby
-:coverage => true                             # Enable/disable JavaScript coverage support
+coverage: true                                # Enable/disable JavaScript coverage support
                                               # default: false
 ```
 
@@ -524,16 +524,16 @@ By default Guard::Jasmine just outputs the coverage when enable without any effe
 make Guard::Jasmine fail the spec run when a given threshold is not met. You can set the following thresholds:
 
 ```ruby
-:statements_threshold => 95                   # Statements coverage threshold
+statements_threshold: 95                      # Statements coverage threshold
                                               # default: 0
 
-:functions_threshold => 85                    # Functions coverage threshold
+functions_threshold: 85                       # Functions coverage threshold
                                               # default: 0
 
-:branches_threshold => -10                    # Branches coverage threshold
+branches_threshold: -10                       # Branches coverage threshold
                                               # default: 0
 
-:lines_threshold => -15                       # Lines coverage threshold
+lines_threshold: -15                          # Lines coverage threshold
                                               # default: 0
 ```
 
@@ -546,10 +546,10 @@ Guard::Jasmine always shows the Istanbul text report after a spec run that conta
 can also enable two more reports:
 
 ```ruby
-:coverage_html => true                        # Enable Istanbul HTML coverage report
+coverage_html: true                           # Enable Istanbul HTML coverage report
                                               # default: false
 
-:coverage_summary => true                     # Enable Istanbul summary coverage report
+coverage_summary: true                        # Enable Istanbul summary coverage report
                                               # default: false
 ```
 
@@ -568,13 +568,13 @@ name in opposite to Jasmine).
 These options affects what system notifications are shown after a spec run:
 
 ```ruby
-:notifications => false                       # Show success and error notifications.
+notifications: false                          # Show success and error notifications.
                                               # default: true
 
-:hide_success => true                         # Disable successful spec run notification.
+hide_success: true                            # Disable successful spec run notification.
                                               # default: false
 
-:max_error_notify => 5                        # Maximum error notifications to show.
+max_error_notify: 5                           # Maximum error notifications to show.
                                               # default: 3
 ```
 

data/lib/guard/jasmine.rb

@@ -22,32 +22,32 @@ module Guard
     attr_accessor :last_run_failed, :last_failed_paths, :run_all_options
 
     DEFAULT_OPTIONS = {
-      :server               => :auto,
-      :server_env           => ENV['RAILS_ENV'] || 'development',
-      :server_timeout       => 60,
-      :port                 => nil,
-      :rackup_config        => nil,
-      :jasmine_url          => nil,
-      :timeout              => 60,
-      :spec_dir             => 'spec/javascripts',
-      :notification         => true,
-      :hide_success         => false,
-      :all_on_start         => true,
-      :keep_failed          => true,
-      :clean                => true,
-      :all_after_pass       => true,
-      :max_error_notify     => 3,
-      :specdoc              => :failure,
-      :console              => :failure,
-      :errors               => :failure,
-      :focus                => true,
-      :coverage             => false,
-      :coverage_html        => false,
-      :coverage_summary     => false,
-      :statements_threshold => 0,
-      :functions_threshold  => 0,
-      :branches_threshold   => 0,
-      :lines_threshold      => 0
+      server:               :auto,
+      server_env:           ENV['RAILS_ENV'] || 'development',
+      server_timeout:       60,
+      port:                 nil,
+      rackup_config:        nil,
+      jasmine_url:          nil,
+      timeout:              60,
+      spec_dir:             nil,
+      notification:         true,
+      hide_success:         false,
+      all_on_start:         true,
+      keep_failed:          true,
+      clean:                true,
+      all_after_pass:       true,
+      max_error_notify:     3,
+      specdoc:              :failure,
+      console:              :failure,
+      errors:               :failure,
+      focus:                true,
+      coverage:             false,
+      coverage_html:        false,
+      coverage_summary:     false,
+      statements_threshold: 0,
+      functions_threshold:  0,
+      branches_threshold:   0,
+      lines_threshold:      0
     }
 
     # Initialize Guard::Jasmine.
@@ -84,11 +84,14 @@ module Guard
     # @option options [Hash] :run_all options overwrite options when run all specs
     #
     def initialize(watchers = [], options = { })
-      options[:port] ||= Jasmine.find_free_server_port
-      options[:jasmine_url] = "http://localhost:#{ options[:port] }#{ options[:server] == :jasmine_gem ? '/' : '/jasmine' }" unless options[:jasmine_url]
       options = DEFAULT_OPTIONS.merge(options)
-      options[:specdoc] = :failure if ![:always, :never, :failure].include? options[:specdoc]
-      options[:server] ||= :auto
+
+      options[:spec_dir]    ||= File.exists?(File.join('spec', 'javascripts')) ? File.join('spec', 'javascripts') : 'spec'
+      options[:port]        ||= Jasmine.find_free_server_port
+      options[:server]      ||= :auto
+      options[:server]        = ::Guard::Jasmine::Server.detect_server(options[:spec_dir]) if options[:server] == :auto
+      options[:jasmine_url]   = "http://localhost:#{ options[:port] }#{ options[:server] == :jasmine_gem ? '/' : '/jasmine' }" unless options[:jasmine_url]
+      options[:specdoc]       = :failure if ![:always, :never, :failure].include? options[:specdoc]
       options[:phantomjs_bin] = Jasmine.which('phantomjs') unless options[:phantomjs_bin]
 
       self.run_all_options = options.delete(:run_all) || { }

data/lib/guard/jasmine/cli.rb

@@ -5,6 +5,7 @@ require 'guard/jasmine/runner'
 require 'guard/jasmine/formatter'
 require 'guard/jasmine/server'
 require 'guard/jasmine/util'
+require 'guard/jasmine/server'
 
 module Guard
   class Jasmine
@@ -23,114 +24,113 @@ module Guard
       desc 'spec', 'Run the Jasmine spec runner_options'
 
       method_option :server,
-                    :type    => :string,
-                    :aliases => '-s',
-                    :default => 'auto',
-                    :desc    => 'Server to start, either `auto`, `webrick`, `mongrel`, `thin`, `unicorn`, `jasmine_gem` or `none`'
+                    type:    :string,
+                    aliases: '-s',
+                    default: 'auto',
+                    desc:    'Server to start, either `auto`, `webrick`, `mongrel`, `thin`, `unicorn`, `jasmine_gem` or `none`'
 
       method_option :port,
-                    :type    => :numeric,
-                    :aliases => '-p',
-                    :desc    => 'Server port to use'
+                    type:    :numeric,
+                    aliases: '-p',
+                    desc:    'Server port to use'
 
       method_option :server_env,
-                    :type    => :string,
-                    :aliases => '-e',
-                    :default => ENV['RAILS_ENV'] || 'test',
-                    :desc    => 'The server environment to use, for example `development`, `test` etc.'
+                    type:    :string,
+                    aliases: '-e',
+                    default: ENV['RAILS_ENV'] || 'test',
+                    desc:    'The server environment to use, for example `development`, `test` etc.'
 
       method_option :server_timeout,
-                    :type    => :numeric,
-                    :default => 60,
-                    :desc    => 'The number of seconds to wait for the Jasmine spec server'
+                    type:    :numeric,
+                    default: 60,
+                    desc:    'The number of seconds to wait for the Jasmine spec server'
 
       method_option :verbose,
-                    :type    => :boolean,
-                    :default => false,
-                    :desc    => 'Show the server output in the console'
+                    type:    :boolean,
+                    default: false,
+                    desc:    'Show the server output in the console'
 
       method_option :rackup_config,
-                    :type    => :string,
-                    :aliases => '-c',
-                    :desc    => 'The rackup config to use (jasminerice only)'
+                    type:    :string,
+                    aliases: '-c',
+                    desc:    'The rackup config to use (jasminerice only)'
 
       method_option :bin,
-                    :type    => :string,
-                    :aliases => '-b',
-                    :desc    => 'The location of the PhantomJS binary'
+                    type:    :string,
+                    aliases: '-b',
+                    desc:    'The location of the PhantomJS binary'
 
       method_option :spec_dir,
-                    :type    => :string,
-                    :aliases => '-d',
-                    :default => 'spec/javascripts',
-                    :desc    => 'The directory with the Jasmine specs'
+                    type:    :string,
+                    aliases: '-d',
+                    desc:    'The directory with the Jasmine specs'
 
       method_option :url,
-                    :type    => :string,
-                    :aliases => '-u',
-                    :desc    => 'The url of the Jasmine test runner'
+                    type:    :string,
+                    aliases: '-u',
+                    desc:    'The url of the Jasmine test runner'
 
       method_option :timeout,
-                    :type    => :numeric,
-                    :aliases => '-t',
-                    :default => 60,
-                    :desc    => 'The maximum time in seconds to wait for the spec runner to finish'
+                    type:    :numeric,
+                    aliases: '-t',
+                    default: 60,
+                    desc:    'The maximum time in seconds to wait for the spec runner to finish'
 
       method_option :console,
-                    :type    => :string,
-                    :default => 'failure',
-                    :desc    => 'Whether to show console.log statements in the spec runner, either `always`, `never` or `failure`'
+                    type:    :string,
+                    default: 'failure',
+                    desc:    'Whether to show console.log statements in the spec runner, either `always`, `never` or `failure`'
 
       method_option :errors,
-                    :type    => :string,
-                    :default => 'failure',
-                    :desc    => 'Whether to show errors in the spec runner, either `always`, `never` or `failure`'
+                    type:    :string,
+                    default: 'failure',
+                    desc:    'Whether to show errors in the spec runner, either `always`, `never` or `failure`'
 
       method_option :focus,
-                    :type    => :boolean,
-                    :aliases => '-f',
-                    :default => true,
-                    :desc    => 'Specdoc focus to hide successful tests when at least one test fails'
+                    type:    :boolean,
+                    aliases: '-f',
+                    default: true,
+                    desc:    'Specdoc focus to hide successful tests when at least one test fails'
 
       method_option :specdoc,
-                    :type    => :string,
-                    :default => :always,
-                    :desc    => 'Whether to show successes in the spec runner, either `always`, `never` or `failure`'
+                    type:    :string,
+                    default: :always,
+                    desc:    'Whether to show successes in the spec runner, either `always`, `never` or `failure`'
 
       method_option :coverage,
-                    :type    => :boolean,
-                    :default => false,
-                    :desc    => 'Whether to enable the coverage support or not'
+                    type:    :boolean,
+                    default: false,
+                    desc:    'Whether to enable the coverage support or not'
 
       method_option :coverage_html,
-                    :type    => :boolean,
-                    :default => false,
-                    :desc    => 'Whether to generate html coverage report. Implies --coverage'
+                    type:    :boolean,
+                    default: false,
+                    desc:    'Whether to generate html coverage report. Implies --coverage'
 
       method_option :coverage_summary,
-                    :type    => :boolean,
-                    :default => false,
-                    :desc    => 'Whether to generate html coverage summary. Implies --coverage'
+                    type:    :boolean,
+                    default: false,
+                    desc:    'Whether to generate html coverage summary. Implies --coverage'
 
       method_option :statements_threshold,
-                    :type    => :numeric,
-                    :default => 0,
-                    :desc    => 'Statements coverage threshold'
+                    type:    :numeric,
+                    default: 0,
+                    desc:    'Statements coverage threshold'
 
       method_option :functions_threshold,
-                    :type    => :numeric,
-                    :default => 0,
-                    :desc    => 'Functions coverage threshold'
+                    type:    :numeric,
+                    default: 0,
+                    desc:    'Functions coverage threshold'
 
       method_option :branches_threshold,
-                    :type    => :numeric,
-                    :default => 0,
-                    :desc    => 'Branches coverage threshold'
+                    type:    :numeric,
+                    default: 0,
+                    desc:    'Branches coverage threshold'
 
       method_option :lines_threshold,
-                    :type    => :numeric,
-                    :default => 0,
-                    :desc    => 'Lines coverage threshold'
+                    type:    :numeric,
+                    default: 0,
+                    desc:    'Lines coverage threshold'
 
       # Run the Guard::Jasmine::Runner with options from
       # the command line.
@@ -138,19 +138,17 @@ module Guard
       # @param [Array<String>] paths the name of the specs to run
       #
       def spec(*paths)
-        paths = [options.spec_dir] if paths.empty?
-
-        runner_options                        = { }
+        runner_options                        = {}
         runner_options[:port]                 = options.port || CLI.find_free_server_port
+        runner_options[:spec_dir]             = options.spec_dir || (File.exists?(File.join('spec', 'javascripts')) ? File.join('spec', 'javascripts') : 'spec')
+        runner_options[:server]               = options.server.to_sym == :auto ? ::Guard::Jasmine::Server.detect_server(runner_options[:spec_dir]) : options.server.to_sym
         runner_options[:jasmine_url]          = options.url || "http://localhost:#{ runner_options[:port] }#{ options.server.to_sym == :jasmine_gem ? '/' : '/jasmine' }"
         runner_options[:phantomjs_bin]        = options.bin || CLI.which('phantomjs')
         runner_options[:timeout]              = options.timeout
         runner_options[:verbose]              = options.verbose
-        runner_options[:server]               = options.server.to_sym
         runner_options[:server_env]           = options.server_env
         runner_options[:server_timeout]       = options.server_timeout
         runner_options[:rackup_config]        = options.rackup_config
-        runner_options[:spec_dir]             = options.spec_dir
         runner_options[:console]              = [:always, :never, :failure].include?(options.console.to_sym) ? options.console.to_sym : :failure
         runner_options[:errors]               = [:always, :never, :failure].include?(options.errors.to_sym) ? options.errors.to_sym : :failure
         runner_options[:specdoc]              = [:always, :never, :failure].include?(options.specdoc.to_sym) ? options.specdoc.to_sym : :always
@@ -166,6 +164,8 @@ module Guard
         runner_options[:hide_success]         = true
         runner_options[:max_error_notify]     = 0
 
+        paths = [runner_options[:spec_dir]] if paths.empty?
+
         if CLI.phantomjs_bin_valid?(runner_options[:phantomjs_bin])
           catch(:task_has_failed) do
             ::Guard::Jasmine::Server.start(runner_options) unless runner_options[:server] == :none

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

@@ -24,7 +24,7 @@ errors = {}
 # Catch JavaScript errors
 #
 page.onError = (msg, trace) ->
-  if currentSpecId && currentSpecId isnt -1
+  if currentSpecId
     errors[currentSpecId] ||= []
     errors[currentSpecId].push({ msg: msg, trace: trace })
 
@@ -42,7 +42,7 @@ page.onConsoleMessage = (msg, line, source) ->
     logs[currentSpecId] = []
 
   else
-    logs[currentSpecId].push(msg) if currentSpecId isnt -1
+    logs[currentSpecId].push(msg)
 
 # Initialize the page before the JavaScript is run.
 #

data/lib/guard/jasmine/phantomjs/guard-jasmine.js

@@ -1,3 +1,4 @@
+// Generated by CoffeeScript 1.3.3
 (function() {
   var currentSpecId, errors, logs, options, page, specsReady, waitFor;
 
@@ -21,7 +22,7 @@
   errors = {};
 
   page.onError = function(msg, trace) {
-    if (currentSpecId && currentSpecId !== -1) {
+    if (currentSpecId) {
       errors[currentSpecId] || (errors[currentSpecId] = []);
       return errors[currentSpecId].push({
         msg: msg,
@@ -44,9 +45,7 @@
       currentSpecId = Number(RegExp.$1);
       return logs[currentSpecId] = [];
     } else {
-      if (currentSpecId !== -1) {
-        return logs[currentSpecId].push(msg);
-      }
+      return logs[currentSpecId].push(msg);
     }
   };
 

data/lib/guard/jasmine/phantomjs/lib/result.js

@@ -1,3 +1,4 @@
+// Generated by CoffeeScript 1.3.3
 (function() {
   var Result;
 
@@ -76,6 +77,24 @@
       return suite;
     };
 
+    Result.prototype.addGlobalErrors = function(suite) {
+      var b, err, errMsg, globalErrors, noSpecs, noSuites, _i, _len, _ref;
+      noSuites = !suite.suites || suite.suites.length === 0;
+      noSpecs = !suite.specs || suite.specs.length === 0;
+      globalErrors = this.errors[-1] && this.errors[-1].length !== 0;
+      if (noSuites && noSpecs && globalErrors) {
+        err = this.errors[-1][0];
+        errMsg = [err.msg];
+        _ref = err.trace;
+        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+          b = _ref[_i];
+          errMsg.push("\n  " + b.file + ":" + b.line + " " + b["function"]);
+        }
+        suite.error = errMsg.join("");
+        return suite.passed = false;
+      }
+    };
+
     Result.prototype.cleanResult = function(suite) {
       var s, spec, _i, _len, _ref;
       suite.suites = (function() {
@@ -106,6 +125,7 @@
       }
       if (this.options.errors !== 'never') {
         this.addErrors(this.result);
+        this.addGlobalErrors(this.result);
       }
       this.cleanResult(this.result);
       return this.result;

data/lib/guard/jasmine/phantomjs/src/result.coffee

@@ -45,6 +45,19 @@ class Result
 
     suite
 
+  addGlobalError: (suite) ->
+    noSuites = !suite.suites || suite.suites.length == 0
+    noSpecs = !suite.specs || suite.specs.length == 0
+    globalErrors = @errors[-1] && @errors[-1].length != 0
+
+    if noSuites && noSpecs && globalErrors
+      err = @errors[-1][0]
+      errMsg = [ err.msg ]
+      for b in err.trace
+        errMsg.push "\n  #{b.file}:#{b.line} #{b.function}"
+      suite.error = errMsg.join("")
+      suite.passed = false
+
   # Clean unnecessary properties from the result
   #
   # @param [Object] suite the suite result
@@ -69,7 +82,9 @@ class Result
   #
   process: ->
     @addLogs(@result) if @options.console isnt 'never'
-    @addErrors(@result) if @options.errors isnt 'never'
+    if @options.errors isnt 'never'
+      @addErrors(@result)
+      @addGlobalError(@result)
     @cleanResult(@result)
 
     @result

data/lib/guard/jasmine/runner.rb

@@ -64,7 +64,7 @@ module Guard
                       "Run Jasmine suite#{ paths.size == 1 ? '' : 's' } #{ paths.join(' ') }"
                     end
 
-          Formatter.info(message, :reset => true)
+          Formatter.info(message, reset: true)
         end
 
         # Returns the failed spec file names.
@@ -167,7 +167,7 @@ module Guard
           json = json.encode('UTF-8') if json.respond_to?(:encode)
 
           begin
-            result = MultiJson.decode(json, { :max_nesting => false })
+            result = MultiJson.decode(json, { max_nesting: false })
 
             if result['error']
               notify_runtime_error(result, options)
@@ -204,7 +204,7 @@ module Guard
         def notify_runtime_error(result, options)
           message = "An error occurred: #{ result['error'] }"
           Formatter.error(message)
-          Formatter.notify(message, :title => 'Jasmine error', :image => :failed, :priority => 2) if options[:notification]
+          Formatter.notify(message, title: 'Jasmine error', image: :failed, priority: 2) if options[:notification]
         end
 
         # Notification about a spec run, success or failure,
@@ -231,12 +231,12 @@ module Guard
           if passed
             report_specdoc(result, passed, options)
             Formatter.success(message)
-            Formatter.notify(full_message, :title => 'Jasmine suite passed') if options[:notification] && !options[:hide_success]
+            Formatter.notify(full_message, title: 'Jasmine suite passed') if options[:notification] && !options[:hide_success]
           else
             report_specdoc(result, passed, options)
             Formatter.error(message)
             notify_errors(result, options)
-            Formatter.notify(full_message, :title => 'Jasmine suite failed', :image => :failed, :priority => 2) if options[:notification]
+            Formatter.notify(full_message, title: 'Jasmine suite failed', image: :failed, priority: 2) if options[:notification]
           end
 
           Formatter.info("Done.\n")
@@ -307,10 +307,10 @@ module Guard
 
             if failed
               Formatter.error coverage
-              Formatter.notify(coverage, :title => 'Code coverage failed', :image => :failed, :priority => 2) if options[:notification]
+              Formatter.notify(coverage, title: 'Code coverage failed', image: :failed, priority: 2) if options[:notification]
             else
               Formatter.success 'Code coverage succeed'
-              Formatter.notify('All code is adequately covered with specs', :title => 'Code coverage succeed') if options[:notification] && !options[:hide_success]
+              Formatter.notify('All code is adequately covered with specs', title: 'Code coverage succeed') if options[:notification] && !options[:hide_success]
             end
           end
         end
@@ -523,9 +523,9 @@ module Guard
             if !spec['passed'] && options[:max_error_notify] > index
               msg = spec['messages'].map { |message| format_message(message, true) }.join(', ')
               Formatter.notify("#{ spec['description'] }: #{ msg }",
-                               :title    => 'Jasmine spec failed',
-                               :image    => :failed,
-                               :priority => 2) if options[:notification]
+                               title:    'Jasmine spec failed',
+                               image:    :failed,
+                               priority: 2) if options[:notification]
             end
           end
         end
@@ -575,17 +575,17 @@ module Guard
         #
         def update_coverage(coverage, file, options)
           if file == options[:spec_dir]
-            File.write(coverage_file, MultiJson.encode(coverage, { :max_nesting => false }))
+            File.write(coverage_file, MultiJson.encode(coverage, { max_nesting: false }))
           else
             if File.exist?(coverage_file)
               impl     = file.sub('_spec', '').sub(options[:spec_dir], '')
-              coverage = MultiJson.decode(File.read(coverage_file), { :max_nesting => false })
+              coverage = MultiJson.decode(File.read(coverage_file), { max_nesting: false })
 
               coverage.each do |coverage_file, data|
                 coverage[coverage_file] = data if coverage_file == impl
               end
 
-              File.write(coverage_file, MultiJson.encode(coverage, { :max_nesting => false }))
+              File.write(coverage_file, MultiJson.encode(coverage, { max_nesting: false }))
             else
               File.write(coverage_file, MultiJson.encode({ }))
             end

data/lib/guard/jasmine/server.rb

@@ -27,7 +27,6 @@ module Guard
         #
         def start(options)
           server  = options[:server]
-          server  = detect_server(options[:spec_dir]) if server == :auto
           port    = options[:port]
           timeout = options[:server_timeout]
 
@@ -54,6 +53,29 @@ module Guard
           end
         end
 
+        # Detect the server to use
+        #
+        # @param [String] spec_dir the spec directory
+        # @return [Symbol] the server strategy
+        #
+        def detect_server(spec_dir)
+          if File.exists?('config.ru')
+            %w(unicorn thin mongrel).each do |server|
+              begin
+                require server
+                return server.to_sym
+              rescue LoadError
+                # Ignore missing server and try next
+              end
+            end
+            :webrick
+          elsif spec_dir && File.exists?(File.join(spec_dir, 'support', 'jasmine.yml'))
+            :jasmine_gem
+          else
+            :none
+          end
+        end
+
         private
 
         # Start the Rack server of the current project. This
@@ -123,29 +145,6 @@ module Guard
           ::Guard::UI.error "Cannot start Rake task server: #{ e.message }"
         end
 
-        # Detect the server to use
-        #
-        # @param [String] spec_dir the spec directory
-        # @return [Symbol] the server strategy
-        #
-        def detect_server(spec_dir)
-          if File.exists?('config.ru')
-            %w(unicorn thin mongrel).each do |server|
-              begin
-                require server
-                return server.to_sym
-              rescue LoadError
-                # Ignore missing server and try next
-              end
-            end
-            :webrick
-          elsif File.exists?(File.join(spec_dir, 'support', 'jasmine.yml'))
-            :jasmine_gem
-          else
-            :none
-          end
-        end
-
         # Wait until the Jasmine test server is running.
         #
         # @param [Number] port the server port

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 = '1.14.0'
+    VERSION = '1.15.0'
   end
 end

metadata

@@ -1,94 +1,83 @@
 --- !ruby/object:Gem::Specification
 name: guard-jasmine
 version: !ruby/object:Gem::Version
-  version: 1.14.0
-  prerelease: 
+  version: 1.15.0
 platform: ruby
 authors:
 - Michael Kessler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-03 00:00:00.000000000 Z
+date: 2013-04-08 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: 1.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: multi_json
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: childprocess
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   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: Guard::Jasmine automatically tests your Jasmine specs on PhantomJS
@@ -128,27 +117,26 @@ files:
 - README.md
 homepage: https://github.com/netzpirat/guard-jasmine
 licenses: []
+metadata: {}
 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: 1.3.6
 requirements: []
 rubyforge_project: guard-jasmine
-rubygems_version: 1.8.24
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Guard gem for headless testing with Jasmine
 test_files: []
 has_rdoc: