Class: Guard::Jasmine

Inherits:
Plugin
  • Object
show all
Extended by:
Util
Defined in:
lib/guard/jasmine.rb,
lib/guard/jasmine/cli.rb,
lib/guard/jasmine/util.rb,
lib/guard/jasmine/runner.rb,
lib/guard/jasmine/server.rb,
lib/guard/jasmine/formatter.rb,
lib/guard/jasmine/inspector.rb

Overview

The Jasmine guard that gets notifications about the following Guard events: start, stop, reload, run_all and run_on_modifications.

Defined Under Namespace

Modules: Formatter, Inspector, Server, Util Classes: CLI, Runner

Constant Summary

DEFAULT_OPTIONS =
{
  server:                   :auto,
  server_env:               ENV['RAILS_ENV'] || 'development',
  server_timeout:           60,
  server_mount:             '/jasmine', # set here for documentation purposes; actually determiend at runtime by presence (or lack thereof) of the JasmineRails constant
  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_html_dir:        './coverage',
  coverage_summary:         false,
  statements_threshold:     0,
  functions_threshold:      0,
  branches_threshold:       0,
  lines_threshold:          0,
  reporters:                nil,
  debug:                    false
}.freeze

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Util

find_free_server_port, phantomjs_bin_valid?, runner_available?, which

Constructor Details

#initialize(options = {}) ⇒ Jasmine

Initialize Guard::Jasmine.

Options Hash (options):

  • :server (String)

    the server to use, either :auto, :none, :webrick, :mongrel, :thin, :jasmine_gem, or a custom rake task

  • :server_env (String)

    the server environment to use, for example :development, :test

  • :server_timeout (Integer)

    the number of seconds to wait for the Jasmine spec server

  • :port (String)

    the port for the Jasmine test server

  • :rackup_config (String)

    custom rackup config to use

  • :server_mount (String)

    custom mount point to use; defaults to '/specs' if JasmineRails is on the load path, otherwise '/jasmine'

  • :jasmine_url (String)

    the url of the Jasmine test runner

  • :phantomjs_bin (String)

    the location of the PhantomJS binary

  • :timeout (Integer)

    the maximum time in seconds to wait for the spec runner to finish

  • :spec_dir (String)

    the directory with the Jasmine specs

  • :notification (Boolean)

    show notifications

  • :hide_success (Boolean)

    hide success message notification

  • :max_error_notify (Integer)

    maximum error notifications to show

  • :all_on_start (Boolean)

    run all suites on start

  • :keep_failed (Boolean)

    keep failed suites and add them to the next run again

  • :clean (Boolean)

    clean the specs according to rails naming conventions

  • :all_after_pass (Boolean)

    run all suites after a suite has passed again after failing

  • :specdoc (Symbol)

    options for the specdoc output, either :always, :never or :failure

  • :console (Symbol)

    options for the console.log output, either :always, :never or :failure

  • :errors (Symbol)

    options for the errors output, either :always, :never or :failure

  • :focus (Symbol)

    options for focus on failures in the specdoc

  • :coverage (Symbol)

    options for enable coverage support

  • :coverage_html (Symbol)

    options for enable coverage html support

  • :coverage_summary (Symbol)

    options for enable coverage summary support

  • :statements_threshold (Symbol)

    options for the statement coverage threshold

  • :functions_threshold (Symbol)

    options for the statement function threshold

  • :branches_threshold (Symbol)

    options for the statement branch threshold

  • :lines_threshold (Symbol)

    options for the statement lines threshold

  • :run_all (Hash)

    options overwrite options when run all specs



87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
# File 'lib/guard/jasmine.rb', line 87

def initialize(options = {})
  options[:server_mount] ||= defined?(JasmineRails) ? '/specs' : '/jasmine'

  options = DEFAULT_OPTIONS.merge(options)

  options[:spec_dir]    ||= File.exist?(File.join('spec', 'javascripts')) ? File.join('spec', 'javascripts') : 'spec'
  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 unless [:always, :never, :failure].include? options[:specdoc]
  options[:phantomjs_bin] = Jasmine.which('phantomjs') unless options[:phantomjs_bin]

  self.run_all_options = options.delete(:run_all) || {}

  super(options)

  self.last_run_failed   = false
  self.last_failed_paths = []
  ::Jasmine.configure do |config|
    config.server_port = options[:port] if options[:port]
  end
  @runner = Runner.new(options.merge(run_all_options))
end

Instance Attribute Details

#last_failed_pathsObject

Returns the value of attribute last_failed_paths



19
20
21
# File 'lib/guard/jasmine.rb', line 19

def last_failed_paths
  @last_failed_paths
end

#last_run_failedObject

Returns the value of attribute last_run_failed



19
20
21
# File 'lib/guard/jasmine.rb', line 19

def last_run_failed
  @last_run_failed
end

#run_all_optionsObject

Returns the value of attribute run_all_options



19
20
21
# File 'lib/guard/jasmine.rb', line 19

def run_all_options
  @run_all_options
end

#runnerObject

Returns the value of attribute runner



19
20
21
# File 'lib/guard/jasmine.rb', line 19

def runner
  @runner
end

Instance Method Details

#reloadObject

Gets called when the Guard should reload itself.

Raises:

  • (:task_has_failed)

    when reload has failed



139
140
141
142
# File 'lib/guard/jasmine.rb', line 139

def reload
  self.last_run_failed   = false
  self.last_failed_paths = []
end

#run_allObject

Gets called when all specs should be run.

Raises:

  • (:task_has_failed)

    when run_all has failed



148
149
150
151
152
153
154
155
# File 'lib/guard/jasmine.rb', line 148

def run_all
  results = runner.run([options[:spec_dir]])

  self.last_failed_paths = results.keys
  self.last_run_failed   = !results.empty?

  throw :task_has_failed if last_run_failed
end

#run_on_modifications(paths) ⇒ Object

Gets called when watched paths and files have changes.

Raises:

  • (:task_has_failed)

    when run_on_modifications has failed



162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
# File 'lib/guard/jasmine.rb', line 162

def run_on_modifications(paths)
  specs = options[:keep_failed] ? paths + last_failed_paths : paths
  specs = Inspector.clean(specs, options) if options[:clean]

  return false if specs.empty?

  results = runner.run(specs)

  if results.empty?
    self.last_failed_paths = last_failed_paths - paths
    run_all if last_run_failed && options[:all_after_pass]
  else
    self.last_failed_paths = last_failed_paths + results.keys
  end

  self.last_run_failed = !results.empty?

  throw :task_has_failed if last_run_failed
end

#startObject

Gets called once when Guard starts.

Raises:

  • (:task_has_failed)

    when start has failed



116
117
118
119
120
121
122
123
124
125
# File 'lib/guard/jasmine.rb', line 116

def start
  if Jasmine.phantomjs_bin_valid?(options[:phantomjs_bin])

    Server.start(options) unless options[:server] == :none

    run_all if Jasmine.runner_available?(options) && options[:all_on_start]
  else
    throw :task_has_failed
  end
end

#stopObject

Gets called once when Guard stops.

Raises:

  • (:task_has_failed)

    when stop has failed



131
132
133
# File 'lib/guard/jasmine.rb', line 131

def stop
  Server.stop unless options[:server] == :none
end