jasmine-rails 0.3.3 → 0.4.0

data/README.md

@@ -6,19 +6,20 @@ This project is intended to make it a little easier to integrate [Jasmine](https
 
 By bundling this gem and configuring your project, you can expect to:
 
-* Be able to run Jasmine specs from the command line (*and fast*) with John Bintz's excellent [jasmine-headless-webkit](http://johnbintz.github.com/jasmine-headless-webkit/)
-* Be able to run Jasmine specs in a browser (wherever you choose to mount the jasmine-rails engine)
+* Be able to run Jasmine specs in a browser (powered by Rails engine mounted into your application)
+* Be able to run Jasmine specs from the command line (powered by
+  [PhantomJS](http://phantomjs.org/))
 * Write specs or source in [CoffeeScript](http://jashkenas.github.com/coffee-script/), leveraging the [asset pipeline](http://railscasts.com/episodes/279-understanding-the-asset-pipeline) to pre-process it
 
 ## Prerequisites
 
-Install qt for its headless webkit widget. The easiest way (on a Mac) that I've found is to use [homebrew](https://github.com/mxcl/homebrew):
+Install phantomjs in order to run tests headless on the command line. The easiest way (on a Mac) that I've found is to use [homebrew](https://github.com/mxcl/homebrew):
 
-    brew install qt
+    brew install phantomjs
 
-For help installing the qt libs on other platforms, the I'd recommend [perusing capybara-webkit driver's documentation](https://github.com/thoughtbot/capybara-webkit), becuse it has the same dependency.
+If you're not on a Mac, fear not, as [installing PhantomJS](http://phantomjs.org) is pretty painless for most environments. The important thing is that the binary be somewhere on your PATH.
 
-## Adding & configuring the gem
+## Installation
 
 First, add jasmine-rails to your Gemfile, like so
 
@@ -28,54 +29,77 @@ First, add jasmine-rails to your Gemfile, like so
 
 Next, run `bundle install`.
 
+Now, just mount jasmine-rails into your application by adding something like this to your routes.rb.  The engine can be mounted to any path that you choose.
+
+``` ruby
+mount JasmineRails::Engine => "/specs" if defined?(JasmineRails)
+```
+
+## Configuration
+
 In order to run any specs, you'll need a Jasmine configuration in `spec/javascripts/support/jasmine.yml`. [Here's an example](https://github.com/searls/jasmine-rails/tree/master/spec/dummy/spec/javascripts/support) from this repo's [dummy project](https://github.com/searls/jasmine-rails/tree/master/spec/dummy).
 
 ``` yaml
+# path to parent directory of src_files
+# relative path from Rails.root
+# defaults to app/assets/javascripts
+src_dir: "app/assets/javascripts"
+
+# list of file expressions to include as source files
+# relative path from scr_dir
 src_files:
  - "application.{js,coffee}"
 
-stylesheets:
+# path to parent directory of spec_files
+# relative path from Rails.root
+# defaults to spec/javascripts
+spec_dir: spec/javascripts
 
+# list of file expressions to include as helpers into spec runner
+# relative path from spec_dir
 helpers:
   - "helpers/**/*.{js,coffee}"
 
+# list of file expressions to include as specs into spec runner
+# relative path from spec_dir
 spec_files:
   - "**/*[Ss]pec.{js,coffee}"
-
-src_dir: "app/assets/javascripts"
-
-spec_dir: spec/javascripts
-
-asset_paths:
- - "vendor/assets/javascripts"
 ```
 
-### Writing asset manifests
+## Asset Pipeline Support
 
-I prefer to have just one asset manifest per project, as the `jasmine.yml` file above suggests. One way to accomplish that is to require your `vendor` (and, if necessary, `lib`) manifests within your application manifest. For an example, check out the repo's [dummy project](https://github.com/searls/jasmine-rails/tree/master/spec/dummy).
+The jasmine-rails gem *fully* supports the Rails asset pipeline which means you can:
+* use `coffee_script` or other Javascript precompilers for source or
+  test files
+* use sprockets directives to control inclusion/exclusion of dependent
+  files
+* leverage asset pipeline search paths to include assets from various
+  sources/gems
 
-Here's `app/assets/javascripts/application.js`
+**If you choose to use the asset pipeline support, many of the `jasmine.yml`
+configurations become unnecessary** and you can rely on the Rails asset
+pipeline to do the hard work of controlling what files are included in
+your testsuite.
 
-``` javascript
-//= require vendor
-//= require_tree .
+```yaml
+# minimalist jasmine.yml configuration when leveraging asset pipeline
+spec_files:
+  - "**/*[Ss]pec.{js,coffee}"
 ```
 
-And here's `vendor/assets/javascripts/vendor.js` (as referenced on the first line of `application.js` above)
-
-``` javascript
-//= require jquery
-//= require jquery_ujs
-//= require_tree .
+```javascript
+//= require helpers/spec_helper  (includes spec/javascripts/helpers/spec_helper.js)
+//= require foo                  (includes app/assets/javascripts/foo.js)
+describe('Foo', function() {
+  it('does something');
+});
 ```
 
-Assets in gems come along for the ride, as well. Additionally, you can follow a similar scheme to import any JavaScript libs you might reference from a `lib/assets/javascripts/lib.js` manifest file.
-
 ## Running from the command line
 
 If you were to run:
 
-    bundle exec jasmine-headless-webkit --color
+    bundle exec rake spec:javascript
 
 You'd hopefully see something like:
 
@@ -83,19 +107,16 @@ You'd hopefully see something like:
 
     PASS: 0 tests, 0 failures, 0.001 secs.
 
-I encourage you to explore John Bintz's excellent [jasmine-headless-webkit's documentation](http://johnbintz.github.com/jasmine-headless-webkit/) for more ideas, like creating a Rake task or running it on a display-less CI server.
+You can filter execution by passing the `SPEC` option as well:
+
+    bundle exec rake spec:javascript SPEC=my_test
 
 If you experience an error at this point, the most likely cause is JavaScript being loaded out of order, or otherwise conflicting with other existing JavaScript in your project. See "Debugging" below.
 
 ## Running from your browser
 
-Just mount jasmine-rails by adding something like this to your routes.rb:
-
-``` ruby
-mount JasmineRails::Engine => "/specs" unless Rails.env.production?
-```
-
-Now when you run `bundle exec rails s`, and navigate to [http://localhost:3000/specs](http://localhost:3000/specs), you should see a Jasmine spec runner in your browser.
+Startup your Rails server (ex: `bundle exec rails s`), and navigate to the path you have configured in your routes.rb file (ex: [http://localhost:3000/specs](http://localhost:3000/specs)).
+The Jasmine spec runner should appear and start running your testsuite instantly.
 
 ## Debugging
 
@@ -103,39 +124,17 @@ Now when you run `bundle exec rails s`, and navigate to [http://localhost:3000/s
 
 In my workflow, I like to work with specs in the command line until I hit a snag and could benefit from debugging in [Web Inspector](http://www.webkit.org/blog/1091/more-web-inspector-updates/) or [Firebug](http://getfirebug.com/) to figure out what's going on.
 
-[When debugging, if you've disabled the asset pipeline's debug mode in dev/test, you may need to append the query param `?debug_assets=true` like so: [http://localhost:3000/specs?debug_assets=true](http://localhost:3000/specs?debug_assets=true). The asset pipeline will include individual `script` tags for each of your scripts when in debug mode, which migh tmake debugging easier.]
-
 ### From the command line
 
-Even though they both read from the same config file, it's certainly possible that your specs will pass in the browser and fail from the command line. In this case, you can try to debug or analyze what's going on by using the "--keep" flag from jasmine-headless-webkit.
-
-By running:
+Even though they both read from the same config file, it's certainly possible that your specs will pass in the browser and fail from the command line. In this case, you can try to debug or analyze what's going on loading the headless runner.html file into your browser environment. The generated runner.html file is written out to `spec/tmp/runner.html` after each run.
 
-    bundle exec jasmine-headless-webkit --keep
+### Ajax / XHRs
 
-If the tests fail, jasmine-headless-webkit will leave its generated spec runner HTML file persisted in your rails root folder. It'll be named something like "jhw.48160.html".
+As a general rule, Jasmine is designed for unit testing, and as a result real network requests are not appropriate for tests written in Jasmine. (Isolation strategies can include spying on asynchronous libraries and then synchronously testing callback behavior, as [demonstrated in this gist](https://gist.github.com/searls/946704)).
 
-## Guard
-
-[Guard](https://github.com/guard/guard) is a great tool for triggering spec runs when files change. To use it, you can bundle these gems:
-
-    group :development do
-      ...
-      gem 'guard-jasmine-headless-webkit'
-      ...
-    end
-
-In my Guardfile, this configuration is working well for me:
-
-    spec_location = "spec/javascripts/%s_spec"
-
-    guard 'jasmine-headless-webkit' do
-      watch(%r{^app/views/.*\.jst$})
-      watch(%r{^public/javascripts/(.*)\.js$}) { |m| newest_js_file(spec_location % m[1]) }
-      watch(%r{^.*/assets/javascripts/(.*)\.(js|coffee)$}) { |m| newest_js_file(spec_location % m[1]) }
-      watch(%r{^spec/javascripts/(.*)_spec\..*}) { |m| newest_js_file(spec_location % m[1]) }
-    end
+If your application code issues XHR requests during your test run, please note that **XHR requests for the local filesystem** are blocked by default for most browsers for security reasons.  To debug local XHR requests (for example, if you jasmine-jquery fixtures), you will need to enable local filesystem requests in your browser.
 
-Finally, to run guard, just:
+Example for Google Chrome (in Mac OS X):
+    open -a "Google Chrome" spec/tmp/runner.html --args --allow-file-access-from-files
 
-    bundle exec guard
+Again, it's the opinion of the present author that this shouldn't be necessary in any situation but legacy rescue of an existing test suite. With respect specifically to HTML fixtures, please consider [jasmine-fixture](https://github.com/searls/jasmine-fixture) and [my rationale](http://searls.testdouble.com/posts/2011-12-11-jasmine-fixtures.html) for it.

data/Rakefile

@@ -9,17 +9,14 @@ APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
 load 'rails/tasks/engine.rake'
 Bundler::GemHelper.install_tasks
 
-task :cd_to_dummy do
-  Dir.chdir(File.expand_path("../spec/dummy", __FILE__))
-end
-
-require 'jasmine-headless-webkit'
-Jasmine::Headless::Task.new(:dummy_headless_jasmine) do |t|
-  t.colors = true
-  t.keep_on_error = true
+task :run_jasmine_rake_in_dummy do
+  system <<-BASH
+    cd spec/dummy
+    bundle exec rake spec:javascript
+  BASH
 end
 
 require 'rspec/core/rake_task'
-RSpec::Core::RakeTask.new(:dummy_spec)
+RSpec::Core::RakeTask.new(:run_browser_spec_in_dummy)
 
-task :default => [:cd_to_dummy, :dummy_headless_jasmine, :dummy_spec]
+task :default => [:run_jasmine_rake_in_dummy, :run_browser_spec_in_dummy]

data/app/controllers/jasmine_rails/spec_runner_controller.rb

@@ -1,7 +1,7 @@
 module JasmineRails
   class SpecRunnerController < ApplicationController
     def index
-      params[:debug_assets] = true
+      JasmineRails.reload_jasmine_config
     end
   end
 end

data/app/helpers/jasmine_rails/spec_runner_helper.rb

@@ -0,0 +1,30 @@
+require 'jasmine-core'
+
+module JasmineRails
+  module SpecRunnerHelper
+    # return list of css files to include in spec runner
+    # all files are fetched through the Rails asset pipeline
+    # includes:
+    # * core jasmine css files
+    def jasmine_css_files
+      Jasmine::Core.css_files
+    end
+
+    # return list of javascript files needed for jasmine testsuite
+    # all files are fetched through the Rails asset pipeline
+    # includes:
+    # * core jasmine libraries
+    # * (optional) jasmine-console-reporter.js for CLI output
+    # * jasmine-boot.js test runner
+    # * jasmine-specs.js built by asset pipeline which merges application specific libraries and specs
+    def jasmine_js_files
+      files = Jasmine::Core.js_files
+      if params[:console]
+        files << 'jasmine-console-reporter.js'
+      end
+      files << 'jasmine-boot.js'
+      files << 'jasmine-specs.js'
+      files
+    end
+  end
+end

data/app/views/layouts/jasmine_rails/spec_runner.html.erb

@@ -4,41 +4,11 @@
     <meta content="text/html;charset=UTF-8" http-equiv="Content-Type"/>
     <title>Jasmine Specs</title>
 
-    <%= stylesheet_link_tag *JasmineRails::JhwAdapter.new.css_files %>
-    <%= javascript_include_tag *JasmineRails::JhwAdapter.new.js_files %>
-
-    <!-- executing jasmine's runner -->
-    <script type="text/javascript">
-      (function() {
-      var jasmineEnv = jasmine.getEnv();
-      jasmineEnv.updateInterval = 1000;
-
-      var htmlReporter = new jasmine.HtmlReporter();
-
-      jasmineEnv.addReporter(htmlReporter);
-
-      jasmineEnv.specFilter = function(spec) {
-        return htmlReporter.specFilter(spec);
-      };
-
-      var currentWindowOnload = window.onload;
-
-      window.onload = function() {
-        if (currentWindowOnload) {
-          currentWindowOnload();
-        }
-        execJasmine();
-      };
-
-      function execJasmine() {
-        jasmineEnv.execute();
-      }
-
-      })();
-    </script>
+    <%= stylesheet_link_tag *jasmine_css_files %>
+    <%= javascript_include_tag *jasmine_js_files %>
   </head>
   <body>
     <div id="jasmine_content"></div>
     <%= yield %>
   </body>
-</html>
+</html>

data/config/routes.rb

@@ -1,6 +1,3 @@
-require 'jasmine-core' ##<--TODO why is this here?
-require 'jasmine' ##<--TODO why is this here?
-
 JasmineRails::Engine.routes.draw do
   root :to => "spec_runner#index"
 end

data/lib/assets/javascripts/jasmine-boot.js

@@ -0,0 +1,27 @@
+var jsApiReporter;
+(function() {
+  var jasmineEnv = jasmine.getEnv();
+
+  jsApiReporter = new jasmine.JsApiReporter();
+  jasmineEnv.addReporter(jsApiReporter);
+
+  var htmlReporter = new jasmine.HtmlReporter();
+  jasmineEnv.addReporter(htmlReporter);
+  jasmineEnv.specFilter = function(spec) {
+    return htmlReporter.specFilter(spec);
+  };
+
+  if (jasmine.ConsoleReporter) {
+    jasmineEnv.addReporter(new jasmine.ConsoleReporter());
+  }
+
+  function execJasmine() {
+    jasmineEnv.execute();
+  }
+
+  if (window.addEventListener) { // W3C
+    window.addEventListener('load', execJasmine, false);
+  } else if (window.attachEvent) { // MSIE
+    window.attachEvent('onload', execJasmine);
+  }
+})();

data/lib/assets/javascripts/jasmine-console-reporter.js

@@ -0,0 +1,110 @@
+/**
+ Jasmine Reporter that outputs test results to the browser console.
+ Useful for running in a headless environment such as PhantomJs, ZombieJs etc.
+
+ Usage:
+ // From your html file that loads jasmine:
+ jasmine.getEnv().addReporter(new jasmine.ConsoleReporter());
+ jasmine.getEnv().execute();
+*/
+
+(function(jasmine, console) {
+  if (!jasmine) {
+    throw "jasmine library isn't loaded!";
+  }
+
+  var ANSI = {}
+  ANSI.color_map = {
+      "green" : 32,
+      "red"   : 31
+  }
+
+  ANSI.colorize_text = function(text, color) {
+    var color_code = this.color_map[color];
+    return "\033[" + color_code + "m" + text + "\033[0m";
+  }
+
+  var ConsoleReporter = function() {
+    if (!console || !console.log) { throw "console isn't present!"; }
+    this.status = this.statuses.stopped;
+  };
+
+  var proto = ConsoleReporter.prototype;
+  proto.statuses = {
+    stopped : "stopped",
+    running : "running",
+    fail    : "fail",
+    success : "success"
+  };
+
+  proto.reportRunnerStarting = function(runner) {
+    this.status = this.statuses.running;
+    this.start_time = (new Date()).getTime();
+    this.executed_specs = 0;
+    this.passed_specs = 0;
+    this.log("Starting...");
+  };
+
+  proto.reportRunnerResults = function(runner) {
+    var failed = this.executed_specs - this.passed_specs;
+    var spec_str = this.executed_specs + (this.executed_specs === 1 ? " spec, " : " specs, ");
+    var fail_str = failed + (failed === 1 ? " failure in " : " failures in ");
+    var color = (failed > 0)? "red" : "green";
+    var dur = (new Date()).getTime() - this.start_time;
+
+    this.log("");
+    this.log("Finished");
+    this.log("-----------------");
+    this.log(spec_str + fail_str + (dur/1000) + "s.", color);
+
+    this.status = (failed > 0)? this.statuses.fail : this.statuses.success;
+
+    /* Print something that signals that testing is over so that headless browsers
+       like PhantomJs know when to terminate. */
+    this.log("");
+    this.log("ConsoleReporter finished");
+  };
+
+
+  proto.reportSpecStarting = function(spec) {
+    this.executed_specs++;
+  };
+
+  proto.reportSpecResults = function(spec) {
+    if (spec.results().skipped) {
+      return;
+    }
+    if (spec.results().passed()) {
+      this.passed_specs++;
+      return;
+    }
+
+    var resultText = spec.suite.description + " : " + spec.description;
+    this.log(resultText, "red");
+
+    var items = spec.results().getItems()
+    for (var i = 0; i < items.length; i++) {
+      var item = items[i];
+      var output = '  ' + item.message;
+      this.log(output, "red");
+    }
+  };
+
+  proto.reportSuiteResults = function(suite) {
+    if (!suite.parentSuite) { return; }
+    var results = suite.results();
+    if (results.totalCount === 0) {
+      return;
+    }
+    var failed = results.totalCount - results.passedCount;
+    var color = (failed > 0)? "red" : "green";
+    this.log(suite.description + ": " + results.passedCount + " of " + results.totalCount + " passed.", color);
+  };
+
+  proto.log = function(str, color) {
+    var text = (color != undefined)? ANSI.colorize_text(str, color) : str;
+    console.log(text)
+  };
+
+  jasmine.ConsoleReporter = ConsoleReporter;
+})(jasmine, console);

data/lib/assets/javascripts/jasmine-specs.js.erb

@@ -0,0 +1,14 @@
+<%
+  # depend on spec dirs to automatically flush asset cache
+  # when new tests or directories are added
+  JasmineRails.each_spec_dir do |directory|
+    depend_on directory
+  end
+
+  # bundle all jasmine specs using asset pipeline
+  # so asset pipeline can properly filter out duplicates
+  # via dependency tree
+  JasmineRails.spec_files.each do |file|
+    require_asset(file.to_s)
+  end
+%>

data/lib/jasmine-rails.rb

@@ -1,5 +1,84 @@
 require "jasmine_rails/engine"
-require "jasmine_rails/jhw_adapter"
 
 module JasmineRails
+  class << self
+    # return the relative path to access the spec runner
+    # for the host Rails application
+    # ex: /jasmine
+    def route_path
+      route = Rails.application.routes.named_routes[:jasmine_rails]
+      raise 'JasmineRails::Engine has not been mounted into routes.rb' unless route
+      path = route.path
+
+      # Rails 3.1 support
+      if path.is_a?(String)
+        path
+      else
+        path.spec.to_s
+      end
+    end
+
+    def spec_dir
+      path = jasmine_config['spec_dir'] || 'spec/javascripts'
+      Rails.root.join(path)
+    end
+
+    # returns list of all files to be included into the jasmine testsuite
+    # includes:
+    # * application src_files
+    # * spec helpers
+    # * spec_files
+    def spec_files
+      files = []
+      files += filter_files src_dir, jasmine_config['src_files']
+      files += filter_files spec_dir, jasmine_config['helpers']
+      files += filter_files spec_dir, jasmine_config['spec_files']
+      files
+    end
+
+    # iterate over all directories used as part of the testsuite (including subdirectories)
+    def each_spec_dir(&block)
+      each_dir spec_dir.to_s, &block
+      each_dir src_dir.to_s, &block
+    end
+
+    # clear out cached jasmine config file
+    # it would be nice to automatically flush when the jasmine.yml file changes instead
+    # of having this programatic API
+    def reload_jasmine_config
+      @config = nil
+    end
+
+    private
+
+    def src_dir
+      path = jasmine_config['src_dir'] || 'app/assets/javascripts'
+      Rails.root.join(path)
+    end
+
+    def jasmine_config
+      @config ||= begin
+        path = Rails.root.join('spec', 'javascripts', 'support', 'jasmine.yml')
+        YAML.load_file(path)
+      end
+    end
+
+    def each_dir(root, &block)
+      yield root
+      Dir[root + '/*'].each do |file|
+        if File.directory?(file)
+          each_dir(file, &block)
+        end
+      end
+    end
+
+    def filter_files(root_dir, patterns)
+      files = patterns.to_a.collect do |pattern|
+        Dir.glob(root_dir.join(pattern)).sort
+      end
+      files = files.flatten
+      files = files.collect {|f| f.gsub(root_dir.to_s + '/', '') }
+      files || []
+    end
+  end
 end

data/lib/jasmine_rails/engine.rb

@@ -1,5 +1,12 @@
+require 'jasmine-core'
+
 module JasmineRails
   class Engine < Rails::Engine
     isolate_namespace JasmineRails
+
+    initializer :assets do |config|
+      Rails.application.config.assets.paths << Jasmine::Core.path
+      Rails.application.config.assets.paths << JasmineRails.spec_dir
+    end
   end
 end

data/lib/jasmine_rails/offline_asset_paths.rb

@@ -0,0 +1,30 @@
+# Rails Asset Patch extension used to write assets out an offline asset directory
+# for future use
+# example:
+#   ActionView::AssetPaths.send :include, JasmineRails::OfflineAssetPaths
+module JasmineRails
+  module OfflineAssetPaths
+    mattr_accessor :disabled
+    extend ActiveSupport::Concern
+    included do
+      alias_method_chain :compute_public_path, :offline_asset
+    end
+
+    def compute_public_path_with_offline_asset(source, dir, options={})
+      return compute_public_path_without_offline_asset(source, dir, options) if JasmineRails::OfflineAssetPaths.disabled
+      return source if source.starts_with?('/')
+      content = Rails.application.assets[source].to_s
+      source_path = offline_asset_dir.join(source)
+
+      FileUtils.mkdir_p File.dirname(source_path)
+      Rails.logger.debug "Compiling #{source} to #{source_path}"
+      File.open(source_path, 'w') {|f| f << content }
+      "assets/#{source}"
+    end
+
+    private
+    def offline_asset_dir
+      Rails.root.join('spec/tmp/assets')
+    end
+  end
+end

data/lib/jasmine_rails/version.rb

@@ -1,3 +1,3 @@
 module JasmineRails
-  VERSION = "0.3.3"
+  VERSION = "0.4.0"
 end

data/lib/tasks/jasmine-rails_tasks.rake

@@ -1,4 +1,28 @@
-# desc "Explaining what the task does"
-# task :jasmine-rails do
-#   # Task goes here
-# end
+namespace :spec do
+  def run_cmd(cmd)
+    puts "$ #{cmd}"
+    unless system(cmd)
+      raise "Error executing command: #{cmd}"
+    end
+  end
+
+  desc "run test with phantomjs"
+  task :javascript => :environment do
+    require 'jasmine_rails/offline_asset_paths'
+    ActionView::AssetPaths.send :include, JasmineRails::OfflineAssetPaths
+    spec_filter = ENV['SPEC']
+    app = ActionController::Integration::Session.new(Rails.application)
+    path = JasmineRails.route_path
+    app.get path, :console => 'true', :spec => spec_filter
+    JasmineRails::OfflineAssetPaths.disabled = true
+    raise "Error generating jasmine runner: #{app.response.status_message}" unless app.response.status == 200
+    html = app.response.body
+    runner_path = Rails.root.join('spec/tmp/runner.html')
+    File.open(runner_path, 'w') {|f| f << html}
+
+    run_cmd "phantomjs #{File.join(File.dirname(__FILE__), 'runner.js')} file://#{runner_path.to_s}?spec=#{spec_filter}"
+  end
+
+  # alias
+  task :javascripts => :javascript
+end

data/lib/tasks/runner.js

@@ -0,0 +1,76 @@
+(function() {
+  // handler for any page javascript errors
+  var errorHandler = function(msg, trace) {
+    var msgStack = ['ERROR: ' + msg];
+    if (trace) {
+      msgStack.push('TRACE:');
+      trace.forEach(function(t) {
+        msgStack.push(' -> ' + t.file + ': ' + t.line + (t.function ? ' (in function "' + t.function + '")' : ''));
+      });
+    }
+    console.error(msgStack.join('\n'));
+    phantom.exit(1);
+  };
+  phantom.onError = errorHandler;
+
+  var system = require('system');
+  var args = system.args;
+
+  if (args.length !== 2) {
+    console.log("Need a url as the argument");
+    phantom.exit(1);
+  }
+
+  var page = new WebPage();
+
+  // log messages to stdout
+  page.onConsoleMessage = function(msg) {
+    console.log(msg);
+  };
+
+  // listen for event from parent page
+  page.onCallback = function(data) {
+    if (data.event === 'exit') {
+      phantom.exit(data.exitCode);
+    } else if (data.event === 'writeFile') {
+      var fs = require("fs");
+      fs.write(data.filename, data.text, 'w');
+    } else {
+      console.log('unkown event callback: ' + data);
+    }
+  };
+
+  // log javascript errors
+  page.onError = errorHandler;
+
+  // setup listeners for jasmine events
+  page.onInitialized = function() {
+    return page.evaluate(function() {
+      return window.onload = function() {
+        jsApiReporter.exitCode = 0;
+        jsApiReporter.reportSpecResults = function(spec) {
+          if (spec.results().failedCount > 0) {
+            jsApiReporter.exitCode = 1;
+          }
+        };
+        jsApiReporter.reportRunnerResults = function() {
+          setTimeout(function() {
+            window.callPhantom({
+              event: 'exit',
+              exitCode: jsApiReporter.exitCode
+            });
+          }, 1);
+        };
+      };
+    });
+  };
+
+  var address = args[1];
+  console.log('Running: ' + address);
+  page.open(address, function(status) {
+    if (status !== "success") {
+      console.log("can't load the address!");
+      return phantom.exit(1);
+    }
+  });
+})();

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jasmine-rails
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-06 00:00:00.000000000 Z
+date: 2013-04-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -30,7 +30,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 3.1.0
 - !ruby/object:Gem::Dependency
-  name: jasmine
+  name: jasmine-core
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
@@ -45,22 +45,6 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '1.3'
-- !ruby/object:Gem::Dependency
-  name: jasmine-headless-webkit
-  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'
 description: Provides a Jasmine Spec Runner that plays nicely with Rails 3.1 assets
   and sets up jasmine-headless-webkit
 email:
@@ -73,15 +57,19 @@ extra_rdoc_files: []
 files:
 - app/controllers/jasmine_rails/application_controller.rb
 - app/controllers/jasmine_rails/spec_runner_controller.rb
+- app/helpers/jasmine_rails/spec_runner_helper.rb
 - app/views/jasmine_rails/spec_runner/index.html.erb
 - app/views/layouts/jasmine_rails/spec_runner.html.erb
-- config/initializers/sprockets.rb
 - config/routes.rb
+- lib/assets/javascripts/jasmine-boot.js
+- lib/assets/javascripts/jasmine-console-reporter.js
+- lib/assets/javascripts/jasmine-specs.js.erb
 - lib/jasmine-rails.rb
 - lib/jasmine_rails/engine.rb
-- lib/jasmine_rails/jhw_adapter.rb
+- lib/jasmine_rails/offline_asset_paths.rb
 - lib/jasmine_rails/version.rb
 - lib/tasks/jasmine-rails_tasks.rake
+- lib/tasks/runner.js
 - MIT-LICENSE
 - Rakefile
 - README.md

data/config/initializers/sprockets.rb

@@ -1,3 +0,0 @@
-assets = Rails.application.assets
-assets.append_path Jasmine::Core.path
-JasmineRails::JhwAdapter.new.asset_paths.each { |path| assets.append_path(path) }

data/lib/jasmine_rails/jhw_adapter.rb

@@ -1,84 +0,0 @@
-require 'jasmine-headless-webkit'
-
-module JasmineRails
-
-  class JhwAdapter
-
-    def initialize
-      @options = Jasmine::Headless::Options.new
-      @runner = instantiate_runner
-      Jasmine::Headless::CacheableAction.enabled = @options[:enable_cache]
-    end
-
-    def css_files
-      @css_files_list ||= CssFilesList.new(
-        :config => @runner.jasmine_config,
-        :only => @options[:files],
-        :seed => @options[:seed]
-      ).logical_paths
-    end
-
-    def js_files
-      @js_files_list ||= JsFilesList.new(
-        :config => @runner.jasmine_config,
-        :only => @options[:files],
-        :seed => @options[:seed]
-      ).logical_paths
-    end
-
-    def asset_paths
-      jasmine_config = YAML.load_file(@options[:jasmine_config])
-      [
-        jasmine_config["src_dir"],
-        jasmine_config["spec_dir"],
-        jasmine_config["asset_paths"]
-      ].flatten.compact
-    end
-
-    def instantiate_runner
-      begin
-        Jasmine::Headless::Runner.new(@options)
-      rescue Jasmine::Headless::NoRunnerError
-        require 'fileutils'
-        FileUtils.touch(Jasmine::Headless::Runner::RUNNER)
-        Jasmine::Headless::Runner.new(@options).tap { File.delete(Jasmine::Headless::Runner::RUNNER) }
-      end
-    end
-  end
-
-  class DistinctifiedFileList < Jasmine::Headless::FilesList
-    def files
-      required_files.collect { |asset| asset.pathname.to_s }.uniq
-    end
-
-    def logical_paths
-      files.map { |file| Rails.application.assets[file].logical_path }
-    end
-  end
-
-  class JsFilesList < DistinctifiedFileList
-
-    def self.default_files
-      %w{jasmine.js jasmine-html}
-    end
-
-    def self.extension_filter
-      extensions = (%w{.js} + Sprockets.engine_extensions)
-      %r{(#{extensions.join('|')})$}
-    end
-
-  end
-
-  class CssFilesList < DistinctifiedFileList
-
-    def self.default_files
-      %w{jasmine.css}
-    end
-
-    def self.extension_filter
-      extensions = (%w{.css .scss .sass .less})
-      %r{(#{extensions.join('|')})$}
-    end
-  end
-
-end