guard-jasmine 0.9.14 → 1.0.0

data/lib/guard/jasmine/phantomjs/lib/reporter.js

@@ -0,0 +1,134 @@
+(function() {
+  var ConsoleReporter;
+
+  ConsoleReporter = (function() {
+
+    function ConsoleReporter() {}
+
+    ConsoleReporter.prototype.runnerResult = {
+      passed: false,
+      stats: {
+        specs: 0,
+        failures: 0,
+        time: 0.0
+      },
+      suites: []
+    };
+
+    ConsoleReporter.prototype.specCount = 0;
+
+    ConsoleReporter.prototype.currentSpecs = [];
+
+    ConsoleReporter.prototype.nestedSuiteResults = {};
+
+    ConsoleReporter.prototype.reportSpecStarting = function(spec) {
+      return console.log("SPEC_START: " + spec.id);
+    };
+
+    ConsoleReporter.prototype.reportSpecResults = function(spec) {
+      var messages, result, specResult, _i, _len, _ref;
+      if (!spec.results().skipped) {
+        specResult = {
+          id: spec.id,
+          description: spec.description,
+          passed: spec.results().failedCount === 0
+        };
+        if (spec.results().failedCount !== 0) {
+          messages = [];
+          _ref = spec.results().getItems();
+          for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+            result = _ref[_i];
+            messages.push(result.message);
+          }
+          if (messages.length !== 0) specResult['messages'] = messages;
+        }
+        this.specCount += 1;
+        return this.currentSpecs.push(specResult);
+      }
+    };
+
+    ConsoleReporter.prototype.reportSuiteResults = function(suite) {
+      var parent, suiteResult, _ref;
+      if (!suite.results().skipped) {
+        suiteResult = {
+          id: suite.id,
+          parent: (_ref = suite.parentSuite) != null ? _ref.id : void 0,
+          description: suite.description,
+          passed: suite.results().failedCount === 0,
+          specs: this.currentSpecs,
+          suites: []
+        };
+        if (suite.parentSuite != null) {
+          parent = suite.parentSuite.id;
+          if (!this.nestedSuiteResults[parent]) {
+            this.nestedSuiteResults[parent] = [];
+          }
+          this.nestedSuiteResults[parent].push(suiteResult);
+        } else {
+          this.addNestedSuites(suiteResult);
+          this.removeEmptySuites(suiteResult);
+          if (suiteResult.specs.length !== 0 || suiteResult.suites.length !== 0) {
+            this.runnerResult.suites.push(suiteResult);
+          }
+        }
+      }
+      return this.currentSpecs = [];
+    };
+
+    ConsoleReporter.prototype.reportRunnerResults = function(runner) {
+      var runtime;
+      runtime = (new Date().getTime() - this.startTime) / 1000;
+      this.runnerResult['passed'] = runner.results().failedCount === 0;
+      this.runnerResult['stats'] = {
+        specs: this.specCount,
+        failures: runner.results().failedCount,
+        time: runtime
+      };
+      return console.log("RUNNER_RESULT: " + (JSON.stringify(this.runnerResult)));
+    };
+
+    ConsoleReporter.prototype.reportRunnerStarting = function(runner) {
+      return this.startTime = new Date().getTime();
+    };
+
+    ConsoleReporter.prototype.addNestedSuites = function(suiteResult) {
+      var suite, _i, _len, _ref, _results;
+      if (this.nestedSuiteResults[suiteResult.id]) {
+        _ref = this.nestedSuiteResults[suiteResult.id];
+        _results = [];
+        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+          suite = _ref[_i];
+          this.addNestedSuites(suite);
+          _results.push(suiteResult.suites.push(suite));
+        }
+        return _results;
+      }
+    };
+
+    ConsoleReporter.prototype.removeEmptySuites = function(suiteResult) {
+      var suite, suites, _i, _len, _ref;
+      suites = [];
+      _ref = suiteResult.suites;
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        suite = _ref[_i];
+        this.removeEmptySuites(suite);
+        if (suite.suites.length !== 0 || suite.specs.length !== 0) {
+          suites.push(suite);
+        }
+      }
+      return suiteResult.suites = suites;
+    };
+
+    ConsoleReporter.prototype.log = function(message) {};
+
+    return ConsoleReporter;
+
+  })();
+
+  if (typeof module !== 'undefined' && module.exports) {
+    module.exports = ConsoleReporter;
+  } else {
+    window.ConsoleReporter = ConsoleReporter;
+  }
+
+}).call(this);

data/lib/guard/jasmine/phantomjs/src/console.coffee

@@ -0,0 +1,149 @@
+# Simplified console logger rreplacement.
+#
+class Console
+
+  # Construct the console wrapper and attach
+  # the log methods.
+  #
+  constructor: (console) ->
+    log = console.log
+
+    console.log = (args...) ->
+      log.call console, Console.format(args...)
+
+    console.info = (args...) ->
+      log.call console, "INFO: #{ Console.format(args...) }"
+
+    console.warn = (args...) ->
+      log.call console, "WARN: #{ Console.format(args...) }"
+
+    console.error = (args...) ->
+      log.call console, "ERROR: #{ Console.format(args...) }"
+
+    console.debug = (args...) ->
+      log.call console, "DEBUG: #{ Console.format(args...) }"
+
+  @MAX_OBJECT_DEPTH: 2
+
+  # Format the console arguments. This parses the known
+  # % placeholder with the object value and/or concatenates
+  # the arguments.
+  #
+  # @param [Array] args the log arguments
+  #
+  @format: (args...) ->
+    result = []
+
+    if typeof args[0] is 'string' and /%[sdifo]/gi.test args[0]
+      arg = args.shift()
+      result.push arg.replace /%[sdifo]/gi, (str) => Console.inspect args.shift(), str
+
+    result.push Console.inspect arg for arg in args
+    result.join ' '
+
+  # Inspect a log object and return a string representation.
+  #
+  # @param [Object] object the object to inspect
+  # @param [String] type the format type
+  # @return [String] a string representation
+  #
+  @inspect: (object, type) ->
+    switch type
+      when '%s'
+        result = String(object)
+        result = match[1] if match = /'(.*)'/.exec result
+
+      when '%d', '%i'
+        result = parseInt object
+
+      when '%f'
+        result = parseFloat object
+
+      else
+        type = Object::toString.call(object).slice 8, -1
+
+        if type is 'Object' and object.toJSON
+          result = Console.pp object.toJSON()
+
+        else if type is 'Object' and object.toString and object.toString() isnt '[object Object]'
+          result = Console.pp object.toString()
+          result = match[1] if match = /'(.*)'/.exec result
+
+        else if type is 'String'
+          result = String(object)
+          result = match[1] if match = /'(.*)'/.exec result
+
+        else
+          result = Console.pp object
+
+    result
+
+  # Pretty print an object
+  #
+  # @param [Object] object the object to inspect
+  # @param [Number] depth the object depth
+  # @return [String] a string representation
+  #
+  @pp: (object, depth = 0) ->
+    type = Object::toString.call(object).slice 8, -1
+    result = ''
+
+    switch type
+      when 'Undefined', 'Null'
+        result += type.toLowerCase()
+
+      when 'Boolean', 'Number', 'Date'
+        result += object.toString()
+
+      when 'String'
+        result += "'#{ object.toString() }'"
+
+      when 'Array'
+        if object.length > 0
+          result += '['
+
+          for value in object
+            if depth < Console.MAX_OBJECT_DEPTH or Object::toString.call(value).slice(8, -1) isnt 'Object'
+              result += "#{ Console.pp value, depth + 1 }, "
+            else
+              result += "[Object], "
+
+          result = result.slice(0, -2)
+          result += ']'
+        else
+          result += '[]'
+
+      when 'Object'
+        if object.jquery
+          if object.length > 0
+            result += '['
+
+            object.each -> result += jQuery(@).html()
+
+            result += ']'
+          else
+            result += '[]'
+
+        else if Object.keys(object).length > 0
+          result += '{ '
+
+          for key, value of object
+            if depth < Console.MAX_OBJECT_DEPTH or Object::toString.call(value).slice(8, -1) isnt 'Object'
+              result += "#{ key }: #{ Console.pp value, depth + 1 }, " if object.hasOwnProperty key
+            else
+              result += "#{ key }: [Object], "
+
+          result = result.slice(0, -2)
+          result += ' }'
+        else
+          result += '{}'
+
+      when 'Function'
+        result += '[Function]'
+
+    result
+
+if typeof module isnt 'undefined' and module.exports
+  module.exports = Console if module
+else
+  new Console(window.console) if window

data/lib/guard/jasmine/phantomjs/src/reporter.coffee

@@ -0,0 +1,134 @@
+# Jasmine Reporter that logs reporter steps
+# and results to the console.
+#
+class ConsoleReporter
+
+  runnerResult: {
+    passed: false
+    stats: {
+      specs: 0
+      failures: 0
+      time: 0.0
+    }
+    suites: []
+  }
+
+  specCount: 0
+  currentSpecs: []
+  nestedSuiteResults: {}
+
+  # Report the start of a spec.
+  #
+  # @param spec [jasmine.Spec] the spec
+  #
+  reportSpecStarting: (spec) ->
+    console.log "SPEC_START: #{ spec.id }"
+
+  # Report results from a spec.
+  #
+  # @param spec [jasmine.Spec] the spec
+  #
+  reportSpecResults: (spec) ->
+    unless spec.results().skipped
+      specResult = {
+        id: spec.id
+        description: spec.description
+        passed: spec.results().failedCount is 0
+      }
+
+      if spec.results().failedCount isnt 0
+        messages = []
+        messages.push result.message for result in spec.results().getItems()
+        specResult['messages'] = messages if messages.length isnt 0
+
+      @specCount += 1
+      @currentSpecs.push specResult
+
+  # Report results from a suite.
+  #
+  # @param suite [jasmine.Suite] the suite
+  #
+  reportSuiteResults: (suite) ->
+    unless suite.results().skipped
+      suiteResult = {
+        id: suite.id
+        parent: suite.parentSuite?.id
+        description: suite.description
+        passed: suite.results().failedCount is 0
+        specs: @currentSpecs
+        suites: []
+      }
+
+      if suite.parentSuite?
+        parent = suite.parentSuite.id
+        @nestedSuiteResults[parent] = [] unless @nestedSuiteResults[parent]
+        @nestedSuiteResults[parent].push suiteResult
+      else
+        @addNestedSuites suiteResult
+        @removeEmptySuites suiteResult
+
+        if suiteResult.specs.length isnt 0 || suiteResult.suites.length isnt 0
+          @runnerResult.suites.push suiteResult
+
+    @currentSpecs = []
+
+  # Report results from the runner.
+  #
+  # @param runner [jasmine.Runner] the runner
+  #
+  reportRunnerResults: (runner) ->
+    runtime = (new Date().getTime() - @startTime) / 1000
+
+    @runnerResult['passed'] = runner.results().failedCount is 0
+
+    @runnerResult['stats'] = {
+      specs: @specCount
+      failures: runner.results().failedCount
+      time: runtime
+    }
+
+    console.log "RUNNER_RESULT: #{ JSON.stringify(@runnerResult) }"
+
+  # Report the start of the runner
+  #
+  # @param runner [jasmine.Runner] the runner
+  #
+  reportRunnerStarting: (runner) ->
+    @startTime = new Date().getTime()
+
+  # Add all nested suites that have previously
+  # been processed.
+  #
+  # @param suiteResult [Object] the suite result
+  #
+  addNestedSuites: (suiteResult) ->
+    if @nestedSuiteResults[suiteResult.id]
+      for suite in @nestedSuiteResults[suiteResult.id]
+        @addNestedSuites suite
+        suiteResult.suites.push suite
+
+  # Removes suites without child suites or specs.
+  #
+  # @param suiteResult [Object] the suite result
+  #
+  removeEmptySuites: (suiteResult) ->
+    suites = []
+
+    for suite in suiteResult.suites
+      @removeEmptySuites suite
+
+      suites.push suite if suite.suites.length isnt 0 || suite.specs.length isnt 0
+
+    suiteResult.suites = suites
+
+  # Log a message
+  #
+  # @param message [String] the log message
+  #
+  log: (message) ->
+
+
+if typeof module isnt 'undefined' and module.exports
+  module.exports = ConsoleReporter
+else
+  window.ConsoleReporter = ConsoleReporter

data/lib/guard/jasmine/phantomjs/test/console_spec.coffee

@@ -0,0 +1,125 @@
+sinon    = require 'sinon'
+{expect} = require 'chai'
+
+Console  = require '../src/console'
+
+describe 'console', ->
+  beforeEach ->
+    @log = sinon.stub()
+    @console = { log: @log }
+
+    new Console(@console)
+
+  describe '#log', ->
+    describe 'with strings', ->
+      it 'logs a single string', ->
+        @console.log 'Hello logger'
+        expect(@log.args[0][0]).to.equal 'Hello logger'
+
+      it 'concatenates multipe strings', ->
+        @console.log 'Hello logger', 'We welcome you', 'Here on Earth'
+        expect(@log.args[0][0]).to.equal 'Hello logger We welcome you Here on Earth'
+
+      it 'replaces a single %s', ->
+        @console.log 'Hello %s!', 'logger'
+        expect(@log.args[0][0]).to.equal 'Hello logger!'
+
+      it 'replaces multiple %s', ->
+        @console.log 'Hello %s, we welcome you to %s!', 'logger', 'Switzerland'
+        expect(@log.args[0][0]).to.equal 'Hello logger, we welcome you to Switzerland!'
+
+      it 'attaches %s surplus strings', ->
+        @console.log 'Hello %s, we welcome you to Switzerland!', 'logger', 'Yay!'
+        expect(@log.args[0][0]).to.equal 'Hello logger, we welcome you to Switzerland! Yay!'
+
+    describe 'with numbers', ->
+      it 'logs a single number', ->
+        @console.log 1
+        expect(@log.args[0][0]).to.equal '1'
+
+      it 'concatenates multipe numbers', ->
+        @console.log 1, 2, 3, 4
+        expect(@log.args[0][0]).to.equal '1 2 3 4'
+
+      it 'replaces a single %d', ->
+        @console.log 'Hello %d!', 1
+        expect(@log.args[0][0]).to.equal 'Hello 1!'
+
+      it 'replaces a single %i', ->
+        @console.log 'Hello %i!', 3
+        expect(@log.args[0][0]).to.equal 'Hello 3!'
+
+      it 'replaces multiple %d', ->
+        @console.log 'I can count %d, %d and %d!', 1, 2, 3
+        expect(@log.args[0][0]).to.equal 'I can count 1, 2 and 3!'
+
+      it 'replaces multiple %i', ->
+        @console.log 'I can count reverse %i, %i and %i!', 3, 2, 1
+        expect(@log.args[0][0]).to.equal 'I can count reverse 3, 2 and 1!'
+
+      it 'attaches %d surplus numbers', ->
+        @console.log 'Hello %d!', 1, 2, 3
+        expect(@log.args[0][0]).to.equal 'Hello 1! 2 3'
+
+      it 'attaches %i surplus numbers', ->
+        @console.log 'Hello %i!', 1, 2, 3
+        expect(@log.args[0][0]).to.equal 'Hello 1! 2 3'
+
+    describe 'with objects', ->
+      it 'logs a boolean', ->
+        @console.log true, false
+        expect(@log.args[0][0]).to.equal 'true false'
+
+      it 'logs a date', ->
+        @console.log new Date('Thu Mar 08 2012 20:28:56 GMT+0100 (CET)')
+        expect(@log.args[0][0]).to.equal 'Thu Mar 08 2012 20:28:56 GMT+0100 (CET)'
+
+      it 'logs an array', ->
+        @console.log [1, 2, 3, 4]
+        expect(@log.args[0][0]).to.equal '[1, 2, 3, 4]'
+
+      it 'logs an object', ->
+        @console.log { a: 1 }
+        expect(@log.args[0][0]).to.equal '{ a: 1 }'
+
+      it 'logs a nested object', ->
+        @console.log "Hello object %o. Nice to meet you", { a: 1, b: { x: 1 } }
+        expect(@log.args[0][0]).to.equal 'Hello object { a: 1, b: { x: 1 } }. Nice to meet you'
+
+      it 'logs a nested object until depth 2', ->
+        @console.log "Hello object %o. Nice to meet you", { a: 1, b: { x: { a: 1, b: { x: 1 } } } }
+        expect(@log.args[0][0]).to.equal 'Hello object { a: 1, b: { x: { a: 1, b: [Object] } } }. Nice to meet you'
+
+    describe 'with an Object that implements toString()', ->
+      it '%s logs the custom string representation', ->
+        @console.log 'I have a toString(): %s!', { toString: -> '[Yepa]' }
+        expect(@log.args[0][0]).to.equal 'I have a toString(): [Yepa]!'
+
+      it '%o logs the custom string representation', ->
+        @console.log 'I have a toString(): %o!', { toString: -> '[Yepa]' }
+        expect(@log.args[0][0]).to.equal 'I have a toString(): [Yepa]!'
+
+    describe 'with an Object that implements toJSON()', ->
+      it '%o logs the custom JSON representation', ->
+        @console.log 'I have a toJSON(): %o!', { toJSON: -> { a: 1 } }
+        expect(@log.args[0][0]).to.equal 'I have a toJSON(): { a: 1 }!'
+
+  describe '#info', ->
+    it 'prefixes a string with INFO', ->
+      @console.info true, { a: 1 }, 'Hello logger'
+      expect(@log.args[0][0]).to.equal 'INFO: true { a: 1 } Hello logger'
+
+  describe '#warn', ->
+    it 'prefixes a string with WARN', ->
+      @console.warn true, { a: 1 }, 'Hello logger'
+      expect(@log.args[0][0]).to.equal 'WARN: true { a: 1 } Hello logger'
+
+  describe '#error', ->
+    it 'prefixes a string with ERROR', ->
+      @console.error true, { a: 1 }, 'Hello logger'
+      expect(@log.args[0][0]).to.equal 'ERROR: true { a: 1 } Hello logger'
+
+  describe '#debug', ->
+    it 'prefixes a string with DEBUG', ->
+      @console.debug true, { a: 1 }, 'Hello logger'
+      expect(@log.args[0][0]).to.equal 'DEBUG: true { a: 1 } Hello logger'