konacha-chai-matchers 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d75de08177b5bc14d3165f7d1aaf558dacfc584d
-  data.tar.gz: a8c99d1eba99773d9195fd25ba01c26c75eaca3e
+  metadata.gz: f6b60b89f98ae533e719ffcab08c0b3e87b8799e
+  data.tar.gz: 191e69e079fa781a2e451fae095d89336f88d26b
 SHA512:
-  metadata.gz: a0d413734a1fffa4a0939fd277d2c3ae1bdc0eefb4e965cd9c781a6b5821cb4a3093654c74a8419b5fbf21197844b8b66d90e0380fec7d35abb1267c9b28be1c
-  data.tar.gz: 55b70498cbab2e31d33abe0f3599a9b299e43fb4e25de126fe7dfa2daf051bb4173f2738ea06f51c8f0531f05e89252bff18a1f43a8814e15ec38d65719c5c53
+  metadata.gz: 5ecfef8e457cdbe3ee1fca5c66d222284f91c25ef913261f3c3f9931d1db9121b766f4009b77e042676b779824fee78163d2aae93596498e0668079ac2629a99
+  data.tar.gz: 8de203d47ce991198b08732835a37176d46ee9ff713b98956186dfb4ee731d252fbb441ffe83710a442387c2d205e00d8b974fd5533f27ad5a6f826254fa78ad

data/.gitmodules

@@ -46,3 +46,18 @@
 [submodule "memo-is"]
 	path = memo-is
 	url = https://github.com/d11wtq/node-memo-is.git
+[submodule "chai-jq"]
+	path = chai-jq
+	url = https://github.com/FormidableLabs/chai-jq.git
+[submodule "chai-js-factories"]
+	path = chai-js-factories
+	url = https://github.com/solatis/chai-js-factories.git
+[submodule "chai-json-schema"]
+	path = chai-json-schema
+	url = https://github.com/Bartvds/chai-json-schema.git
+[submodule "chai-datetime"]
+	path = chai-datetime
+	url = https://github.com/gaslight/chai-datetime.git
+[submodule "chai-change"]
+	path = chai-change
+	url = https://github.com/timruffles/chai-change.git

data/.ruby-version

@@ -0,0 +1 @@
+2.1.1

data/VERSIONS

@@ -1,16 +1,21 @@
 chai-spies: 0.5.1
 sinon-chai: 2.5.0
-chai-as-promised: 4.1.0
-chai-jquery: 1.2.1
+chai-as-promised: 4.1.1
+chai-jquery: 1.2.3
 chai-timers: 0.2.0
 chai-stats: 0.3.0
 chai-null: 0.1.0
 chai-factories: 0.1.0
 chai-changes: 1.3.4
 chai-backbone: 0.9.2
-js-factories: 1.0.1
+js-factories: 1.1.1
 mocha-as-promised: 2.0.0
 chai-things: 0.2.0
 chai-fuzzy: 1.4.0
-sinon: 1.7.3
+sinon: 1.10.3
 memo-is: 0.0.2
+chai-jq: 0.0.7
+chai-js-factories: 0.1.3
+chai-json-schema: 1.1.0
+chai-datetime: 1.3.0
+chai-change: 1.0.0

data/VERSIONS.lock

@@ -1 +1,2 @@
-sinon: v1.7.3
+memo-is: origin/master
+chai-jquery: origin/master

data/lib/konacha-chai-matchers/collector.rb

@@ -30,11 +30,25 @@ module Konacha
           @libs ||= urls.each_with_index.map do |url, i|
             name = paths[i]
             `cd ./#{name} && git fetch && cd ..`
-            latest_tag = `cd ./#{name} && git describe --tags --abbrev=0 && cd ..`.split.first
-            library_tag = locked_versions[name] || latest_tag
+            `cd ./#{name} && git fetch --tags && cd ..`
+            tags = `cd ./#{name} && git tag && cd ..`.split
+
+            ordered_tags = tags.sort do |astr, bstr|
+              a = astr.scan(/\d+/).map(&:to_i)
+              b = bstr.scan(/\d+/).map(&:to_i)
+              a.each_with_index do |e, c|
+                next if e == b[c]
+                break e <=> b[c]
+              end
+            end
+            latest_tag = ordered_tags.last
 
+            library_tag = latest_tag
+            library_tag = locked_versions[name] if locked_versions.key? name
             latest_commit = `cd ./#{name} && git rev-parse #{library_tag || 'HEAD'} && cd ..`.split.first
 
+            $stdout.puts "*** #{name} tag: #{latest_tag.inspect}, using: #{library_tag.inspect} commit: #{latest_commit}"
+
             Library.new url: url, name: name, tag: library_tag, commit: latest_commit
           end
         end

data/lib/konacha-chai-matchers/version.rb

@@ -1,7 +1,7 @@
 module Konacha
   module Chai
     module Matchers
-      VERSION = "0.2.0"
+      VERSION = "0.3.0"
     end
   end
 end

data/vendor/assets/javascripts/chai-as-promised.js

@@ -330,12 +330,12 @@
             return toTestAgainst !== undefined ? assertion.to.be.rejectedWith(toTestAgainst) : assertion.to.be.rejected;
         };
 
-        assert.becomes = function (promise, value) {
-            return assert.eventually.deepEqual(promise, value);
+        assert.becomes = function (promise, value, message) {
+            return assert.eventually.deepEqual(promise, value, message);
         };
 
-        assert.doesNotBecome = function (promise, value) {
-            return assert.eventually.notDeepEqual(promise, value);
+        assert.doesNotBecome = function (promise, value, message) {
+            return assert.eventually.notDeepEqual(promise, value, message);
         };
 
         assert.eventually = {};

data/vendor/assets/javascripts/chai-change.js

@@ -0,0 +1,200 @@
+(function() {
+
+function plugin(chai,util) {
+
+  var Assertion = chai.Assertion;
+  var flag = util.flag;
+
+  chai.Assertion.addMethod('change',assertChange);
+  chai.Assertion.addMethod('changes',assertChange);
+  chai.assert.change = assertInterfaceChange;
+  chai.assert.noChange = assertInterfaceNoChange;
+
+  /**
+   * ### .change(getValue)
+   *
+   * Asserts that the value returned by `getValue`
+   * changes after the function has run:
+   *
+   *     var x = 0;
+   *     expect(function() { x += 1; }).to.change(function() { return x });
+   *
+   *     expect(function() {}).not.to.change(function() { return x });
+   *
+   * You can pass options to be specific about the changes expected. Use the `from` 
+   * key to enforce a starting value, a `to` key for and ending value, and a
+   * `by` key to enforce a numeric change.
+   *
+   *     expect(function() { x += 1 }).to.change(function() { return x },{by: 1});
+   *     expect(function() { x += 1 }).to.change(function() { return x },{from: x});
+   *     expect(function() { x += 1 }).to.change(function() { return x },{from: x, to: x + 1});
+   *     expect(function() { x += 1 }).to.change(function() { return x },{to: x + 1});
+   *
+   * @name change
+   * @param {Function} changer
+   * @param {Function} getValue
+   * @param {Object} options _optional_
+   * @api public
+   */
+  function assertChange(changeWatcher, changeSpec, msg) {
+    if(msg) flag(this, 'message', msg);
+    var body = flag(this, 'object');
+    var negated = flag(this,'negate');
+
+    var chai = this;
+    var FAIL = {};
+
+    changeSpec = changeSpec || {}
+
+    withFail(function() {
+      if(changeSpec) new Assertion(changeSpec).is.a('object');
+
+      new Assertion(body, msg).is.a('function');
+      new Assertion(changeWatcher, msg).is.a('function');
+
+      if(changeWatcher.length > 0 || body.length > 0) {
+        chai.assert(changeSpec.callback != null,"For asynchronous tests, need to pass a `done(err)` function as `callback:` option");
+      }
+
+      runStep(changeWatcher,function(before) {
+        withFail(preconditions,before);
+        runStep(body,function() {
+          runStep(changeWatcher,function(after) {
+            var result = withFail(postconditions,before,after);
+            if(result !== FAIL && changeSpec.callback) changeSpec.callback();
+          });
+        });
+      });
+    });
+
+    function preconditions(before) {
+      if('by' in changeSpec) {
+        if(typeof changeSpec.by !== 'number' || 
+            (changeSpec.from != null && typeof changeSpec.from !== 'number')) {
+          throw new Error('change "by" assertions only work with numbers specified in "by" and or "from" options');
+        }
+        changeSpec.to = before + changeSpec.by;
+      }
+      if('from' in changeSpec && changeSpec.from !== before) {
+        throw new Error("change 'from' value wasn't equal to " + util.inspect(before));
+      }
+    }
+
+    function postconditions(before,after) {
+      if('to' in changeSpec) {
+        chai.assert(
+            after === changeSpec.to
+          , 'expected ' + util.inspect(before) + ' to change to ' + util.inspect(changeSpec.to) + ', instead changed to ' + util.inspect(after)
+          , 'didn\'t expect ' + util.inspect(before) + ' to have changed to ' + util.inspect(changeSpec.to)
+        );
+      } else {
+        chai.assert(
+            after !== before
+          , 'expected value to have changed from '  + util.inspect(before)
+          , 'expected value to have remained unchanged from ' + util.inspect(before) + ', but changed to ' + util.inspect(after)
+        );
+      }
+    }
+
+    function runStep(fn,done) {
+      if(fn.length === 0) return done(withFail(fn));
+      fn(function(err,val) {
+        if(err) return fail(err);
+        done(val);
+      });
+    }
+
+    function fail(err) {
+      if(changeSpec.callback) return changeSpec.callback(err);
+      if(!(err instanceof Error)) err = new Error(err);
+      throw err;
+    }
+
+    function withFail(fn) {
+      var args = [].slice.call(arguments,1);
+      try {
+        return fn.apply(null,args);
+      } catch(e) {
+        fail(e);
+        return FAIL;
+      }
+    }
+
+    return this;
+
+  };
+  /**
+   * ### .change(getValue)
+   *
+   * Asserts that the value returned by `getValue`
+   * changes after the `affect` function has run:
+   *
+   *     var x = 0;
+   *     assert.change(function() { x += 1; },function() { return x });
+   *
+   * You can pass options to be specific about the changes expected. Use the `from` 
+   * key to enforce a starting value, a `to` key for and ending value, and a
+   * `by` key to enforce a numeric change.
+   *
+   *     assert.change(function() { x += 1 },function() { return x },{by: 1});
+   *     assert.change(function() { x += 1 },function() { return x },{from: x});
+   *     assert.change(function() { x += 1 },function() { return x },{from: x, to: x + 1});
+   *     assert.change(function() { x += 1 },function() { return x },{to: x + 1});
+   *
+   * @name change
+   * @param {Function} affect
+   * @param {Function} getValue
+   * @param {Object} options _optional_
+   * @param {String} message
+   * @api public
+   */
+  function assertInterfaceChange(fn, changeWatcher, opts, msg) {
+    if(typeof opts === 'string') {
+      msg = opts;
+      opts = null;
+    }
+    new Assertion(fn, msg).to.change(changeWatcher,opts);
+  };
+
+  /**
+   * ### .change(getValue)
+   *
+   * Asserts that the value returned by `getValue`
+   * doesn't change after the `affect` has run:
+   *
+   *     var x = 0;
+   *     assert.noChange(doesNothing,function() { return x });
+   *     function doesNothing() {}
+   *
+   * @name change
+   * @param {Function} affect
+   * @param {Function} getValue
+   * @param {Object} options _optional_
+   * @param {String} message
+   * @api public
+   */
+
+  function assertInterfaceNoChange(fn, changeWatcher, opts, msg) {
+    if(typeof opts === 'string') {
+      msg = opts;
+      opts = null;
+    }
+    new Assertion(fn, msg).not.to.change(changeWatcher,opts);
+  };
+
+}
+
+if(typeof module === "undefined") {
+  if(typeof define === "function" && define.amd) {
+    define([],function() {
+      return plugin;
+    });
+  } else {
+    chai.use(plugin);
+  }
+} else {
+  module.exports = plugin;
+}
+
+
+})();

data/vendor/assets/javascripts/chai-datetime.js

@@ -0,0 +1,170 @@
+(function(plugin){
+  if (
+    typeof require === "function" &&
+    typeof exports === "object" &&
+    typeof module === "object"
+  ) {
+    // NodeJS
+    module.exports = plugin;
+  } else if (
+    typeof define === "function" &&
+    define.amd
+  ) {
+    // AMD
+    define(function () {
+      return plugin;
+    });
+  } else {
+    // Other environment (usually <script> tag): plug in to global chai instance directly.
+    chai.use(plugin);
+  }
+}(function(chai, utils){
+  chai.datetime = chai.datetime || {};
+
+  chai.datetime.formatDate = function(date) {
+    return date.toDateString();
+  };
+
+  chai.datetime.formatTime = function(time) {
+    return time;
+  };
+
+  chai.datetime.equalTime = function(actual, expected) {
+    return actual.getTime() == expected.getTime();
+  };
+
+  chai.datetime.equalDate = function(actual, expected) {
+    return actual.toDateString() === expected.toDateString();
+  };
+
+  chai.datetime.beforeDate = function(actual, expected) {
+    return actual.getUTCFullYear() < expected.getUTCFullYear() || actual.getUTCMonth() < expected.getUTCMonth() || actual.getUTCDate() < expected.getUTCDate();
+  };
+
+  chai.datetime.afterDate = function(actual, expected) {
+    return actual.getUTCFullYear() > expected.getUTCFullYear() || actual.getUTCMonth() > expected.getUTCMonth() || actual.getUTCDate() > expected.getUTCDate();
+  };
+
+  chai.datetime.beforeTime = function(actual, expected) {
+    return actual.getTime() < expected.getTime();
+  };
+
+  chai.datetime.afterTime = function(actual, expected) {
+    return actual.getTime() > expected.getTime();
+  };
+
+  chai.Assertion.addChainableMethod('equalTime', function(expected) {
+    var actual = this._obj;
+
+    return this.assert(
+      chai.datetime.equalTime(expected, actual),
+      'expected ' + this._obj + ' to equal ' + expected,
+      'expected ' + this._obj + ' to not equal ' + expected,
+      expected.toString(),
+      actual.toString()
+    );
+  });
+
+  chai.Assertion.addChainableMethod('equalDate', function(expected) {
+    var expectedDate  = chai.datetime.formatDate(expected),
+        actualDate    = chai.datetime.formatDate(this._obj);
+
+    return this.assert(
+      chai.datetime.equalDate(this._obj, expected),
+      'expected ' + actualDate + ' to equal ' + expectedDate,
+      'expected ' + actualDate + ' to not equal ' + expectedDate
+    );
+  });
+
+  chai.Assertion.addChainableMethod('beforeDate', function(expected) {
+    var actual = this._obj;
+
+    this.assert(
+      chai.datetime.beforeDate(actual, expected),
+      'expected ' + chai.datetime.formatDate(actual) + ' to be before ' + chai.datetime.formatDate(expected),
+      'expected ' + chai.datetime.formatDate(actual) + ' not to be before ' + chai.datetime.formatDate(expected)
+    );
+  });
+
+  chai.Assertion.addChainableMethod('afterDate', function(expected) {
+    var actual = this._obj;
+
+    this.assert(
+      chai.datetime.afterDate(actual, expected),
+      'expected ' + chai.datetime.formatDate(actual) + ' to be after ' + chai.datetime.formatDate(expected),
+      'expected ' + chai.datetime.formatDate(actual) + ' not to be after ' + chai.datetime.formatDate(expected)
+    );
+  });
+
+  chai.Assertion.addChainableMethod('beforeTime', function(expected) {
+    var actual = this._obj;
+
+    this.assert(
+      chai.datetime.beforeTime(actual, expected),
+      'expected ' + chai.datetime.formatTime(actual) + ' to be before ' + chai.datetime.formatTime(expected),
+      'expected ' + chai.datetime.formatTime(actual) + ' not to be before ' + chai.datetime.formatTime(expected)
+    );
+  });
+
+  chai.Assertion.addChainableMethod('afterTime', function(expected) {
+    var actual = this._obj;
+
+    this.assert(
+      chai.datetime.afterTime(actual, expected),
+      'expected ' + chai.datetime.formatTime(actual) + ' to be after ' + chai.datetime.formatTime(expected),
+      'expected ' + chai.datetime.formatTime(actual) + ' not to be after ' + chai.datetime.formatTime(expected)
+    );
+  });
+
+  // Asserts
+  var assert = chai.assert;
+
+  assert.equalDate = function(val, exp, msg) {
+    new chai.Assertion(val, msg).to.be.equalDate(exp);
+  };
+
+  assert.notEqualDate = function(val, exp, msg) {
+    new chai.Assertion(val, msg).to.not.be.equalDate(exp);
+  };
+
+  assert.beforeDate = function(val, exp, msg) {
+    new chai.Assertion(val, msg).to.be.beforeDate(exp);
+  };
+
+  assert.notBeforeDate = function(val, exp, msg) {
+    new chai.Assertion(val, msg).to.not.be.beforeDate(exp);
+  };
+
+  assert.afterDate = function(val, exp, msg) {
+    new chai.Assertion(val, msg).to.be.afterDate(exp);
+  };
+
+  assert.notAfterDate = function(val, exp, msg) {
+    new chai.Assertion(val, msg).not.to.be.afterDate(exp);
+  };
+
+  assert.equalTime = function(val, exp, msg) {
+    new chai.Assertion(val, msg).to.be.equalTime(exp);
+  };
+
+  assert.notEqualTime = function(val, exp, msg) {
+    new chai.Assertion(val, msg).to.not.be.equalTime(exp);
+  };
+
+  assert.beforeTime = function(val, exp, msg) {
+    new chai.Assertion(val, msg).to.be.beforeTime(exp);
+  };
+
+  assert.notBeforeTime = function(val, exp, msg) {
+    new chai.Assertion(val, msg).not.to.be.beforeTime(exp);
+  };
+
+  assert.afterTime = function(val, exp, msg) {
+    new chai.Assertion(val, msg).to.be.afterTime(exp);
+  };
+
+  assert.notAfterTime = function(val, exp, msg) {
+    new chai.Assertion(val, msg).to.not.be.afterTime(exp);
+  };
+
+}));