konacha 1.2.1 → 1.2.2

data/History.md

@@ -1,5 +1,11 @@
 # master
 
+# 1.2.2
+
+* Update chai (1.0.3)
+* Improve compatibility with WebKit driver
+* Improve error reporting
+
 # 1.2.1
 
 * Update chai (1.0.1)

data/konacha.gemspec

@@ -17,7 +17,7 @@ the asset pipeline and engines.}
   gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   gem.name          = "konacha"
   gem.require_paths = ["lib"]
-  gem.version       = "1.2.1"
+  gem.version       = "1.2.2"
 
   gem.add_dependency "rails", "~> 3.1"
   gem.add_dependency "capybara"

data/lib/konacha/engine.rb

@@ -4,6 +4,8 @@ module Konacha
 
     def self.application(app)
       Rack::Builder.app do
+        use Rack::ShowExceptions
+
         map app.config.assets.prefix do
           run app.assets
         end

data/lib/konacha/runner.rb

@@ -74,14 +74,18 @@ module Konacha
       begin
         sleep 0.1
         done, dots = session.evaluate_script('[Konacha.done, Konacha.dots]')
-        io.write dots[dots_printed..-1]
-        io.flush
-        dots_printed = dots.length
+        if dots
+          io.write dots[dots_printed..-1]
+          io.flush
+          dots_printed = dots.length
+        end
       end until done
 
       @examples = JSON.parse(session.evaluate_script('Konacha.getResults()')).map do |row|
         Example.new(row)
       end
+    rescue => e
+      raise Konacha::Error, "Error communicating with browser process: #{e.inspect}"
     end
   end
 
@@ -104,4 +108,7 @@ module Konacha
       end
     end
   end
+
+  class Error < StandardError
+  end
 end

data/vendor/assets/javascripts/chai.js

@@ -111,6 +111,10 @@ Assertion.addMethod = function (name, fn) {
   util.addMethod(this.prototype, name, fn);
 };
 
+Assertion.addChainableMethod = function (name, fn, chainingBehavior) {
+  util.addChainableMethod(this.prototype, name, fn, chainingBehavior);
+};
+
 Assertion.overwriteProperty = function (name, fn) {
   util.overwriteProperty(this.prototype, name, fn);
 };
@@ -265,37 +269,23 @@ Object.defineProperty(Assertion.prototype, 'deep',
  * @api public
  */
 
-var an = function () {
-  var assert = function(type) {
-    var obj = flag(this, 'object')
-      , klassStart = type.charAt(0).toUpperCase()
-      , klass = klassStart + type.slice(1)
-      , article = ~[ 'A', 'E', 'I', 'O', 'U' ].indexOf(klassStart) ? 'an ' : 'a ';
-
-    this.assert(
-        '[object ' + klass + ']' === toString.call(obj)
-      , 'expected #{this} to be ' + article + type
-      , 'expected #{this} not to be ' + article + type
-      , '[object ' + klass + ']'
-      , toString.call(obj)
-    );
-
-    return this;
-  };
-
-  assert.__proto__ = this;
-  return assert;
-};
+function an(type) {
+  var obj = flag(this, 'object')
+    , klassStart = type.charAt(0).toUpperCase()
+    , klass = klassStart + type.slice(1)
+    , article = ~[ 'A', 'E', 'I', 'O', 'U' ].indexOf(klassStart) ? 'an ' : 'a ';
 
-Object.defineProperty(Assertion.prototype, 'an',
-  { get: an
-  , configurable: true
-});
+  this.assert(
+      '[object ' + klass + ']' === toString.call(obj)
+    , 'expected #{this} to be ' + article + type
+    , 'expected #{this} not to be ' + article + type
+    , '[object ' + klass + ']'
+    , toString.call(obj)
+  );
+}
 
-Object.defineProperty(Assertion.prototype, 'a',
-  { get: an
-  , configurable: true
-});
+Assertion.addChainableMethod('an', an);
+Assertion.addChainableMethod('a', an);
 
 /**
  * ### .include(value)
@@ -315,32 +305,20 @@ Object.defineProperty(Assertion.prototype, 'a',
  * @api public
  */
 
-var include = function () {
+function includeChainingBehavior() {
   flag(this, 'contains', true);
+}
 
-  var assert = function(val) {
-    var obj = flag(this, 'object')
-    this.assert(
-        ~obj.indexOf(val)
-      , 'expected #{this} to include ' + util.inspect(val)
-      , 'expected #{this} to not include ' + util.inspect(val));
-
-    return this;
-  };
-
-  assert.__proto__ = this;
-  return assert;
-};
-
-Object.defineProperty(Assertion.prototype, 'contain',
-  { get: include
-  , configurable: true
-});
+function include(val) {
+  var obj = flag(this, 'object')
+  this.assert(
+      ~obj.indexOf(val)
+    , 'expected #{this} to include ' + util.inspect(val)
+    , 'expected #{this} to not include ' + util.inspect(val));
+}
 
-Object.defineProperty(Assertion.prototype, 'include',
-  { get: include
-  , configurable: true
-});
+Assertion.addChainableMethod('include', include, includeChainingBehavior);
+Assertion.addChainableMethod('contain', include, includeChainingBehavior);
 
 /**
  * ### .ok
@@ -589,7 +567,7 @@ Object.defineProperty(Assertion.prototype, 'arguments',
 Assertion.prototype.equal = function (val) {
   var obj = flag(this, 'object');
   if (flag(this, 'deep')) {
-    new Assertion(obj).to.eql(val);
+    return this.eql(val);
   } else {
     this.assert(
         val === obj
@@ -617,8 +595,8 @@ Assertion.prototype.equal = function (val) {
 Assertion.prototype.eql = function (obj) {
   this.assert(
       util.eql(obj, flag(this, 'object'))
-    , 'expected #{this} to equal #{exp}'
-    , 'expected #{this} to not equal #{exp}'
+    , 'expected #{this} to deeply equal #{exp}'
+    , 'expected #{this} to not deeply equal #{exp}'
     , obj );
 
   return this;
@@ -1205,7 +1183,7 @@ var used = []
  * Chai version
  */
 
-exports.version = '1.0.1';
+exports.version = '1.0.3';
 
 /*!
  * Primary `Assertion` prototype
@@ -2316,6 +2294,86 @@ module.exports = function (chai, util) {
 
 }); // module: interface/should.js
 
+require.register("utils/addChainableMethod.js", function(module, exports, require){
+/*!
+ * Chai - addChainingMethod utility
+ * Copyright(c) 2012 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+/*!
+ * Module dependencies
+ */
+
+var transferFlags = require('./transferFlags');
+
+/**
+ * ### addChainableMethod (ctx, name, method, chainingBehavior)
+ *
+ * Adds a method to an object, such that the method can also be chained.
+ *
+ *     utils.addChainableMethod(chai.Assertion.prototype, 'foo', function (str) {
+ *       var obj = utils.flag(this, 'object');
+ *       new chai.Assertion(obj).to.be.equal(str);
+ *     });
+ *
+ * Can also be accessed directly from `chai.Assertion`.
+ *
+ *     chai.Assertion.addChainableMethod('foo', fn, chainingBehavior);
+ *
+ * The result can then be used as both a method assertion, executing both `method` and
+ * `chainingBehavior`, or as a language chain, which only executes `chainingBehavior`.
+ *
+ *     expect(fooStr).to.be.foo('bar');
+ *     expect(fooStr).to.be.foo.equal('foo');
+ *
+ * @param {Object} ctx object to which the method is added
+ * @param {String} name of method to add
+ * @param {Function} method function to be used for `name`, when called
+ * @param {Function} chainingBehavior function to be called every time the property is accessed
+ * @name addChainableMethod
+ * @api public
+ */
+
+module.exports = function (ctx, name, method, chainingBehavior) {
+  if (typeof chainingBehavior !== 'function') {
+    chainingBehavior = function () { };
+  }
+
+  Object.defineProperty(ctx, name,
+    { get: function () {
+        chainingBehavior.call(this);
+
+        var assert = function () {
+          var result = method.apply(this, arguments);
+          return result === undefined ? this : result;
+        };
+
+        // Re-enumerate every time to better accomodate plugins.
+        var asserterNames = Object.getOwnPropertyNames(ctx);
+        asserterNames.forEach(function (asserterName) {
+          var pd = Object.getOwnPropertyDescriptor(ctx, asserterName);
+
+          // Avoid trying to overwrite things that we can't, like `length`
+          // and `arguments`.
+          var functionProtoPD = Object.getOwnPropertyDescriptor(Function.prototype, asserterName);
+          if (functionProtoPD && !functionProtoPD.configurable) {
+            return;
+          }
+
+          Object.defineProperty(assert, asserterName, pd);
+        });
+
+        transferFlags(this, assert);
+
+        return assert;
+      }
+    , configurable: true
+  });
+};
+
+}); // module: utils/addChainableMethod.js
+
 require.register("utils/addMethod.js", function(module, exports, require){
 /*!
  * Chai - addMethod utility
@@ -2787,6 +2845,12 @@ exports.inspect = require('./inspect');
 
 exports.flag = require('./flag');
 
+/*!
+ * Flag transferring utility
+ */
+
+exports.transferFlags = require('./transferFlags');
+
 /*!
  * Deep equal utility
  */
@@ -2829,6 +2893,13 @@ exports.overwriteProperty = require('./overwriteProperty');
 
 exports.overwriteMethod = require('./overwriteMethod');
 
+/*!
+ * Add a chainable method
+ */
+
+exports.addChainableMethod = require('./addChainableMethod');
+
+
 }); // module: utils/index.js
 
 require.register("utils/inspect.js", function(module, exports, require){
@@ -3255,6 +3326,54 @@ module.exports = function (obj, args) {
 
 }); // module: utils/test.js
 
+require.register("utils/transferFlags.js", function(module, exports, require){
+/*!
+ * Chai - transferFlags utility
+ * Copyright(c) 2012 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+/**
+ * ### transferFlags(assertion, object, includeAll = true)
+ *
+ * Transfer all the flags for `assertion` to `object`. If
+ * `includeAll` is set to `false`, then the base Chai
+ * assertion flags (namely `object`, `ssfi`, and `message`)
+ * will not be transferred.
+ *
+ *
+ *     var newAssertion = new Assertion();
+ *     utils.transferFlags(assertion, newAssertion);
+ *
+ *     var anotherAsseriton = new Assertion(myObj);
+ *     utils.transferFlags(assertion, anotherAssertion, false);
+ *
+ * @param {Assertion} assertion the assertion to transfer the flags from
+ * @param {Object} object the object to transfer the flags too; usually a new assertion
+ * @param {Boolean} includeAll
+ * @name getAllFlags
+ * @api private
+ */
+
+module.exports = function (assertion, object, includeAll) {
+  var flags = assertion.__flags || (assertion.__flags = Object.create(null));
+
+  if (!object.__flags) {
+    object.__flags = Object.create(null);
+  }
+
+  includeAll = arguments.length === 3 ? includeAll : true;
+
+  for (var flag in flags) {
+    if (includeAll ||
+        (flag !== 'object' && flag !== 'ssfi' && flag != 'message')) {
+      object.__flags[flag] = flags[flag];
+    }
+  }
+};
+
+}); // module: utils/transferFlags.js
+
 
   return require('chai');
 });

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: konacha
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.2.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-22 00:00:00.000000000 Z
+date: 2012-05-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -224,21 +224,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 4477410044413595969
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 4477410044413595969
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Unit-test your Rails JavaScript with the mocha test framework and chai assertion