guard-jasmine 1.3.0 → 1.19.2

data/lib/guard/jasmine/cli.rb

@@ -5,11 +5,12 @@ require 'guard/jasmine/runner'
 require 'guard/jasmine/formatter'
 require 'guard/jasmine/server'
 require 'guard/jasmine/util'
+require 'guard/jasmine/server'
 
 module Guard
   class Jasmine
 
-    # Small helper class to run the Jasmine runner once from the
+    # 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.
     #
@@ -20,60 +21,151 @@ module Guard
 
       default_task :spec
 
-      desc 'spec', 'Run the Jasmine spec runner'
+      desc 'spec', 'Run the Jasmine spec runner_options'
 
       method_option :server,
-                    :type => :string,
-                    :aliases => '-s',
-                    :default => 'auto',
-                    :desc => 'Server to start, either `auto`, `webrick`, `mongrel`, `thin`, `jasmine_gem` or `none`'
+                    type:    :string,
+                    aliases: '-s',
+                    default: 'auto',
+                    desc:    'Server to start, either `auto`, `webrick`, `mongrel`, `thin`, `unicorn`, `jasmine_gem` or `none`'
 
       method_option :port,
-                    :type => :numeric,
-                    :aliases => '-p',
-                    :default => 3001,
-                    :desc => 'Server port to use'
+                    type:    :numeric,
+                    aliases: '-p',
+                    desc:    'Server port to use'
 
-      method_option :url,
-                    :type => :string,
-                    :aliases => '-u',
-                    :default => 'http://localhost:3001/jasmine',
-                    :desc => 'The url of the Jasmine test runner'
+      method_option :server_env,
+                    type:    :string,
+                    aliases: '-e',
+                    default: ENV['RAILS_ENV'] || 'test',
+                    desc:    'The server environment to use, for example `development`, `test` etc.'
+
+      method_option :server_timeout,
+                    type:    :numeric,
+                    default: 60,
+                    desc:    'The number of seconds to wait for the Jasmine spec server'
+
+      method_option :verbose,
+                    type:    :boolean,
+                    default: false,
+                    desc:    'Show the server output in the console'
+
+      method_option :rackup_config,
+                    type:    :string,
+                    aliases: '-c',
+                    desc:    'The rackup config to use (jasminerice only)'
 
       method_option :bin,
-                    :type => :string,
-                    :aliases => '-b',
-                    :desc => 'The location of the PhantomJS binary'
+                    type:    :string,
+                    aliases: '-b',
+                    desc:    'The location of the PhantomJS binary'
+
+      method_option :spec_dir,
+                    type:    :string,
+                    aliases: '-d',
+                    desc:    'The directory with the Jasmine specs'
+
+      method_option :line_number,
+                    type:    :numeric,
+                    aliases: '-l',
+                    desc:    'The line which identifies the spec to be run'
+
+      method_option :url,
+                    type:    :string,
+                    aliases: '-u',
+                    desc:    'The url of the Jasmine test runner'
+
+      method_option :mount,
+                    type:    :string,
+                    aliases: '-m',
+                    desc:    'The mount point of the Jasmine test runner'
 
       method_option :timeout,
-                    :type => :numeric,
-                    :aliases => '-t',
-                    :default => 10000,
-                    :desc => 'The maximum time in milliseconds to wait for the spec runner to finish'
+                    type:    :numeric,
+                    aliases: '-t',
+                    default: 60,
+                    desc:    'The maximum time in seconds to wait for the spec runner to finish'
 
       method_option :console,
-                    :type => :string,
-                    :aliases => '-c',
-                    :default => 'failure',
-                    :desc => 'Whether to show console.log statements in the spec runner, either `always`, `never` or `failure`'
+                    type:    :string,
+                    default: 'failure',
+                    desc:    'Whether to show console.log statements in the spec runner, either `always`, `never` or `failure`'
 
       method_option :errors,
-                    :type => :string,
-                    :aliases => '-x',
-                    :default => 'failure',
-                    :desc => 'Whether to show errors in the spec runner, either `always`, `never` or `failure`'
-
-      method_option :server_env,
-                    :type => :string,
-                    :aliases => '-e',
-                    :default => 'test',
-                    :desc => 'The server environment to use, for example `development`, `test` etc.'
-
-      method_option :spec_dir,
-                    :type => :string,
-                    :aliases => '-d',
-                    :default => 'spec/javascripts',
-                    :desc => 'The directory with the Jasmine specs'
+                    type:    :string,
+                    default: 'failure',
+                    desc:    'Whether to show errors in the spec runner, either `always`, `never` or `failure`'
+
+      method_option :focus,
+                    type:    :boolean,
+                    aliases: '-f',
+                    default: true,
+                    desc:    'Specdoc focus to hide successful tests when at least one test fails'
+
+      method_option :specdoc,
+                    type:    :string,
+                    default: :always,
+                    desc:    'Whether to show successes in the spec runner, either `always`, `never` or `failure`'
+
+      method_option :coverage,
+                    type:    :boolean,
+                    default: false,
+                    desc:    'Whether to enable the coverage support or not'
+
+      method_option :coverage_html,
+                    type:    :boolean,
+                    default: false,
+                    desc:    'Whether to generate html coverage report. Implies --coverage'
+
+      method_option :coverage_html_dir,
+                    type:    :string,
+                    default: "./coverage",
+                    desc:    'Where to save html coverage reports. Defaults to ./coverage. Implies --coverage-html'
+
+      method_option :coverage_summary,
+                    type:    :boolean,
+                    default: false,
+                    desc:    'Whether to generate html coverage summary. Implies --coverage'
+
+      method_option :ignore_instrumentation,
+                    type:    :string,
+                    default: "",
+                    desc:    'Files matching this regex will not be instrumented (e.g. vendor)'
+
+      method_option :statements_threshold,
+                    type:    :numeric,
+                    default: 0,
+                    desc:    'Statements coverage threshold'
+
+      method_option :functions_threshold,
+                    type:    :numeric,
+                    default: 0,
+                    desc:    'Functions coverage threshold'
+
+      method_option :branches_threshold,
+                    type:    :numeric,
+                    default: 0,
+                    desc:    'Branches coverage threshold'
+
+      method_option :lines_threshold,
+                    type:    :numeric,
+                    default: 0,
+                    desc:    'Lines coverage threshold'
+
+      method_option :junit,
+                    type:    :boolean,
+                    default: false,
+                    desc:    'Whether to save jasmine test results in JUnit-compatible xml files'
+
+      method_option :junit_consolidate,
+                    type:    :boolean,
+                    default: false,
+                    desc:    'Whether to save nested describes within the same xml file as their parent'
+
+      method_option :junit_save_path,
+                    type:    :string,
+                    default: '',
+                    desc:    'The directory to save junit xml files into'
 
       # Run the Guard::Jasmine::Runner with options from
       # the command line.
@@ -81,33 +173,56 @@ module Guard
       # @param [Array<String>] paths the name of the specs to run
       #
       def spec(*paths)
-        paths = [options.spec_dir] if paths.empty?
-
-        runner = {}
-        runner[:jasmine_url] = options.url
-        runner[:phantomjs_bin] = options.bin || CLI.which('phantomjs')
-        runner[:timeout] = options.timeout
-        runner[:port] = options.port
-        runner[:server_env] = options.server_env
-        runner[:spec_dir] = options.spec_dir
-        runner[:console] = [:always, :never, :failure].include?(options.console.to_sym) ? options.console.to_sym : :failure
-        runner[:errors] = [:always, :never, :failure].include?(options.errors.to_sym) ? options.errors.to_sym : :failure
-        runner[:server] = options.server.to_sym
-
-        runner[:notification] = false
-        runner[:hide_success] = true
-        runner[:max_error_notify] = 0
-        runner[:specdoc] = :always
-
-        if CLI.phantomjs_bin_valid?(runner[:phantomjs_bin])
-          ::Guard::Jasmine::Server.start(runner[:server], runner[:port], runner[:server_env], runner[:spec_dir]) unless runner[:server] == :none
-
-          if CLI.runner_available?(runner[:jasmine_url])
-            result = ::Guard::Jasmine::Runner.run(paths, runner)
+        runner_options                            = {}
+        runner_options[:port]                     = options.port || CLI.find_free_server_port
+        runner_options[:spec_dir]                 = options.spec_dir || (File.exists?(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
+
+        ::Guard::UI.options = ::Guard::UI.options.merge({ :template => ':message' })
+
+        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.run(paths, runner_options)
             ::Guard::Jasmine::Server.stop
 
             Process.exit result.first ? 0 : 1
           else
+            ::Guard::Jasmine::Server.stop
             Process.exit 2
           end
 

data/lib/guard/jasmine/coverage.rb

@@ -0,0 +1,69 @@
+# coding: utf-8
+require 'tilt'
+require 'childprocess'
+require 'guard/jasmine'
+require 'guard/jasmine/util'
+
+# Tilt template to generate coverage instrumented
+# Jasmine specs files.
+#
+class JasmineCoverage < Tilt::Template
+  extend ::Guard::Jasmine::Util
+
+  def prepare
+  end
+
+  # Returns a coverage instrumented JavaScript file
+  #
+  def evaluate(context, locals)
+    return data if !ENV['IGNORE_INSTRUMENTATION'].to_s.empty? && file =~ Regexp.new(ENV['IGNORE_INSTRUMENTATION'])
+    return data unless JasmineCoverage.coverage_bin
+    return data unless file.include?(JasmineCoverage.app_asset_path)
+
+    Dir.mktmpdir do |path|
+      filename = File.basename(file)
+      input    = File.join(path, filename).sub /\.js.+/, '.js'
+
+      File.write input, data
+
+      result = %x[#{JasmineCoverage.coverage_bin} instrument --embed-source #{input.shellescape}]
+
+      raise "Could not generate coverage instrumented file for #{ file }" unless $?.exitstatus == 0
+
+      result.gsub input, file
+
+    end
+  end
+
+  private
+
+  # Get the absolute path to the projects assets path `/app/assets`.
+  #
+  # @return [String] the path to the Rails assets
+  #
+  def self.app_asset_path
+    @app_asset_path ||= File.join(Rails.root, 'app', 'assets')
+  end
+
+  # Returns the coverage executable path.
+  #
+  # @return [String] the path
+  #
+  def self.coverage_bin
+    @coverage_bin ||= which 'istanbul'
+  end
+
+end
+
+if ENV['COVERAGE'] == 'true' and defined?(Rails)
+
+  # Guard::Jasmine engine to register coverage instrumented
+  # Jasmine spec files.
+  #
+  class GuardJasmineCoverageEngine < ::Rails::Engine
+    initializer 'guard-jasmine.initialize' do |app|
+      app.assets.register_postprocessor 'application/javascript', JasmineCoverage
+    end
+  end
+
+end

data/lib/guard/jasmine/formatter.rb

@@ -54,7 +54,7 @@ module Guard
         # @param [Hash] options the output options
         #
         def spec_failed(message, options = { })
-           ::Guard::UI.info(color(message, ';31'), options)
+          ::Guard::UI.info(color(message, ';31'), options)
         end
 
         # Print a red spec failed message to the console.
@@ -63,7 +63,7 @@ module Guard
         # @param [Hash] options the output options
         #
         def suite_name(message, options = { })
-           ::Guard::UI.info(color(message, ';33'), options)
+          ::Guard::UI.info(color(message, ';33'), options)
         end
 
         # Outputs a system notification.
@@ -81,7 +81,7 @@ module Guard
 
         # Print a info message to the console.
         #
-        # @param [String] test the text to colorize
+        # @param [String] text the text to colorize
         # @param [String] color_code the color code
         #
         def color(text, color_code)

data/lib/guard/jasmine/inspector.rb

@@ -34,7 +34,7 @@ module Guard
 
         # Tests if the file is valid.
         #
-        # @param [String] file the file
+        # @param [String] path the file
         # @return [Boolean] when the file valid
         #
         def jasmine_spec?(path)

data/lib/guard/jasmine/phantomjs/guard-jasmine.coffee

@@ -5,11 +5,14 @@ phantom.injectJs 'lib/result.js'
 # Set default values
 options =
   url: phantom.args[0] || 'http://127.0.0.1:3000/jasmine'
-  timeout: parseInt(phantom.args[1] || 5000)
+  timeout: parseInt(phantom.args[1] || 10000)
   specdoc: phantom.args[2] || 'failure'
   focus: /true/i.test phantom.args[3]
   console: phantom.args[4] || 'failure'
   errors: phantom.args[5] || 'failure'
+  junit: /true/i.test phantom.args[6]
+  junit_consolidate: /true/i.test phantom.args[7]
+  junit_save_path: phantom.args[8] || ''
 
 # Create the web page.
 #
@@ -20,11 +23,13 @@ page = require('webpage').create()
 currentSpecId = -1
 logs = {}
 errors = {}
+resultsKey = "__jr" + Math.ceil(Math.random() * 1000000)
+fs = require("fs")
 
 # Catch JavaScript errors
 #
 page.onError = (msg, trace) ->
-  if currentSpecId && currentSpecId isnt -1
+  if currentSpecId
     errors[currentSpecId] ||= []
     errors[currentSpecId].push({ msg: msg, trace: trace })
 
@@ -39,72 +44,150 @@ page.onConsoleMessage = (msg, line, source) ->
 
   else if /^SPEC_START: (\d+)$/.test(msg)
     currentSpecId = Number(RegExp.$1)
-    logs[currentSpecId] = []
 
   else
-    logs[currentSpecId].push(msg) if currentSpecId isnt -1
+    logs[currentSpecId] ||= []
+    logs[currentSpecId].push(msg)
 
 # Initialize the page before the JavaScript is run.
 #
 page.onInitialized = ->
+  overloadPageEvaluate(page)
+  setupWriteFileFunction(page, resultsKey, fs.separator)
+
   page.injectJs 'lib/console.js'
   page.injectJs 'lib/reporter.js'
+  page.injectJs 'lib/junit_reporter.js'
 
-  page.evaluate ->
+  setupReporters = ->
     # Attach the console reporter when the document is ready.
     window.onload = ->
+      window.onload = null
       window.resultReceived = false
       window.reporter = new ConsoleReporter()
-      jasmine.getEnv().addReporter(window.reporter)
+      if window.jasmine
+        jasmine.getEnv().addReporter(new JUnitXmlReporter("%save_path%", "%consolidate%"))
+        jasmine.getEnv().addReporter(window.reporter)
+
+  page.evaluate(setupReporters, {save_path: options.junit_save_path, consolidate: options.junit_consolidate})
+
+
+getXmlResults = (page, key) ->
+  getWindowObj = ->
+    window["%resultsObj%"] || {}
+  page.evaluate getWindowObj, {resultsObj: key}
+
+replaceFunctionPlaceholders= (fn, replacements) ->
+  if replacements && typeof replacements == 'object'
+    fn = fn.toString()
+    for p of replacements
+      if replacements.hasOwnProperty(p)
+        match = new RegExp("%" + p + "%", "g")
+        loop
+          fn = fn.replace(match, replacements[p])
+          break unless fn.indexOf(match) != -1
+  fn
+
+overloadPageEvaluate = (page) ->
+  page._evaluate = page.evaluate
+  page.evaluate = (fn, replacements) ->
+    page._evaluate(replaceFunctionPlaceholders(fn, replacements))
+  page
+
+setupWriteFileFunction= (page,key, path_separator) ->
+  saveData = () ->
+     window["%resultsObj%"] = {}
+     window.fs_path_separator = "%fs_path_separator%"
+     window.__phantom_writeFile = (filename, text) ->
+         window["%resultsObj%"][filename] = text;
+
+  page.evaluate saveData, {resultsObj: key, fs_path_separator: path_separator}
 
 # Open web page and run the Jasmine test runner
 #
 page.open options.url, (status) ->
   # Avoid that a failed iframe load breaks the runner, see https://github.com/netzpirat/guard-jasmine/pull/19
   page.onLoadFinished = ->
-
   if status isnt 'success'
     console.log JSON.stringify({ error: "Unable to access Jasmine specs at #{ options.url }" })
     phantom.exit()
   else
-    done = -> phantom.exit()
-    waitFor specsReady, done, options.timeout
+    waitFor jasmineReady, jasmineAvailable, options.timeout, jasmineMissing
+
+# Test if the jasmine has been loaded
+#
+jasmineReady = ->
+  page.evaluate -> window.jasmine
+
+# Start specs after they are have been loaded
+#
+jasmineAvailable = ->
+  waitFor specsReady, specsDone, options.timeout, specsTimedout
+
+# Error message for when jasmine never loaded asynchronously
+#
+jasmineMissing = ->
+  text = page.evaluate -> document.getElementsByTagName('body')[0]?.innerText
+
+  if text
+    error = """
+            The Jasmine reporter is not available!
+
+            #{ text }
+            """
+    console.log JSON.stringify({ error: error })
+  else
+    console.log JSON.stringify({ error: 'The Jasmine reporter is not available!' })
 
 # Test if the specs have finished.
 #
 specsReady = ->
   page.evaluate -> window.resultReceived
 
+# Error message for when specs time out
+#
+specsTimedout = ->
+  text = page.evaluate -> document.getElementsByTagName('body')[0]?.innerText
+  if text
+    error = """
+            Timeout waiting for the Jasmine test results!
+
+            #{ text }
+            """
+    console.log JSON.stringify({ error: error })
+  else
+    console.log JSON.stringify({ error: 'Timeout for the Jasmine test results!' })
+
+specsDone = ->
+  if options.junit == true
+    xml_results = getXmlResults(page, resultsKey)
+    for filename of xml_results
+      if xml_results.hasOwnProperty(filename) && (output = xml_results[filename]) && typeof(output) == 'string'
+        fs.write(filename, output, 'w')
+
+  phantom.exit()
+
 # Wait until the test condition is true or a timeout occurs.
 #
 # @param [Function] test the test that returns true if condition is met
 # @param [Function] ready the action when the condition is fulfilled
 # @param [Number] timeout the max amount of time to wait in milliseconds
 #
-waitFor = (test, ready, timeout = 5000) ->
-    start = new Date().getTime()
-    condition = false
-
-    wait = ->
-      if (new Date().getTime() - start < timeout) and not condition
-        condition = test()
+waitFor = (test, ready, timeout = 10000, timeoutFunction) ->
+  start = Date.now()
+  condition = false
+  interval = undefined
+
+  wait = ->
+    if (Date.now() - start < timeout) and not condition
+      condition = test()
+    else
+      clearInterval interval
+
+      if condition
+        ready()
       else
-        if not condition
-          text = page.evaluate -> document.getElementsByTagName('body')[0]?.innerText
-
-          if text
-            error = """
-                    Timeout waiting for the Jasmine test results!
-
-                    #{ text }
-                    """
-            console.log JSON.stringify({ error: error })
-          else
-            console.log JSON.stringify({ error: 'Timeout waiting for the Jasmine test results!' })
-
-          phantom.exit(1)
-        else
-          ready()
-          clearInterval interval
+        timeoutFunction()
+        phantom.exit(1)
 
-    interval = setInterval wait, 250
+  interval = setInterval wait, 250