konacha-chai-matchers 0.0.8 → 0.0.9

data/.gitmodules

@@ -1,39 +1,45 @@
 [submodule "chai-spies"]
-	path = chai-spies
-	url = git://github.com/chaijs/chai-spies.git
+  path = chai-spies
+  url = git://github.com/chaijs/chai-spies.git
 [submodule "sinon-chai"]
-	path = sinon-chai
-	url = git://github.com/domenic/sinon-chai.git
+  path = sinon-chai
+  url = git://github.com/domenic/sinon-chai.git
 [submodule "chai-as-promised"]
-	path = chai-as-promised
-	url = git://github.com/domenic/chai-as-promised.git
+  path = chai-as-promised
+  url = git://github.com/domenic/chai-as-promised.git
 [submodule "chai-jquery"]
-	path = chai-jquery
-	url = git://github.com/chaijs/chai-jquery.git
+  path = chai-jquery
+  url = git://github.com/chaijs/chai-jquery.git
 [submodule "chai-timers"]
-	path = chai-timers
-	url = git://github.com/chaijs/chai-timers.git
+  path = chai-timers
+  url = git://github.com/chaijs/chai-timers.git
 [submodule "chai-stats"]
-	path = chai-stats
-	url = git://github.com/chaijs/chai-stats.git
+  path = chai-stats
+  url = git://github.com/chaijs/chai-stats.git
 [submodule "chai-null"]
-	path = chai-null
-	url = git://github.com/chaijs/chai-null.git
+  path = chai-null
+  url = git://github.com/chaijs/chai-null.git
 [submodule "chai-factories"]
-	path = chai-factories
-	url = git://github.com/chaijs/chai-factories.git
+  path = chai-factories
+  url = git://github.com/chaijs/chai-factories.git
 [submodule "chai-changes"]
-	path = chai-changes
-	url = https://github.com/matthijsgroen/chai-changes.git
+  path = chai-changes
+  url = https://github.com/matthijsgroen/chai-changes.git
 [submodule "chai-backbone"]
-	path = chai-backbone
-	url = https://github.com/matthijsgroen/chai-backbone.git
-[submodule "Sinon.JS"]
-	path = Sinon.JS
-	url = git://github.com/cjohansen/Sinon.JS.git
+  path = chai-backbone
+  url = https://github.com/matthijsgroen/chai-backbone.git
 [submodule "js-factories"]
-	path = js-factories
-	url = git://github.com/matthijsgroen/js-factories.git
+  path = js-factories
+  url = git://github.com/matthijsgroen/js-factories.git
 [submodule "mocha-as-promised"]
-	path = mocha-as-promised
-	url = git://github.com/domenic/mocha-as-promised.git
+  path = mocha-as-promised
+  url = git://github.com/domenic/mocha-as-promised.git
+[submodule "chai-things"]
+  path = chai-things
+  url = git://github.com/RubenVerborgh/Chai-Things.git
+[submodule "chai-fuzzy"]
+  path = chai-fuzzy
+  url = git://github.com/elliotf/chai-fuzzy.git
+[submodule "sinon"]
+  path = sinon
+  url = git://github.com/cjohansen/Sinon.JS.git

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

@@ -1,7 +1,7 @@
 module Konacha
   module Chai
     module Matchers
-      VERSION = "0.0.8"
+      VERSION = "0.0.9"
     end
   end
 end

data/tasks/update.rb

@@ -1,9 +1,10 @@
 require 'pathname'
+require 'json'
 
 desc 'updates all submodules'
 task :update do
   modules = collect_modules
-  update_modules modules
+  #update_modules modules
   vendor_files modules
 end
 
@@ -12,7 +13,9 @@ def collect_modules
   File.open('.gitmodules') do |f|
     contents = f.read
     contents.each_line do |line|
-      modules << $1 if line =~ /\[submodule "(.*)"\]/
+      if matches = /\[submodule "(.*)"\]/.match(line)
+        modules << matches[1]
+      end
     end
   end
   modules
@@ -20,28 +23,52 @@ end
 
 def main_files folders
   folders.map do |f|
-    file_search = f.downcase
-    file_search << '.js' unless file_search =~ /\.js$/
+    r = determine_file_from_suggestion f
+    r ||= get_main_file_from_package "./#{f}/package.json", f
 
-    path_order = ["./#{f}/pkg/#{file_search}", "./#{f}/#{file_search}", "./#{f}/lib/#{file_search}"]
-
-    r = path_order.map do |p|
-      p if File.exist? p
-    end.flatten.compact.first
+    { lib: r, module: f }
   end.flatten.compact
 end
 
+def determine_file_from_suggestion filename, folder = filename
+  file_search = filename.downcase
+  file_search << '.js' unless file_search =~ /\.js$/
+
+  path_order = [
+    "./#{folder}/pkg/#{file_search}",
+    "./#{folder}/#{file_search}",
+    "./#{folder}/lib/#{file_search}"
+  ]
+  path_order.map do |p|
+    p if File.exist? p
+  end.flatten.compact.first
+end
+
+def get_main_file_from_package filename, folder
+  return unless File.exist? filename
+  json_string = File.open(filename).read
+  json = JSON.parse json_string
+  return unless json.has_key? "main"
+  main_file = json["main"]
+  determine_file_from_suggestion main_file, folder
+end
+
 def vendor_files modules
   files = main_files modules
-  puts "found #{files.length} of the #{modules.length} lib files" unless files.length == modules.length
+  missing = files.map { |f| f[:lib].nil? ? f[:module] : nil }.compact
+
+  puts "missing #{missing.length} lib files: #{missing.inspect}" unless missing.empty?
+
   path = "./vendor/assets/javascripts/"
   Pathname.new(path).mkpath()
-  FileUtils.cp files, path
+  files.each do |info|
+    FileUtils.cp(info[:lib], "#{path}#{info[:module]}.js") if info[:lib]
+  end
 end
 
 def update_modules modules
   modules.each do |mod|
-    `cd ./#{mod} && git pull`
+    `cd ./#{mod} && git pull origin master`
     `cd ./#{mod} && ./build` if File.exist? "./#{mod}/build"
   end
 end

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

@@ -0,0 +1,90 @@
+(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){
+  var _;
+
+  if (
+    typeof require === "function"
+    && typeof exports === "object"
+    && typeof module === "object"
+  ) {
+    // server-side
+    _ = require('underscore');
+  } else {
+    // browser-side
+    _ = window._;
+  }
+
+  // contain => _.where, check _.isEqual
+  // containOnce => contain, check size of returned array
+  // like => _.isEqual
+
+  chai.Assertion.addMethod('like', function(expected){
+    var obj = this._obj
+    this.assert(
+      _.isEqual(obj, expected)
+      , "expected #{this} to be like #{exp}"
+      , "expected #{this} not to be like #{exp}"
+      , expected
+      , obj
+      , true
+    )
+  });
+
+  chai.Assertion.addMethod('jsonOf', function(expected){
+    var obj            = this._obj;
+    var expectedAsJSON = JSON.parse(JSON.stringify(expected));
+
+    this.assert(
+      _.isEqual(obj, expectedAsJSON)
+      , "expected #{this} to be like JSON #{exp}"
+      , "expected #{this} not to be like JSON #{exp}"
+      , expectedAsJSON
+      , obj
+      , true
+    )
+  });
+
+  chai.Assertion.addMethod('containOneLike', function(expected){
+    var obj = this._obj
+
+    var _obj = _(obj);
+
+    if (!_obj.isObject() && !_obj.isArray()) {
+      this.assert(
+        false
+        , "expected #{this} to be an array, object, or string"
+        , "expected #{this} to be an array, object, or string"
+      )
+    }
+
+    var found = _obj.some(function(needle){
+      return _.isEqual(needle,expected);
+    });
+
+    this.assert(
+      found
+      , "expected #{this} to contain one thing like #{exp}"
+      , "expected #{this} not to contain one thing like #{exp}"
+      , expected
+    )
+  });
+}));

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

@@ -0,0 +1,143 @@
+(function (chaiModule) {
+  "use strict";
+  // NodeJS
+  if (typeof require === "function" && typeof exports === "object" && typeof module === "object")
+    module.exports = chaiModule;
+  // AMD
+  else if (typeof define === "function" && define.amd)
+    define(function () { return chaiModule; });
+  // Other
+  else
+    chai.use(chaiModule);
+}(function chaiAsPromised(chai, utils) {
+  "use strict";
+
+  var Assertion = chai.Assertion,
+      assertionPrototype = Assertion.prototype,
+      expect = chai.expect;
+
+  // Handles the `something` chain property
+  function chainSomething() {
+    // `include` or `contains` should have been called before
+    if (!utils.flag(this, "contains"))
+      throw new Error("cannot use something without include or contains");
+    // `something` should not have been used already
+    if (utils.flag(this, "something"))
+      throw new Error("cannot use something twice in an assertion");
+    // flag that this is a `something` chain
+    utils.flag(this, "something", {
+      // remember if `something` was negated
+      negate: utils.flag(this, "negate")
+    });
+    // reset the negation flag for the coming assertion
+    utils.flag(this, "negate", false);
+  }
+
+  // Performs the `something()` assertion
+  function assertSomething() {
+    // Undo the flags set by the `something` chain property
+    var somethingFlags = utils.flag(this, "something");
+    utils.flag(this, "something", false);
+    utils.flag(this, "negate", somethingFlags.negate);
+
+    // The assertion's object for `something` should be array-like
+    var object = utils.flag(this, "object");
+    expect(object).to.have.property("length");
+    expect(object.length).to.be.a("number", "something object length");
+
+    // The object should contain something
+    this.assert(object.length > 0,
+      "expected #{this} to contain something",
+      "expected #{this} not to contain something"
+    );
+  }
+
+  // Find all assertion methods
+  var methodNames = Object.getOwnPropertyNames(assertionPrototype)
+    .filter(function (propertyName) {
+      var property = Object.getOwnPropertyDescriptor(assertionPrototype, propertyName);
+      return typeof property.value  === "function";
+    });
+
+  // Override all methods to react on a possible `something` in the chain
+  methodNames.forEach(function (methodName) {
+    Assertion.overwriteMethod(methodName, function (_super) {
+      return function () {
+        // Return if no `something` has been used in the chain
+        var somethingFlags = utils.flag(this, "something");
+        if (!somethingFlags)
+          return _super.apply(this, arguments);
+        // Clear the `something` flag; it should not be handled again
+        utils.flag(this, "something", false);
+
+        // The assertion's object for `something` should be array-like
+        var arrayObject = utils.flag(this, "object");
+        expect(arrayObject).to.have.property("length");
+        var length = arrayObject.length;
+        expect(length).to.be.a("number", "something object length");
+
+        // In the negative case, an empty array means success
+        var negate = somethingFlags.negate;
+        if (negate && !length)
+          return;
+        // In the positive case, the array should not be empty
+        new Assertion(arrayObject).assert(length,
+          "expected #{this} to contain something");
+
+        // Try the assertion on every array element
+        var assertionError;
+        for (var i = 0; i < length; i++) {
+          // Test whether the element satisfies the assertion
+          var item = arrayObject[i],
+              itemAssertion = copyAssertion(this, item, somethingAssert);
+          assertionError = null;
+          try { _super.apply(itemAssertion, arguments); }
+          catch (error) { assertionError = error; }
+          // If the element satisfies the assertion
+          if (!assertionError) {
+            // In case the base assertion is negated, a satisfying element
+            // means the base assertion ("no element must satisfy x") fails
+            if (negate) {
+              // Assert the negated item assertion, which should fail and throw an error
+              var negItemAssertion = copyAssertion(this, item, somethingAssert, true);
+              _super.apply(negItemAssertion, arguments);
+              // Throw here if, for some reason, the negated item assertion didn't throw
+              new Assertion(arrayObject).assert(false,
+                  "expected no element of #{this} to satisfy the assertion");
+            }
+            // In the positive case, a satisfying element means the assertion holds
+            return;
+          }
+        }
+        // Changes the assertion message to an array viewpoint
+        function somethingAssert(test, positive, negative, expected, actual) {
+          var replacement = (negate ? "no" : "an") + " element of #{this}";
+          utils.flag(this, "object", arrayObject);
+          assertionPrototype.assert.call(this, test,
+            (negate ? negative : positive).replace("#{this}", replacement),
+            (negate ? positive : negative).replace("#{this}", replacement),
+            expected, actual);
+        }
+        // If we reach this point, no element that satisfies the assertion has been found
+        if (!negate)
+          throw assertionError;
+      };
+    });
+  });
+
+  // Copies an assertion to another item, using the specified assert function
+  function copyAssertion(baseAssertion, item, assert, negate) {
+    var assertion = new Assertion(item);
+    utils.transferFlags(baseAssertion, assertion, false);
+    assertion.assert = assert;
+    if (negate)
+      utils.flag(assertion, "negate", !utils.flag(assertion, "negate"));
+    return assertion;
+  }
+
+  // Define the `something` chainable assertion method and its variants
+  ["something", "thing", "item", "one", "some", "any"].forEach(function (methodName) {
+    if (!(methodName in assertionPrototype))
+      Assertion.addChainableMethod(methodName, assertSomething, chainSomething);
+  });
+}));