guard-jasmine 1.3.0 → 1.19.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2023ac9b80d1f49f03e13afc24c7fa46348b41a1
+  data.tar.gz: 550ac8a2dde8bc3678692d7eb14bef40952f732e
+SHA512:
+  metadata.gz: 5dfee71f3214204be61632de52ebd7c7a73757c2c368b7b11fd6e64945263910c907c11823e2f727c373e29cf1f20ec3828d0ca097670968f24cee46eb22dc7a
+  data.tar.gz: 2c879978c5f288890d1f92f2256b53772f83af2aee98cf3a87ae4fdebc91fbcb03e188645def29a436cf04f90070ca37449c75fff11999ab3ca311151a314832

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2011-2012 Michael Kessler
+Copyright (c) 2011-2013 Michael Kessler
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

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.3, 2.0.0, 2.0.1 and the latest versions of JRuby and Rubinius.
 
 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).
@@ -15,9 +15,14 @@ Ruby.
 * Fast headless testing on [PhantomJS][], a full featured WebKit browser with native support for
 various web standards: DOM handling, CSS selector, JSON, Canvas, and SVG.
 
-* Runs the standard Jasmine test runner, so you can use [Jasminerice][] for integrating [Jasmine][] into the
+* Runs the standard Jasmine test runner, so you can use [Jasminerice][] or [jasmine-rails][] for integrating [Jasmine][] into the
 [Rails asset pipeline][] and write your specs in [CoffeeScript][].
 
+* Integrates [Istanbul](https://github.com/gotwarlost/istanbul) to instrument your code in the asset pipeline and
+generate coverage reports.
+
+* Custom console logger implementation for pretty printing JavaScript objects and DOM elements.
+
 * Can be used to run [Jasmine-species](http://rudylattae.github.com/jasmine-species/) acceptance tests provided by
 [Jasmine Stories](https://github.com/DominikGuzei/jasmine-stories).
 
@@ -25,6 +30,12 @@ various web standards: DOM handling, CSS selector, JSON, Canvas, and SVG.
 
 * Runs on Mac OS X, Linux and Windows.
 
+## ScreenCast
+
+If you are a [RailsCast Pro](http://railscasts.com/pro) subscriber, I recommend to watch
+[#261 Testing JavaScript with Jasmine (revised)](http://railscasts.com/episodes/261-testing-javascript-with-jasmine-revised)
+for an introduction to Jasmine, Jasminerice and Guard::Jasmine.
+
 ## Installation
 
 ### Guard and Guard::Jasmine
@@ -60,7 +71,13 @@ Alternatively you can install [Homebrew][] on Mac OS X and install it with:
 $ brew install phantomjs
 ```
 
-If you are using Ubuntu 10.10, you can install it with apt:
+If you are using Ubuntu 12.04 or above, phantomjs is in the official repositories and can be installed with apt:
+
+```bash
+$ sudo apt-get install phantomjs
+```
+
+For older versions of Ubuntu, you will need to add a repository first:
 
 ```bash
 $ sudo add-apt-repository ppa:jerome-etienne/neoip
@@ -126,6 +143,34 @@ It also creates an empty `spec/javascripts/spec.css` file as it is always reques
 
 Now you can access `/jasmine` when you start your Rails server normally.
 
+### Jasmine-Rails
+
+[jasmine-rails][] is another option for integrating your [Jasmine][] tests with an asset pipeline-enabled Rails application.  The quick-and-dirty recipe for this is:
+
+1. Add `jasmine-rails` to your `Gemfile`:
+
+    ```ruby
+    group :test do
+      gem "jasmine-rails"
+    end
+    ```
+    
+2. Configure a mount point in your application's `routes.rb` (please refer to the [jasmine-rails][] documentation for more details):
+
+    ```ruby
+    mount JasmineRails::Engine => '/specs' if defined?(JasmineRails)
+    ```
+    
+3. Configure **Guard::Jasmine** to reference the mount point in your `Guardfile`:
+
+    ```ruby
+    guard 'jasmine', :server => :webrick, :server_mount => '/specs' do
+      # watch stuff
+    end
+    ```
+    
+4. Profit!  Seriously, you should be able to access the Jasmine runner at `/specs` within your Rails application, *and* **Guard::Jasmine** should run the same specs.  Now no more excuses, get that javascript tested!
+
 ### Jasmine Stories acceptance tests
 
 [Jasmine Stories](https://github.com/DominikGuzei/jasmine-stories) is a Jasminerice clone and that serves
@@ -153,7 +198,7 @@ Now you can access `/jasmine-stories` when you start your Rails server normally.
 accordingly:
 
 ```ruby
-guard :jasmine, :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
 ```
@@ -191,13 +236,7 @@ group :development, :test do
 end
 ```
 
-and generate the configuration files and change the Jasmine url:
-
-```ruby
-guard :jasmine, :jasmine_url => 'http://localhost:8888/' do
-  ...
-end
-```
+and generate the configuration files.
 
 #### Rails 3 without the asset pipeline
 
@@ -223,8 +262,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
@@ -260,15 +299,15 @@ We add support for CoffeeScript specs, using Thin as spec server and adding Jasm
 create a Rack configuration to spin up a mini-Rails app for testing:
 
 ```Ruby
-require 'rails'
-require 'rails/all'
+require 'action_controller/railtie'
 require 'jasminerice'
+require 'guard/jasmine'
 require 'sprockets/railtie'
 require 'jquery-rails'
 
 class JasmineTest < Rails::Application
   routes.append do
-    mount Jasminerice::Engine => '/jasmine'
+    mount Jasminerice::Engine, at: '/jasmine'
   end
 
   config.cache_classes = true
@@ -318,7 +357,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
 ```
@@ -328,33 +367,40 @@ 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,
-                                              # :webrick, :mongrel, :thin, :jasmine_gem
+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: :development
+                                              # default: RAILS_ENV is exists, otherwise :development
 
-:port => 9292                                 # Jasmine server port to use.
-                                              # default: 8888
+server_timeout:  30                           # The number of seconds to wait for the Jasmine spec server
+                                              # default: 15
 
-:phantomjs_bin => '~/bin/phantomjs'           # Path to phantomjs.
+port:  8888                                   # Jasmine server port to use.
+                                              # default: a random, free server port
+
+phantomjs_bin:  '~/bin/phantomjs'             # Path to phantomjs.
                                               # default: auto-detect 'phantomjs'
 
-:timeout => 20000                             # The time in ms to wait for the spec runner to finish.
-                                              # default: 10000
+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).
+                                              # default: ./config.ru
+                                              # This option is useful when using guard-jasmine in a mountable engine
+                                              # and the config.ru is within the dummy app
 ```
 
-If you're setting the `:server` option to `:none`, you can supply the Jasmine runner url manually:
+If you're setting the `:server` option to `:none` or need to access your specs on a other host than `localhost`, you can
+supply the Jasmine runner url manually:
 
 ```ruby
-:jasmine_url => 'http://192.168.1.5/jasmine'  # URL where Jasmine is served.
-                                              # default: http://127.0.0.1:8888/jasmine
+jasmine_url:  'http://192.168.1.5:1234/jasmine'  # URL where Jasmine is served.
+                                                   # default: nil
 ```
-
-Detecting the server with the `auto` option does only detect the jasmine gem or webrick. If you want to use mongrel or
-thins, you have to set it explicit in the server option.
+You may want to have also a fixed port instead of the random generated one.
 
 The reason why the Server environment is set to `development` by default is that in development mode
 the asset pipeline doesn't concatenate the JavaScripts and you'll see the line number in the real file,
@@ -364,7 +410,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.
 
@@ -373,19 +419,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
 ```
@@ -404,19 +450,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
 ```
@@ -431,6 +477,17 @@ The `:errors` option is partially working when using at least PhantomJS version
 [Issue #166](http://code.google.com/p/phantomjs/issues/detail?id=166) for the actual status of retreiving the JavaScript
 stack trace.
 
+### Overwrite options when running all specs
+
+You may want to have different options when the spec runner runs all specs. You can specify the `:run_all` option
+as a Hash that contains any valid runner option and will overwrite the general options.
+
+```ruby
+run_all: { specdoc:  :never }                 # Run all options,
+                                              # Takes any valid option
+                                              # default: {}
+```
+
 #### Console logs
 
 The `:console` options adds captured console logs from the spec runner and adds them to the specdoc. Guard:Jasmine
@@ -458,18 +515,117 @@ You can further customize the log output by implement one of these methods:
 In addition, the console can log jQuery collections and outputs the HTML representation of the element by using the
 jQuery `html()` method.
 
+### Coverage options
+
+Guard::Jasmine supports coverage reports generated by [Istanbul](https://github.com/gotwarlost/istanbul). You need to
+have `istanbul` in your path in order to make this feature work. You can install it with NPM
+
+```ruby
+$ npm install -g istanbul
+```
+
+You also need to explicit enable the coverage support in the options:
+
+```ruby
+coverage: true                                # Enable/disable JavaScript coverage support
+                                              # default: false
+```
+
+### Instrumentation
+
+Istanbul needs to instrument the implementation files so that the execution path can be detected. Guard::Jasmine comes
+with a tilt template that generates instrumented implementation files when using in the asset pipeline. If you do not
+use asset pipeline, than you need to instrument your files on your own, either manually (basic example: `istanbul instrument --output instrumented_scripts scripts`) or by using something like
+[Guard::Process](https://github.com/socialreferral/guard-process). You can get more information about the
+instrumentation with `istanbul help instrument`. You'll also need to update your `:spec_dir` or `jasmine.yml/src_dir` settings to point Guard::Jasmine to these instrumented source files.
+
+**Important**: You need to clear the asset cache when you change this setting, so that already compiled assets will be
+recompiled. Just use the Sprockets supplied Rake task:
+
+```ruby
+$ rake assets:clean
+```
+
+#### Check coverage
+
+By default Guard::Jasmine just outputs the coverage when enable without any effect on the spec run result. You can
+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
+                                              # default: 0
+
+functions_threshold: 85                       # Functions coverage threshold
+                                              # default: 0
+
+branches_threshold: -10                       # Branches coverage threshold
+                                              # default: 0
+
+lines_threshold: -15                          # Lines coverage threshold
+                                              # default: 0
+```
+
+A positive threshold is taken to be the minimum percentage required, a negative threshold represents the maximum number
+of uncovered entities allowed.
+
+#### Coverage report
+
+Guard::Jasmine always shows the Istanbul text report after a spec run that contains the coverage results per file. You
+can also enable two more reports:
+
+```ruby
+coverage_html: true                           # Enable Istanbul HTML coverage report
+                                              # default: false
+
+coverage_html_dir: './coverage'               # Directory to write Istanbul HTML coverage report to
+                                              # default: './coverage'
+
+coverage_summary: true                        # Enable Istanbul summary coverage report
+                                              # default: false
+
+ignore_instrumentation: 'vendor'              # Ignore files matching this regex when instrumenting
+                                              # default: ''
+```
+
+The `:coverage_summary` options disables the detailed file based coverage report by a small summary coverage report.
+
+Both of these results are more useful if they are run against the coverage data from a full spec run, so it's strongly
+advised to enable the `:all_on_start` option.
+
+With Jasmine in the asset pipeline all instrumented implementation files are available in the runtime and when you
+execute a partial spec run it reports a lower coverage for the excluded files, since their associated specs aren't run.
+Guard::Jasmine tries to work around this by merge only the coverage data for the changed files (Istanbul knows the file
+name in opposite to Jasmine).
+
+#### Jenkins CI integration
+
+You can use the Cobertura format to bring coverage support to Jenkins CI, even that Guard::Jasmine has no built in
+support for it. The trick is to post-process the coverage data with istanbul after the spec run:
+
+```ruby
+desc "Run all JavaScript specs with Istanbul"
+task :jscov => :environment do
+  # Run Jasmine tests with code coverage on and generate Jenkins-compatible Jasmine code coverage report file.
+  # Must run assets:clean first to force re-compilation.
+  # Make sure to fail this task if there are unit test failures.
+  # For some reason does not work if run as separate exec's, so combine into one.
+  exec('rake assets:clean; guard-jasmine --coverage --coverage-html --coverage-summary; \
+        code=$?; if [ $code != "0" ]; then exit $code; fi; istanbul report cobertura')
+end
+```
+
 ### System notifications options
 
-These options affects what system notifications (growl, libnotify or notifu) are shown after a spec run:
+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
 ```
 
@@ -506,27 +662,47 @@ Usage:
   guard-jasmine spec
 
 Options:
-  -s, [--server=SERVER]          # Server to start, either `auto`, `none`, `webrick`, `mongrel`,
-                                 # `thin`, `jasmine_gem`
-                                 # Default: auto
-  -p, [--port=N]                 # Server port to use
-                                 # Default: 8888
-  -u, [--url=URL]                # The url of the Jasmine test runner
-                                 # Default: http://localhost:8888/jasmine
-  -b, [--bin=BIN]                # The location of the PhantomJS binary
-                                 # Default: /usr/local/bin/phantomjs
-  -t, [--timeout=N]              # The maximum time in milliseconds to wait
-                                 # for the spec runner to finish
-                                 # Default: 10000
-  -c, [--console=CONSOLE]        # Whether to show console.log statements in the spec runner,
-                                 # either `always`, `never` or `failure`
-                                 # Default: failure
-  -x, [--errors=ERRORS]          # Whether to show errors in the spec runner,
-                                 # either `always`, `never` or `failure`
-                                 # Default: failure
-  -e, [--server-env=SERVER_ENV]  # The server environment to use, for example `development`, `test`
-                                 # Default: test
-
+  -s, [--server=SERVER]                 # Server to start, either `auto`, `webrick`, `mongrel`, `thin`, `puma`
+                                        # `unicorn`, `jasmine_gem` or `none`
+                                        # Default: auto
+  -p, [--port=N]                        # Server port to use
+                                        # Default: Random free port
+      [--verbose]                       # Show the server output in the console
+  -e, [--server-env=SERVER_ENV]         # The server environment to use, for example `development`, `test` etc.
+                                        # Default: test
+      [--server-timeout=N]              # The number of seconds to wait for the Jasmine spec server
+                                        # Default: 15
+  -b, [--bin=BIN]                       # The location of the PhantomJS binary
+  -d, [--spec-dir=SPEC_DIR]             # The directory with the Jasmine specs
+                                        # Default: spec/javascripts
+  -l, [--line-number=N]                 # The line which identifies the spec to be run
+  -u, [--url=URL]                       # The url of the Jasmine test runner_options
+                                        # Default: nil
+  -t, [--timeout=N]                     # The maximum time in seconds to wait for the spec
+                                        # runner to finish
+                                        # Default: 10
+      [--console=CONSOLE]               # Whether to show console.log statements in the spec runner,
+                                        # either `always`, `never` or `failure`
+                                        # Default: failure
+      [--errors=ERRORS]                 # Whether to show errors in the spec runner,
+                                        # either `always`, `never` or `failure`
+                                        # Default: failure
+      [--focus]                         # Specdoc focus to hide successful tests when at least one test fails
+                                        # Default: true
+      [--specdoc=SPECDOC]               # Whether to show successes in the spec runner, either `always`, `never` or `failure`
+                                        # Default: always
+      [--coverage]                      # Whether to enable the coverage support or not
+      [--coverage-html]                 # Whether to generate html coverage report. Implies --coverage
+      [--coverage-html-dir=REPORT_DIR]  # Where to save html coverage reports. Defaults to ./coverage. Implies --coverage-html
+      [--coverage-summary]              # Whether to generate html coverage summary. Implies --coverage
+      [--statements-threshold=N]        # Statements coverage threshold
+                                        # Default: 0
+      [--functions-threshold=N]         # Functions coverage threshold
+                                        # Default: 0
+      [--branches-threshold=N]          # Branches coverage threshold
+                                        # Default: 0
+      [--lines-threshold=N]             # Lines coverage threshold
+                                        # Default: 0
 Run the Jasmine spec runner
 ```
 
@@ -579,14 +755,13 @@ With the given `guard-jasmine` script you're able to configure [Travis CI](http:
 Simply use the `script` setting in your `.travis.yml`:
 
 ```yaml
-script: 'bundle exec guard-jasmine'
+script: 'bundle exec guard-jasmine --server-timeout=60'
 ```
 
-You can also run your Guard::Jasmine specs after your specs that are ran with `rake` by using `after_script`:
+You can also run your Guard::Jasmine specs after your specs that are ran with `rake` by using `&&`:
 
 ```yaml
-script: 'rake spec'
-after_script: 'bundle exec guard-jasmine'
+script: 'rake spec && bundle exec guard-jasmine'
 ```
 
 When using a PhantomJS version prior to 1.5, you need to start `xvfb` before running the specs:
@@ -597,6 +772,9 @@ before_script:
   - "sh -e /etc/init.d/xvfb start"
 ```
 
+**Tip**: It's highly recommended the have a server timeout of at least 60 seconds, since the performance of the Travis VMs seems to
+vary quite a bit; sometimes the Jasmine server starts in 5 seconds, sometimes it takes as long as 50 seconds.
+
 ## How to test a Rails engine with Jasmine Gem
 
 When building an engine, your code lives at the root but the dummy Rails app is in another folder (like `test/dummy` or `spec/dummy`).
@@ -621,17 +799,9 @@ Given your configuration, you could also need to set:
 There are many ways to get your Jasmine specs run within a headless environment. If Guard::Jasmine isn't for you,
 I recommend to check out these other brilliant Jasmine runners:
 
-### Guards
-
-* [guard-jasmine-headless-webkit][], a Guard for [jasmine-headless-webkit][], but doesn't run on JRuby.
-* [guard-jasmine-node][] automatically & intelligently executes Jasmine Node.js specs when files are modified.
-* [guard-jessie][] allows to automatically run you Jasmine specs under Node.js using Jessie runner.
-
-### Standalone
-
-* [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
-featured browser environment.
+* [guard-konacha][], Automatically run [konacha][] tests through Guard.
+* [guard-teabag][], Guard-Teabag: Run Javascript tests with Guard and all the features of [Teabag][]
+* [Karma][] spectacular Test Runner for JavaScript.
 
 ## How to file an issue
 
@@ -665,6 +835,16 @@ Pull requests are very welcome! Please try to follow these simple rules if appli
 For questions please join us in our [Google group](http://groups.google.com/group/guard-dev) or on
 `#guard` (irc.freenode.net).
 
+### Open Commit Bit
+
+Guard has an open commit bit policy: Anyone with an accepted pull request gets added as a repository collaborator.
+Please try to follow these simple rules:
+
+* Commit directly onto the master branch only for typos, improvements to the readme and documentation (please add
+  `[ci skip]` to the commit message).
+* Create a feature branch and open a pull-request early for any new features to get feedback.
+* Make sure you adhere to the general pull request rules above.
+
 ### The guard-jasmine-debug executable
 
 This Guard comes with a small executable `guard-jasmine-debug` that can be used to run the Jasmine test runner on PhantomJS
@@ -676,7 +856,7 @@ $ guard-jasmine-debug
 ```
 
 The only argument that the script takes is the URL to the Jasmine runner, which defaults to
-`http://127.0.0.1:3000/Jasmine`. So you can for example just run a subset of the specs by changing the URL:
+`http://127.0.0.1:3000/jasmine`. So you can for example just run a subset of the specs by changing the URL:
 
 ```bash
 $ guard-jasmine-debug http://127.0.0.1:3000/Jasmine?spec=YourSpec
@@ -684,7 +864,7 @@ $ guard-jasmine-debug http://127.0.0.1:3000/Jasmine?spec=YourSpec
 
 ## Author
 
-Developed by Michael Kessler, sponsored by [mksoft.ch](https://mksoft.ch).
+Developed by Michael Kessler, sponsored by [FlinkFinger](http://www.flinkfinger.com).
 
 If you like Guard::Jasmine, you can watch the repository at [GitHub](https://github.com/netzpirat/guard-jasmine) and
 follow [@netzpirat](https://twitter.com/#!/netzpirat) on Twitter for project updates.
@@ -692,7 +872,7 @@ follow [@netzpirat](https://twitter.com/#!/netzpirat) on Twitter for project upd
 ## Contributors
 
 See the [CHANGELOG](https://github.com/netzpirat/guard-jasmine/blob/master/CHANGELOG.md) and the GitHub list of
-[contributors](https://github.com/netzpirat/haml_coffee_assets/contributors).
+[contributors](https://github.com/netzpirat/guard-jasmine/contributors).
 
 ## Acknowledgment
 
@@ -709,7 +889,7 @@ for it!
 
 (The MIT License)
 
-Copyright (c) 2011-2012 Michael Kessler
+Copyright (c) 2011-2013 Michael Kessler
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
@@ -739,6 +919,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 [PhantomJS build instructions]: http://code.google.com/p/phantomjs/wiki/BuildInstructions
 [Brad Phelan]: http://twitter.com/#!/bradgonesurfing
 [Jasminerice]: https://github.com/bradphelan/jasminerice
+[jasmine-rails]: https://github.com/searls/jasmine-rails
 [Pivotal Labs]: http://pivotallabs.com/
 [Jasmine]: http://pivotal.github.com/jasmine/
 [the Jasmine Gem]: https://github.com/pivotal/jasmine-gem
@@ -746,14 +927,12 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 [CoffeeScript]: http://jashkenas.github.com/coffee-script/
 [Rails 3.1 asset pipeline]: http://guides.rubyonrails.org/asset_pipeline.html
 [Homebrew]: http://mxcl.github.com/homebrew/
-[Jezebel]: https://github.com/benrady/jezebel
-[Jessie]: https://github.com/futuresimple/jessie
-[guard-jasmine-headless-webkit]: https://github.com/johnbintz/guard-jasmine-headless-webkit
-[jasmine-headless-webkit]: https://github.com/johnbintz/jasmine-headless-webkit/
-[Evergreen]: https://github.com/jnicklas/evergreen
 [PhantomJS script]: https://github.com/netzpirat/guard-jasmine/blob/master/lib/guard/jasmine/phantomjs/guard-jasmine.coffee
 [Guard::CoffeeScript]: https://github.com/guard/guard-coffeescript
 [Sinon.JS]: http://sinonjs.org
-[guard-jasmine-node]: https://github.com/guard/guard-jasmine-node
-[guard-jessie]: https://github.com/guard/guard-jessie
 [Rails asset pipeline]: http://guides.rubyonrails.org/asset_pipeline.html
+[guard-konacha]: https://github.com/alexgb/guard-konacha
+[konacha]: https://github.com/jfirebaugh/konacha
+[Karma]: https://github.com/karma-runner/karma
+[guard-teabag]: https://github.com/modeset/guard-teabag
+[Teabag]: https://github.com/modeset/teabag

data/bin/guard-jasmine-debug

@@ -1,3 +1,3 @@
 #!/usr/bin/env ruby
-script = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'guard', 'jasmine', 'phantomjs', 'guard-jasmine.coffee'))
+script = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'guard', 'jasmine', 'phantomjs', 'guard-jasmine.js'))
 puts `phantomjs #{ script } #{ ARGV[0] } #{ ARGV[1] }`