guard-jasmine 1.19.2 → 2.0.0beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2023ac9b80d1f49f03e13afc24c7fa46348b41a1
-  data.tar.gz: 550ac8a2dde8bc3678692d7eb14bef40952f732e
+  metadata.gz: 9852283136894ad3b639698821b88d26a08c89bb
+  data.tar.gz: 598808aead2bdce0f51ee5907bfaa0d44c503341
 SHA512:
-  metadata.gz: 5dfee71f3214204be61632de52ebd7c7a73757c2c368b7b11fd6e64945263910c907c11823e2f727c373e29cf1f20ec3828d0ca097670968f24cee46eb22dc7a
-  data.tar.gz: 2c879978c5f288890d1f92f2256b53772f83af2aee98cf3a87ae4fdebc91fbcb03e188645def29a436cf04f90070ca37449c75fff11999ab3ca311151a314832
+  metadata.gz: 407fb6d9cdd446bd99f8aa457dffab5dc531b3ac30efb771147e2ff3a95c237e9ceb83279e0cf5688b4df94c44bc03f754ad46ab68037400bc1ad9bf475c9307
+  data.tar.gz: 0d0c99a86b87a430a3c93da08d7403c3aeeb5562fec6cc5b458cb78fdde521a810e734f5b638464a48d9ed771a4b081cbb57ff0350a9dccc1aa4e89aac620e92

data/README.md

@@ -1,4 +1,4 @@
-# Guard::Jasmine [![Build Status](https://secure.travis-ci.org/netzpirat/guard-jasmine.png)](http://travis-ci.org/netzpirat/guard-jasmine)
+# Guard::Jasmine [![Build Status](https://secure.travis-ci.org/guard/guard-jasmine.png)](http://travis-ci.org/guard/guard-jasmine)
 
 Guard::Jasmine automatically tests your Jasmine specs when files are modified.
 
@@ -15,8 +15,8 @@ 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][] or [jasmine-rails][] for integrating [Jasmine][] into the
-[Rails asset pipeline][] and write your specs in [CoffeeScript][].
+* Runs the standard Jasmine test runner, which can optionally integrate [Jasmine][] into the
+[Rails asset pipeline][], enabling you to write your specs in [CoffeeScript][].
 
 * Integrates [Istanbul](https://github.com/gotwarlost/istanbul) to instrument your code in the asset pipeline and
 generate coverage reports.
@@ -57,7 +57,7 @@ Add the default Guard::Jasmine template to your `Guardfile` by running:
 $ guard init jasmine
 ```
 
-Please have a look at the [CHANGELOG](https://github.com/netzpirat/guard-jasmine/blob/master/CHANGELOG.md) when
+Please have a look at the [CHANGELOG](https://github.com/guard/guard-jasmine/blob/master/CHANGELOG.md) when
 upgrading to a newer Guard::Jasmine version.
 
 ### PhantomJS
@@ -91,14 +91,14 @@ You can also build it from source for several other operating systems, please co
 ## Rails with the asset pipeline setup
 
 With Rails 3.1 and later you can write your Jasmine specs in addition to JavaScript with CoffeeScript, fully integrated
-into the Rails asset pipeline with [Jasminerice][]. You have full access to your running Rails app, but it's a good
+into the Rails asset pipeline. You have full access to your running Rails app, but it's a good
 practice to fake the server response. Check out the excellent [Sinon.JS][] documentation to learn more about this topic.
 
-Guard::Jasmine will start a Rails Rack server to run your specs.
+Guard::Jasmine will start a Rails Rack server to run your specs.  Step by step instructions on configuring this are below.
 
 ### How it works
 
-![Guard Jasmine](https://github.com/netzpirat/guard-jasmine/raw/master/resources/guard-jasmine-with-asset-pipeline.jpg)
+![Guard Jasmine](https://github.com/guard/guard-jasmine/raw/master/resources/guard-jasmine-with-asset-pipeline.jpg)
 
 1. Guard is triggered by a file modification.
 2. Guard::Jasmine executes the [PhantomJS script][].
@@ -111,228 +111,21 @@ Guard::Jasmine will start a Rails Rack server to run your specs.
 9. The PhantomJS script collects the Jasmine runner results and returns a JSON report.
 10. Guard::Jasmine reports the results to the console and system notifications.
 
-### Jasminerice
+#### Configuring Guard Jasmine to integrate with the asset pipeline.
 
-Please read the detailed installation and configuration instructions at [Jasminerice][].
+ * Install Guard Jasmine into the Rails project's Gemfile:
+ 
+   `gem "guard-jasmine", "~> 2.0"`
 
-In short, you add it to your `Gemfile`:
+ * Install Jasmine: `rails generate jasmine:install`
+ * (Optionally) install Jasmine examples: `rails generate jasmine:examples`
+ * (Optionally) Edit spec/javascripts/support/jasmine.yml to enable running CoffeeScript.
+   * Change the `spec_files:` section to `'**/*[sS]pec.{js,coffee}'`
+ * Install GuardJasmine's sample Guardfile `rails generate  guard_jasmine:install`
+ * Run GuardJasmine: `guard`
+ 
+A sample Rails project configured in this way is at https://github.com/nathanstitt/guard-jasmine-rails-test
 
-```ruby
-group :development, :test do
-  gem 'jasminerice'
-end
-```
-
-And run following from the Terminal:
-
-```bash
-mkdir -p spec/javascripts
-echo -e "#=require application\n#=require_tree ./" > spec/javascripts/spec.js.coffee
-echo -e "/*\n *=require application\n */" > spec/javascripts/spec.css
-```
-
-This creates the directory `spec/javascripts` where your CoffeeScript tests goes into. You define the Rails
-asset pipeline manifest in `spec/javascripts/spec.js.coffee`:
-
-```coffeescript
-#=require application
-#=require_tree ./
-```
-
-It also creates an empty `spec/javascripts/spec.css` file as it is always requested when running specs.
-
-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
-[Jasmine-species](http://rudylattae.github.com/jasmine-species/) acceptance tests.
-
-In short, you add it to your `Gemfile`:
-
-```ruby
-group :development, :test do
-  gem 'jasmine-stories'
-end
-```
-
-And run following from the Terminal:
-
-```bash
-mkdir -p spec/javascripts/stories
-echo -e "#=require_tree ./stories" > spec/javascripts/stories.js.coffee
-echo -e "/*\n *=require application\n */" > spec/javascripts/spec.css
-```
-
-This creates the directory `spec/javascripts/stories` where your CoffeeScript acceptance tests goes into.
-
-Now you can access `/jasmine-stories` when you start your Rails server normally. You have to change the Jasmine runner
-accordingly:
-
-```ruby
-guard :jasmine, port: 8888, jasmine_url: 'http://127.0.0.1:8888/jasmine-stories' do
-  ...
-end
-```
-
-## Rails without the asset pipeline
-
-With Rails without the asset pipeline or a plain Ruby project, you can use [the Jasmine Gem][] to configure your Jasmine
-specs and server the Jasmine runner. You don't have full access to your running Rails app, but it's anyway a good
-practice to fake the server response. Check out the excellent [Sinon.JS][] documentation to learn more about this topic.
-
-Guard::Jasmine will start a Jasmine Gem Rack server to run your specs.
-
-### How it works
-
-![Guard Jasmine](https://github.com/netzpirat/guard-jasmine/raw/master/resources/guard-jasmine-without-asset-pipeline.jpg)
-
-1. Guard is triggered by a file modification.
-2. Guard::Jasmine executes the [PhantomJS script][].
-3. The PhantomJS script requests the Jasmine test runner via HTTP.
-4. The Jasmine Gem reads your configuration and get the assets.
-5. The Jasmine Gem serves the the code to be tested and the specs.
-6. PhantomJS runs the Jasmine tests headless.
-7. The PhantomJS script collects the Jasmine runner results and returns a JSON report.
-8. Guard::Jasmine reports the results to the console and system notifications.
-
-### Jasmine Gem
-
-Please read the detailed installation and configuration instructions at [the Jasmine Gem][].
-
-In short, you add the Jasmine gem to your `Gemfile`:
-
-```ruby
-group :development, :test do
-  gem 'jasmine'
-end
-```
-
-and generate the configuration files.
-
-#### Rails 3 without the asset pipeline
-
-Install the Jasmine gem in your Rails 3 app with:
-
-```bash
-$ rails g jasmine:install
-```
-
-#### Rails 2
-
-Install the Jasmine gem in your Rails 2 app with:
-
-```bash
-$ script/generate jasmine
-```
-
-Now you can configure your spec suite in the Jasmine configuration file `specs/javascripts/support/jasmine.yml`.
-
-#### Writing CoffeeScript specs
-
-It is also possible to use CoffeeScript in this setup, by using [Guard::CoffeeScript][] to compile your code and even
-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'
-```
-
-## Ruby projects
-
-If you like to use Guard::Jasmine with a plain Ruby project, you can create a Rack configuration file
-that starts a Rails instance with the asset pipeline and Jasminerice, having the full Rails testing
-comfort for non-Rails projects. Please have a look at the
-[Rails with the asset pipeline](https://github.com/netzpirat/guard-jasmine#rails-with-the-asset-pipeline-setup)
-section to see how the setup works.
-
-First you have the add the needed Gems to your `Gemfile`:
-
-```Ruby
-group :assets do
-  gem 'coffee-script'
-end
-
-group :development, :test do
-  gem 'actionpack', '~> 3.2'
-  gem 'railties',   '~> 3.2'
-  gem 'tzinfo'
-
-  gem 'thin'
-
-  gem 'jasminerice'
-  gem 'jquery-rails'
-  gem 'guard-jasmine'
-end
-```
-
-We add support for CoffeeScript specs, using Thin as spec server and adding Jasminerice and jQuery
-(which is needed by Jasminerice) to the Gems. After installing the gems with `bundle`, we can
-create a Rack configuration to spin up a mini-Rails app for testing:
-
-```Ruby
-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, at: '/jasmine'
-  end
-
-  config.cache_classes = true
-  config.active_support.deprecation = :log
-  config.assets.enabled = true
-  config.assets.version = '1.0'
-  config.secret_token = '9696be98e32a5f213730cb7ed6161c79'
-end
-
-JasmineTest.initialize!
-run JasmineTest
-```
-
-The mini Rails app is now ready to start and serve the Jasmine specs. You only have to create
-`spec/javascripts/spec.js.coffee`, the Jasminerice asset pipeline manifest, and configure the
-assets:
-
-```CoffeeScript
-#= require jquery
-#= require_tree .
-```
-
-Start the test server manually with `bundle exec rackup -p 3000` and visit `http://localhost:3000/jasmine`
-to verify it works. If everything is fine, you can continue with adding Guard::Jasmine to your `Guardfile`
-and have your non-Rails app comfortably tested in a headless environment.
 
 ## Usage
 
@@ -378,7 +171,8 @@ server_env:  :test                            # Jasmine server Rails environment
 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. Note that some ports (e.g. 6665) won't work.
+                                              # This is due to the fact that Webkit considers them unsafe.
                                               # default: a random, free server port
 
 phantomjs_bin:  '~/bin/phantomjs'             # Path to phantomjs.
@@ -805,7 +599,7 @@ I recommend to check out these other brilliant Jasmine runners:
 
 ## How to file an issue
 
-You can report issues and feature requests to [GitHub Issues](https://github.com/netzpirat/guard-jasmine/issues). Try to figure out
+You can report issues and feature requests to [GitHub Issues](https://github.com/guard/guard-jasmine/issues). Try to figure out
 where the issue belongs to: Is it an issue with Guard itself or with Guard::Jasmine? Please don't
 ask question in the issue tracker, instead join us in our [Google group](http://groups.google.com/group/guard-dev) or on
 `#guard` (irc.freenode.net).
@@ -821,7 +615,7 @@ When you file an issue, please try to follow to these simple rules if applicable
 ## Development information
 
 - Documentation hosted at [RubyDoc](http://rubydoc.info/github/guard/guard-jasmine/master/frames).
-- Source hosted at [GitHub](https://github.com/netzpirat/guard-jasmine).
+- Source hosted at [GitHub](https://github.com/guard/guard-jasmine).
 
 Pull requests are very welcome! Please try to follow these simple rules if applicable:
 
@@ -866,13 +660,16 @@ $ guard-jasmine-debug http://127.0.0.1:3000/Jasmine?spec=YourSpec
 
 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.
+If you like Guard::Jasmine, you can watch the repository at [GitHub](https://github.com/guard/guard-jasmine).
+
+## Maintainer
+
+Maintained by [Nathan Stitt](https://github.com/nathanstitt).
 
 ## Contributors
 
-See the [CHANGELOG](https://github.com/netzpirat/guard-jasmine/blob/master/CHANGELOG.md) and the GitHub list of
-[contributors](https://github.com/netzpirat/guard-jasmine/contributors).
+See the [CHANGELOG](https://github.com/guard/guard-jasmine/blob/master/CHANGELOG.md) and the GitHub list of
+[contributors](https://github.com/guard/guard-jasmine/contributors).
 
 ## Acknowledgment
 
@@ -889,7 +686,7 @@ for it!
 
 (The MIT License)
 
-Copyright (c) 2011-2013 Michael Kessler
+Copyright (c) 2011-2014 Michael Kessler
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/lib/generators/guard_jasmine/install_generator.rb

@@ -0,0 +1,17 @@
+require 'rails/generators'
+
+module GuardJasmine
+  class InstallGenerator < Rails::Generators::Base
+    desc "Install a sample Guardfile for running Jasmine specs via GuardJasmine"
+
+    def self.source_root
+      @source_root ||= File.join(File.dirname(__FILE__), 'templates')
+    end
+
+    # Generator Code. Remember this is just suped-up Thor so methods are executed in order
+    def install
+      template "Guardfile"
+    end
+
+  end
+end

data/lib/generators/guard_jasmine/templates/Guardfile

@@ -0,0 +1,9 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :jasmine do
+    watch(%r{^spec/javascripts/.*(?:_s|S)pec\.(coffee|js)$})
+    watch(%r{app/assets/javascripts/(.+?)\.(js\.coffee|js|coffee)(?:\.\w+)*$}) { |m|
+      "spec/javascripts/jasmine/#{ m[1] }_spec.#{ m[2] }"
+    }
+end

data/lib/guard/jasmine.rb

@@ -18,7 +18,7 @@ module Guard
 
     extend ::Guard::Jasmine::Util
 
-    attr_accessor :last_run_failed, :last_failed_paths, :run_all_options
+    attr_accessor :last_run_failed, :last_failed_paths, :run_all_options, :runner
 
     DEFAULT_OPTIONS = {
       server:                   :auto,
@@ -51,7 +51,8 @@ module Guard
       lines_threshold:          0,
       junit:                    false,
       junit_consolidate:        true,
-      junit_save_path:          ''
+      junit_save_path:          '',
+      debug:                    false
     }
 
     # Initialize Guard::Jasmine.
@@ -93,19 +94,20 @@ module Guard
       options = DEFAULT_OPTIONS.merge(options)
 
       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[:server]       =  ::Guard::Jasmine::Server.detect_server(options[:spec_dir]) if options[:server] == :auto
+      options[:port]        ||= ::Guard::Jasmine::Server.choose_server_port(options)
       options[:jasmine_url]   = "http://localhost:#{ options[:port] }#{ options[:server] == :jasmine_gem ? '/' : options[:server_mount] }" 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) || { }
+      self.run_all_options = options.delete(:run_all) || {}
 
       super(options)
 
       self.last_run_failed   = false
       self.last_failed_paths = []
+      @runner = Runner.new( options.merge(self.run_all_options) )
     end
 
     # Gets called once when Guard starts.
@@ -147,36 +149,37 @@ module Guard
     # @raise [:task_has_failed] when run_all has failed
     #
     def run_all
-      passed, failed_specs = Runner.run([options[:spec_dir]], options.merge(self.run_all_options))
+      results = runner.run([options[:spec_dir]])
 
-      self.last_failed_paths = failed_specs
-      self.last_run_failed   = !passed
+      self.last_failed_paths = results.keys
+      self.last_run_failed   = !results.empty?
 
-      throw :task_has_failed unless passed
+      throw :task_has_failed if self.last_run_failed
     end
-
     # Gets called when watched paths and files have changes.
     #
     # @param [Array<String>] paths the changed paths and files
     # @raise [:task_has_failed] when run_on_modifications has failed
     #
     def run_on_modifications(paths)
+
       specs = options[:keep_failed] ? paths + self.last_failed_paths : paths
       specs = Inspector.clean(specs, options) if options[:clean]
+
       return false if specs.empty?
 
-      passed, failed_specs = Runner.run(specs, options)
+      results = runner.run(specs)
 
-      if passed
+      if results.empty?
         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
+        self.last_failed_paths = self.last_failed_paths + results.keys
       end
 
-      self.last_run_failed = !passed
+      self.last_run_failed = !results.empty?
 
-      throw :task_has_failed unless passed
+      throw :task_has_failed if self.last_run_failed
     end
 
   end