guard-jasmine 1.19.2 → 2.0.0beta1

data/lib/guard/jasmine/cli.rb

@@ -217,12 +217,10 @@ module Guard
           end
 
           if CLI.runner_available?(runner_options)
-            result = ::Guard::Jasmine::Runner.run(paths, runner_options)
+            result = ::Guard::Jasmine::Runner.new(runner_options).run(paths)
             ::Guard::Jasmine::Server.stop
-
-            Process.exit result.first ? 0 : 1
+            Process.exit result.empty? ? 0 : 1
           else
-            ::Guard::Jasmine::Server.stop
             Process.exit 2
           end
 
@@ -231,8 +229,10 @@ module Guard
         end
 
       rescue => e
-        ::Guard::UI.error e.message
+        ::Guard::UI.error "Something went wrong: #{e.message}"
         Process.exit 2
+      ensure
+        ::Guard::Jasmine::Server.stop
       end
 
       desc 'version', 'Show the Guard::Jasmine version'

data/lib/guard/jasmine/formatter.rb

@@ -48,6 +48,16 @@ module Guard
           ::Guard::UI.info(color(message, ';32'), options)
         end
 
+        # Print a yellow pending message to the console.
+        #
+        # @param [String] message the message to print
+        # @param [Hash] options the output options
+        # @option options [Boolean] :reset reset the UI
+        #
+        def spec_pending(message, options = { })
+          ::Guard::UI.info(color(message, ';33'), options)
+        end
+
         # Print a red spec failed message to the console.
         #
         # @param [String] message the message to print

data/lib/guard/jasmine/inspector.rb

@@ -20,7 +20,6 @@ module Guard
         def clean(paths, options)
           paths.uniq!
           paths.compact!
-
           if paths.include?(options[:spec_dir])
             paths = [options[:spec_dir]]
           else
@@ -38,7 +37,7 @@ module Guard
         # @return [Boolean] when the file valid
         #
         def jasmine_spec?(path)
-          path =~ /_spec\.(js|coffee|js\.coffee)$/ && File.exists?(path)
+          path =~ /(?:_s|S)pec\.(js|coffee|js\.coffee)$/ && File.exists?(path)
         end
 
       end

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

@@ -1,246 +1,120 @@
 (function() {
-  var currentSpecId, errors, fs, getXmlResults, jasmineAvailable, jasmineMissing, jasmineReady, logs, options, overloadPageEvaluate, page, replaceFunctionPlaceholders, resultsKey, setupWriteFileFunction, specsDone, specsReady, specsTimedout, waitFor;
-
-  phantom.injectJs('lib/result.js');
+  var exitSuccessfully, jasmineAvailable, options, page, reportError, reporterMissing, reporterReady, specsDone, specsTimedout, waitFor;
 
   options = {
     url: phantom.args[0] || 'http://127.0.0.1:3000/jasmine',
-    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] || ''
+    timeout: parseInt(phantom.args[1] || 10000)
   };
 
   page = require('webpage').create();
 
-  currentSpecId = -1;
-
-  logs = {};
-
-  errors = {};
-
-  resultsKey = "__jr" + Math.ceil(Math.random() * 1000000);
-
-  fs = require("fs");
-
-  page.onError = function(msg, trace) {
-    if (currentSpecId) {
-      errors[currentSpecId] || (errors[currentSpecId] = []);
-      return errors[currentSpecId].push({
-        msg: msg,
-        trace: trace
-      });
-    }
-  };
-
-  page.onConsoleMessage = function(msg, line, source) {
-    var result;
-
-    if (/^RUNNER_END$/.test(msg)) {
-      result = page.evaluate(function() {
-        return window.reporter.runnerResult;
-      });
-      console.log(JSON.stringify(new Result(result, logs, errors, options).process()));
-      return page.evaluate(function() {
-        return window.resultReceived = true;
-      });
-    } else if (/^SPEC_START: (\d+)$/.test(msg)) {
-      return currentSpecId = Number(RegExp.$1);
-    } else {
-      logs[currentSpecId] || (logs[currentSpecId] = []);
-      return logs[currentSpecId].push(msg);
-    }
+  page.onError = function(message, trace) {
+    return reportError("Javascript error encountered on Jasmine test page: " + message, trace);
   };
 
   page.onInitialized = function() {
-    var setupReporters;
-
-    overloadPageEvaluate(page);
-    setupWriteFileFunction(page, resultsKey, fs.separator);
-    page.injectJs('lib/console.js');
-    page.injectJs('lib/reporter.js');
-    page.injectJs('lib/junit_reporter.js');
-    setupReporters = function() {
+    page.injectJs('guard-reporter.js');
+    return page.evaluate(function() {
       return window.onload = function() {
-        window.onload = null;
-        window.resultReceived = false;
-        window.reporter = new ConsoleReporter();
+        window.reporter = new GuardReporter();
         if (window.jasmine) {
-          jasmine.getEnv().addReporter(new JUnitXmlReporter("%save_path%", "%consolidate%"));
-          return jasmine.getEnv().addReporter(window.reporter);
+          return window.jasmine.getEnv().addReporter(window.reporter);
         }
       };
-    };
-    return page.evaluate(setupReporters, {
-      save_path: options.junit_save_path,
-      consolidate: options.junit_consolidate
-    });
-  };
-
-  getXmlResults = function(page, key) {
-    var getWindowObj;
-
-    getWindowObj = function() {
-      return window["%resultsObj%"] || {};
-    };
-    return page.evaluate(getWindowObj, {
-      resultsObj: key
-    });
-  };
-
-  replaceFunctionPlaceholders = function(fn, replacements) {
-    var match, p;
-
-    if (replacements && typeof replacements === 'object') {
-      fn = fn.toString();
-      for (p in replacements) {
-        if (replacements.hasOwnProperty(p)) {
-          match = new RegExp("%" + p + "%", "g");
-          while (true) {
-            fn = fn.replace(match, replacements[p]);
-            if (fn.indexOf(match) === -1) {
-              break;
-            }
-          }
-        }
-      }
-    }
-    return fn;
-  };
-
-  overloadPageEvaluate = function(page) {
-    page._evaluate = page.evaluate;
-    page.evaluate = function(fn, replacements) {
-      return page._evaluate(replaceFunctionPlaceholders(fn, replacements));
-    };
-    return page;
-  };
-
-  setupWriteFileFunction = function(page, key, path_separator) {
-    var saveData;
-
-    saveData = function() {
-      window["%resultsObj%"] = {};
-      window.fs_path_separator = "%fs_path_separator%";
-      return window.__phantom_writeFile = function(filename, text) {
-        return window["%resultsObj%"][filename] = text;
-      };
-    };
-    return page.evaluate(saveData, {
-      resultsObj: key,
-      fs_path_separator: path_separator
     });
   };
 
-  page.open(options.url, function(status) {
-    page.onLoadFinished = function() {};
+  page.onLoadFinished = function(status) {
     if (status !== 'success') {
-      console.log(JSON.stringify({
-        error: "Unable to access Jasmine specs at " + options.url
-      }));
-      return phantom.exit();
+      return reportError("Unable to access Jasmine specs at " + options.url + ", page returned status: " + status);
     } else {
-      return waitFor(jasmineReady, jasmineAvailable, options.timeout, jasmineMissing);
+      return waitFor(reporterReady, jasmineAvailable, options.timeout, reporterMissing);
     }
-  });
+  };
+
+  page.open(options.url);
 
-  jasmineReady = function() {
+  reporterReady = function() {
     return page.evaluate(function() {
-      return window.jasmine;
+      return window.jasmine && window.reporter;
     });
   };
 
   jasmineAvailable = function() {
-    return waitFor(specsReady, specsDone, options.timeout, specsTimedout);
+    return waitFor(specsDone, exitSuccessfully, options.timeout, specsTimedout);
   };
 
-  jasmineMissing = function() {
-    var error, text;
-
+  reporterMissing = function() {
+    var text;
     text = page.evaluate(function() {
       var _ref;
-
       return (_ref = document.getElementsByTagName('body')[0]) != null ? _ref.innerText : void 0;
     });
-    if (text) {
-      error = "The Jasmine reporter is not available!\n\n" + text;
-      return console.log(JSON.stringify({
-        error: error
-      }));
-    } else {
-      return console.log(JSON.stringify({
-        error: 'The Jasmine reporter is not available!'
-      }));
-    }
+    return reportError("The reporter is not available!\nPerhaps the url ( " + options.url + " ) is incorrect?\n\n" + text);
   };
 
-  specsReady = function() {
-    return page.evaluate(function() {
-      return window.resultReceived;
+  specsDone = function() {
+    var result;
+    return result = page.evaluate(function() {
+      return window.reporter.resultComplete;
     });
   };
 
-  specsTimedout = function() {
-    var error, text;
+  exitSuccessfully = function() {
+    var results;
+    results = page.evaluate(function() {
+      return window.reporter.results();
+    });
+    console.log(JSON.stringify(results));
+    return phantom.exit();
+  };
 
+  specsTimedout = function() {
+    var text;
     text = page.evaluate(function() {
       var _ref;
-
       return (_ref = document.getElementsByTagName('body')[0]) != null ? _ref.innerText : void 0;
     });
-    if (text) {
-      error = "Timeout waiting for the Jasmine test results!\n\n" + text;
-      return console.log(JSON.stringify({
-        error: error
-      }));
-    } else {
-      return console.log(JSON.stringify({
-        error: 'Timeout for the Jasmine test results!'
-      }));
-    }
-  };
-
-  specsDone = function() {
-    var filename, output, xml_results;
-
-    if (options.junit === true) {
-      xml_results = getXmlResults(page, resultsKey);
-      for (filename in xml_results) {
-        if (xml_results.hasOwnProperty(filename) && (output = xml_results[filename]) && typeof output === 'string') {
-          fs.write(filename, output, 'w');
-        }
-      }
-    }
-    return phantom.exit();
+    return reportError("Timeout waiting for the Jasmine test results!\n\n" + text);
   };
 
   waitFor = function(test, ready, timeout, timeoutFunction) {
     var condition, interval, start, wait;
-
     if (timeout == null) {
       timeout = 10000;
     }
-    start = Date.now();
     condition = false;
     interval = void 0;
+    start = Date.now(0);
     wait = function() {
-      if ((Date.now() - start < timeout) && !condition) {
+      if (!condition && (Date.now() - start < timeout)) {
         return condition = test();
       } else {
         clearInterval(interval);
         if (condition) {
           return ready();
         } else {
-          timeoutFunction();
-          return phantom.exit(1);
+          return timeoutFunction();
         }
       }
     };
     return interval = setInterval(wait, 250);
   };
 
+  reportError = function(msg, trace) {
+    var err;
+    if (trace == null) {
+      trace = [];
+    }
+    if (0 === trace.length) {
+      err = new Error();
+      trace = err.stack;
+    }
+    console.log(JSON.stringify({
+      error: msg,
+      trace: trace
+    }));
+    return phantom.exit(1);
+  };
+
 }).call(this);

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

@@ -0,0 +1,187 @@
+(function() {
+  var ConsoleCapture, GuardReporter, extendObject;
+
+  extendObject = function(a, b) {
+    var key, value;
+    for (key in b) {
+      value = b[key];
+      if (b.hasOwnProperty(key)) {
+        a[key] = value;
+      }
+    }
+    return a;
+  };
+
+  ConsoleCapture = (function() {
+    var level, _i, _len, _ref;
+
+    ConsoleCapture.DOT_REPORTER_MATCH = /\[\d+m[F.]..0m/;
+
+    ConsoleCapture.levels = ['log', 'info', 'warn', 'error', 'debug'];
+
+    ConsoleCapture.original = console;
+
+    ConsoleCapture.original_levels = {};
+
+    _ref = ConsoleCapture.levels;
+    for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+      level = _ref[_i];
+      ConsoleCapture.original_levels[level] = console[level];
+    }
+
+    function ConsoleCapture() {
+      var _j, _len1, _ref1;
+      this.original = {};
+      this.captured = [];
+      _ref1 = ConsoleCapture.levels;
+      for (_j = 0, _len1 = _ref1.length; _j < _len1; _j++) {
+        level = _ref1[_j];
+        this._reassign_level(level);
+      }
+    }
+
+    ConsoleCapture.prototype.revert = function() {
+      var _j, _len1, _ref1, _results;
+      _ref1 = ConsoleCapture.levels;
+      _results = [];
+      for (_j = 0, _len1 = _ref1.length; _j < _len1; _j++) {
+        level = _ref1[_j];
+        _results.push(ConsoleCapture.original[level] = ConsoleCapture.original_levels[level]);
+      }
+      return _results;
+    };
+
+    ConsoleCapture.prototype._reassign_level = function(level) {
+      var my;
+      my = this;
+      return console[level] = function() {
+        var args;
+        args = Array.prototype.slice.call(arguments, 0);
+        if (args[0] && args[0].toString && args[0].toString().match(ConsoleCapture.DOT_REPORTER_MATCH)) {
+          return;
+        }
+        my.captured.push([level].concat(args));
+        return ConsoleCapture.original_levels[level].apply(ConsoleCapture.original, arguments);
+      };
+    };
+
+    return ConsoleCapture;
+
+  })();
+
+  GuardReporter = (function() {
+    function GuardReporter() {}
+
+    GuardReporter.STACK_MATCHER = new RegExp("__spec__\/(.*):([0-9]+)", "g");
+
+    GuardReporter.prototype.jasmineStarted = function() {
+      this.console = new ConsoleCapture();
+      this.startedAt = Date.now();
+      this.currentSuite = {
+        suites: []
+      };
+      return this.stack = [this.currentSuite];
+    };
+
+    GuardReporter.prototype.suiteStarted = function(suite) {
+      suite = extendObject({
+        specs: [],
+        suites: []
+      }, suite);
+      this.currentSuite.suites.push(suite);
+      this.currentSuite = suite;
+      return this.stack.push(suite);
+    };
+
+    GuardReporter.prototype.suiteDone = function(Suite) {
+      this.stack.pop();
+      return this.currentSuite = this.stack[this.stack.length - 1];
+    };
+
+    GuardReporter.prototype.jasmineDone = function() {
+      return this.resultComplete = true;
+    };
+
+    GuardReporter.prototype.specDone = function(spec) {
+      var error, failure, match, _i, _len, _ref;
+      this.resultReceived = true;
+      spec = extendObject({
+        logs: this.console.captured,
+        errors: []
+      }, spec);
+      _ref = spec.failedExpectations;
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        failure = _ref[_i];
+        error = extendObject({
+          trace: []
+        }, failure);
+        while (match = GuardReporter.STACK_MATCHER.exec(failure.stack)) {
+          error.trace.push({
+            file: match[1],
+            line: parseInt(match[2])
+          });
+        }
+        delete error.stack;
+        spec.errors.push(error);
+      }
+      delete spec.failedExpectations;
+      this.currentSuite.specs.push(spec);
+      this.resetConsoleLog();
+      return spec;
+    };
+
+    GuardReporter.prototype.resetConsoleLog = function() {
+      this.console.revert();
+      return this.console = new ConsoleCapture;
+    };
+
+    GuardReporter.prototype.eachSuite = function(suite) {
+      var suites, _i, _len, _ref;
+      suites = [].concat(suite.suites);
+      _ref = suite.suites;
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        suite = _ref[_i];
+        suites = suites.concat(this.eachSuite(suite));
+      }
+      return suites;
+    };
+
+    GuardReporter.prototype.results = function() {
+      var spec, stats, suite, _i, _j, _len, _len1, _ref, _ref1;
+      stats = {
+        time: (Date.now() - this.startedAt) / 1000,
+        specs: 0,
+        failed: 0,
+        pending: 0,
+        disabled: 0
+      };
+      _ref = this.eachSuite(this.stack[0]);
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        suite = _ref[_i];
+        stats.specs += suite.specs.length;
+        _ref1 = suite.specs;
+        for (_j = 0, _len1 = _ref1.length; _j < _len1; _j++) {
+          spec = _ref1[_j];
+          if (void 0 !== stats[spec.status]) {
+            stats[spec.status] += 1;
+          }
+        }
+      }
+      return {
+        jasmine_version: typeof jasmine !== "undefined" && jasmine !== null ? jasmine.version : void 0,
+        stats: stats,
+        suites: this.stack[0].suites
+      };
+    };
+
+    return GuardReporter;
+
+  })();
+
+  if (typeof module !== 'undefined' && module.exports) {
+    module.exports = GuardReporter;
+  } else {
+    window.GuardReporter = GuardReporter;
+  }
+
+}).call(this);