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,
  junit:                    false,
  junit_consolidate:        true,
  junit_save_path:          '',
  debug:                    false
}

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.

Parameters:

  • options (Hash) (defaults to: { })

    the options for the Guard

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



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

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

  options = DEFAULT_OPTIONS.merge(options)

  options[:spec_dir]    ||= File.exists?(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 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) || {}

  super(options)

  self.last_run_failed   = false
  self.last_failed_paths = []
  @runner = Runner.new( options.merge(self.run_all_options) )
end

Instance Attribute Details

#last_failed_pathsObject

Returns the value of attribute last_failed_paths



21
22
23
# File 'lib/guard/jasmine.rb', line 21

def last_failed_paths
  @last_failed_paths
end

#last_run_failedObject

Returns the value of attribute last_run_failed



21
22
23
# File 'lib/guard/jasmine.rb', line 21

def last_run_failed
  @last_run_failed
end

#run_all_optionsObject

Returns the value of attribute run_all_options



21
22
23
# File 'lib/guard/jasmine.rb', line 21

def run_all_options
  @run_all_options
end

#runnerObject

Returns the value of attribute runner



21
22
23
# File 'lib/guard/jasmine.rb', line 21

def runner
  @runner
end

Instance Method Details

#reloadObject

Gets called when the Guard should reload itself.

Raises:

  • (:task_has_failed)

    when reload has failed



142
143
144
145
# File 'lib/guard/jasmine.rb', line 142

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



151
152
153
154
155
156
157
158
# File 'lib/guard/jasmine.rb', line 151

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 self.last_run_failed
end

#run_on_modifications(paths) ⇒ Object

Gets called when watched paths and files have changes.

Parameters:

  • paths (Array<String>)

    the changed paths and files

Raises:

  • (:task_has_failed)

    when run_on_modifications has failed



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

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?

  results = runner.run(specs)

  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 + results.keys
  end

  self.last_run_failed = !results.empty?

  throw :task_has_failed if self.last_run_failed
end

#startObject

Gets called once when Guard starts.

Raises:

  • (:task_has_failed)

    when start has failed



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

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

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

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

#stopObject

Gets called once when Guard stops.

Raises:

  • (:task_has_failed)

    when stop has failed



134
135
136
# File 'lib/guard/jasmine.rb', line 134

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