Class: Guard::Jasmine::CLI

Inherits:
Thor
  • Object
show all
Extended by:
Util
Defined in:
lib/guard/jasmine/cli.rb

Overview

Small helper class to run the Jasmine runner_options once from the command line. This can be useful to integrate guard-jasmine into a continuous integration server.

This outputs the specdoc and disables any notifications.

Instance Method Summary collapse

Methods included from Util

find_free_server_port, phantomjs_bin_valid?, runner_available?, which

Instance Method Details

#spec(*paths) ⇒ Object

Run the Guard::Jasmine::Runner with options from the command line.

Parameters:

  • paths (Array<String>)

    the name of the specs to run



173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
# File 'lib/guard/jasmine/cli.rb', line 173

def spec(*paths)
  runner_options                            = {}
  runner_options[:port]                     = options.port || CLI.find_free_server_port
  runner_options[:spec_dir]                 = options.spec_dir || (File.exist?(File.join('spec', 'javascripts')) ? File.join('spec', 'javascripts') : 'spec')
  runner_options[:line_number]              = options.line_number
  runner_options[:server]                   = options.server.to_sym == :auto ? ::Guard::Jasmine::Server.detect_server(runner_options[:spec_dir]) : options.server.to_sym
  runner_options[:server_mount]             = options.mount || (defined?(JasmineRails) ? '/specs' : '/jasmine')
  runner_options[:jasmine_url]              = options.url || "http://localhost:#{ runner_options[:port] }#{ options.server.to_sym == :jasmine_gem ? '/' : runner_options[:server_mount] }"
  runner_options[:phantomjs_bin]            = options.bin || CLI.which('phantomjs')
  runner_options[:timeout]                  = options.timeout
  runner_options[:verbose]                  = options.verbose
  runner_options[:server_env]               = options.server_env
  runner_options[:server_timeout]           = options.server_timeout
  runner_options[:rackup_config]            = options.rackup_config
  runner_options[:console]                  = [:always, :never, :failure].include?(options.console.to_sym) ? options.console.to_sym : :failure
  runner_options[:errors]                   = [:always, :never, :failure].include?(options.errors.to_sym) ? options.errors.to_sym : :failure
  runner_options[:specdoc]                  = [:always, :never, :failure].include?(options.specdoc.to_sym) ? options.specdoc.to_sym : :always
  runner_options[:focus]                    = options.focus
  runner_options[:coverage]                 = options.coverage || options.coverage_html || options.coverage_summary || options.coverage_html_dir != './coverage'
  runner_options[:coverage_html]            = options.coverage_html || options.coverage_html_dir != './coverage'
  runner_options[:coverage_html_dir]        = options.coverage_html_dir
  runner_options[:coverage_summary]         = options.coverage_summary
  runner_options[:ignore_instrumentation]   = options.ignore_instrumentation
  runner_options[:statements_threshold]     = options.statements_threshold
  runner_options[:functions_threshold]      = options.functions_threshold
  runner_options[:branches_threshold]       = options.branches_threshold
  runner_options[:lines_threshold]          = options.lines_threshold
  runner_options[:notification]             = false
  runner_options[:hide_success]             = true
  runner_options[:max_error_notify]         = 0
  runner_options[:junit]                    = options.junit
  runner_options[:junit_consolidate]        = options.junit_consolidate
  runner_options[:junit_save_path]          = options.junit_save_path
  runner_options[:is_cli]                   = true

  paths = [runner_options[:spec_dir]] if paths.empty?

  if CLI.phantomjs_bin_valid?(runner_options[:phantomjs_bin])
    catch(:task_has_failed) do
      ::Guard::Jasmine::Server.start(runner_options) unless runner_options[:server] == :none
    end

    if CLI.runner_available?(runner_options)
      result = ::Guard::Jasmine::Runner.new(runner_options).run(paths)
      ::Guard::Jasmine::Server.stop
      Process.exit result.empty? ? 0 : 1
    else
      Process.exit 2
    end

  else
    Process.exit 2
  end

rescue => e
  ::Guard::UI.error "Something went wrong: #{e.message}"
  Process.exit 2
ensure
  ::Guard::Jasmine::Server.stop
end

#versionObject

Shows the current version of Guard::Jasmine.

See Also:

  • VERSION


241
242
243
# File 'lib/guard/jasmine/cli.rb', line 241

def version
  ::Guard::UI.info "Guard::Jasmine version #{ ::Guard::JasmineVersion::VERSION }"
end