dune-dashboard 1.0.0

data/vendor/assets/components/numeral/tests/numeral/manipulate.js

@@ -0,0 +1,104 @@
+var numeral = require('../../numeral');
+
+exports.manipulate = {
+
+    add: function (test) {
+        test.expect(4);
+
+        var tests = [
+                [1000,10,1010],
+                [0.5,3,3.5],
+                [-100,200,100],
+                [0.1,0.2,0.3]
+            ],
+            num;
+
+        for (var i = 0; i < tests.length; i++) {
+            num = numeral(tests[i][0]);
+            num.add(tests[i][1]);
+            test.strictEqual(num.value(), tests[i][2], tests[i][0] + ' + ' + tests[i][1]);
+        }
+
+        test.done();
+    },
+
+    subtract: function (test) {
+        test.expect(4);
+
+        var tests = [
+                [1000,10,990],
+                [0.5,3,-2.5],
+                [-100,200,-300],
+                [0.3,0.1,0.2]
+            ],
+            num;
+
+        for (var i = 0; i < tests.length; i++) {
+            num = numeral(tests[i][0]);
+            num.subtract(tests[i][1]);
+            test.strictEqual(num.value(), tests[i][2], tests[i][0] + ' - ' + tests[i][1]);
+        }
+
+        test.done();
+    },
+
+    multiply: function (test) {
+        test.expect(4);
+
+        var tests = [
+                [1000,10,10000],
+                [0.5,3,1.5],
+                [-100,200,-20000],
+                [0.1,0.2,0.02]
+            ],
+            num;
+
+        for (var i = 0; i < tests.length; i++) {
+            num = numeral(tests[i][0]);
+            num.multiply(tests[i][1]);
+            test.strictEqual(num.value(), tests[i][2], tests[i][0] + ' * ' + tests[i][1]);
+        }
+
+        test.done();
+    },
+
+    divide: function (test) {
+        test.expect(4);
+
+        var tests = [
+                [1000,10,100],
+                [0.5,3,0.16666666666666666],
+                [-100,200,-0.5],
+                [5.3,0.1,53]
+            ],
+            num;
+
+        for (var i = 0; i < tests.length; i++) {
+            num = numeral(tests[i][0]);
+            num.divide(tests[i][1]);
+            test.strictEqual(num.value(), tests[i][2], tests[i][0] + ' / ' + tests[i][1]);
+        }
+
+        test.done();
+    },
+
+    difference: function (test) {
+        test.expect(4);
+
+        var tests = [
+                [1000,10,990],
+                [0.5,3,2.5],
+                [-100,200,300],
+                [0.3,0.2,0.1]
+            ],
+            num;
+
+        for (var i = 0; i < tests.length; i++) {
+            num = numeral(tests[i][0]);
+            test.strictEqual(num.difference(tests[i][1]), tests[i][2], 'Difference between ' + tests[i][0] + ' and ' + tests[i][1]);
+        }
+
+        test.done();
+    }
+
+};

data/vendor/assets/components/numeral/tests/numeral/misc.js

@@ -0,0 +1,123 @@
+var numeral = require('../../numeral');
+
+exports.misc = {
+
+    value: function (test) {
+        test.expect(5);
+
+        var tests = [
+                [1000, 1000],
+                [0.5, 0.5],
+                [, 0],
+                ['1,000', 1000],
+                ['not a number', 0]
+            ],
+            num;
+
+        for (var i = 0; i < tests.length; i++) {
+            num = numeral(tests[i][0]);
+            test.strictEqual(num.value(), tests[i][1], tests[i][1]);
+        }
+
+        test.done();
+    },
+
+    set: function (test) {
+        test.expect(2);
+
+        var tests = [
+                [1000,1000],
+                [-0.25,-0.25]
+            ],
+            num;
+
+        for (var i = 0; i < tests.length; i++) {
+            num = numeral().set(tests[i][0]);
+            test.strictEqual(num.value(), tests[i][1], tests[i][0]);
+        }
+
+        test.done();
+    },
+
+    customZero: function (test) {
+        test.expect(3);
+
+        var tests = [
+                [0,null,'0'],
+                [0,'N/A','N/A'],
+                [0,'','']
+            ];
+
+        for (var i = 0; i < tests.length; i++) {
+            numeral.zeroFormat(tests[i][1]);
+            test.strictEqual(numeral(tests[i][0]).format('0'), tests[i][2], tests[i][1]);
+        }
+
+        test.done();
+    },
+
+    clone: function (test) {
+        test.expect(4);
+
+        var a = numeral(1000),
+            b = numeral(a),
+            c = a.clone(),
+            aVal = a.value(),
+            aSet = a.set(2000).value(),
+            bVal = b.value(),
+            cVal = c.add(10).value();
+
+        test.strictEqual(aVal, 1000, 'Parent starting value');
+        test.strictEqual(aSet, 2000, 'Parent set to 2000');
+        test.strictEqual(bVal, 1000, 'Implicit clone unmanipulated');
+        test.strictEqual(cVal, 1010, 'Explicit clone + 10');
+
+        test.done();
+    },
+
+    isNumeral: function (test) {
+        test.expect(2);
+
+        var tests = [
+                [numeral(),true],
+                [1,false]
+            ];
+
+        for (var i = 0; i < tests.length; i++) {
+            test.strictEqual(numeral.isNumeral(tests[i][0]), tests[i][1], tests[i][0]);
+        }
+
+        test.done();
+    },
+    
+    languageData: function(test) {
+        test.expect(10);
+        
+        var cOld = '$',
+            cNew = '!',
+            formatTestVal = function() { return numeral('100').format('$0,0') },
+            oldCurrencyVal = cOld + '100',
+            newCurrencyVal = cNew + '100';
+        
+        test.strictEqual(numeral.languageData().currency.symbol, cOld, 'Current language currency is ' + cOld);
+        test.strictEqual(numeral.languageData('en').currency.symbol, cOld, 'English language currency is ' + cOld);
+        
+        numeral.languageData().currency.symbol = cNew;
+        test.strictEqual(numeral.languageData().currency.symbol, cNew, 'Current language currency is changed to ' + cNew);
+        test.strictEqual(formatTestVal(), newCurrencyVal, 'Format uses new currency');
+        
+        numeral.languageData().currency.symbol = cOld;
+        test.strictEqual(numeral.languageData().currency.symbol, '$', 'Current language currency is reset to ' + cOld);
+        test.strictEqual(formatTestVal(), oldCurrencyVal, 'Format uses old currency');
+        
+        numeral.languageData('en').currency.symbol = cNew;
+        test.strictEqual(numeral.languageData().currency.symbol, cNew, 'English language currency is changed to ' + cNew);
+        test.strictEqual(formatTestVal(), newCurrencyVal, 'Format uses new currency');
+        
+        numeral.languageData('en').currency.symbol = cOld;
+        test.strictEqual(numeral.languageData().currency.symbol, cOld, 'English language currency is reset to ' + cOld);
+        test.strictEqual(formatTestVal(), oldCurrencyVal, 'Format uses old currency');
+        
+        test.done();
+    }
+};

data/vendor/assets/components/numeral/tests/numeral/unformat.js

@@ -0,0 +1,96 @@
+var numeral = require('../../numeral');
+
+exports.unformat = {
+    setUp: function (callback) {
+        numeral.zeroFormat('N/A');
+        callback();
+    },
+
+    numbers: function (test) {
+        test.expect(15);
+
+        var tests = [
+                ['10,000.123', 10000.123],
+                ['(0.12345)', -0.12345],
+                ['((--0.12345))', 0.12345],
+                ['23rd', 23],
+                ['31st', 31],
+                ['1.23t', 1230000000000],
+                ['N/A', 0],
+                [, 0],
+                ['', 0],
+
+                // Pass Through for Numbers
+                [0, 0],
+                [1, 1],
+                [1.1, 1.1],
+                [-0, 0],
+                [-1, -1],
+                [-1.1, -1.1]
+            ];
+
+        for (var i = 0; i < tests.length; i++) {
+            test.strictEqual(numeral().unformat(tests[i][0]), tests[i][1], tests[i][0]);
+        }
+
+        test.done();
+    },
+
+    currency: function (test) {
+        test.expect(2);
+
+        var tests = [
+                ['($1.23m)', -1230000],
+                ['$ 10,000.00', 10000]
+            ];
+
+        for (var i = 0; i < tests.length; i++) {
+            test.strictEqual(numeral().unformat(tests[i][0]), tests[i][1], tests[i][0]);
+        }
+
+        test.done();
+    },
+
+    bytes: function (test) {
+        test.expect(2);
+
+        var tests = [
+                ['100B', 100],
+                ['3.154 TB', 3467859674006]
+            ];
+
+        for (var i = 0; i < tests.length; i++) {
+            test.strictEqual(numeral().unformat(tests[i][0]), tests[i][1], tests[i][0]);
+        }
+
+        test.done();
+    },
+
+    percentages: function (test) {
+        test.expect(1);
+
+        var tests = [
+                ['-76%', -0.76]
+            ];
+
+        for (var i = 0; i < tests.length; i++) {
+            test.strictEqual(numeral().unformat(tests[i][0]), tests[i][1], tests[i][0]);
+        }
+
+        test.done();
+    },
+
+    time: function (test) {
+        test.expect(1);
+
+        var tests = [
+                ['2:23:57', 8637]
+            ];
+
+        for (var i = 0; i < tests.length; i++) {
+            test.strictEqual(numeral().unformat(tests[i][0]), tests[i][1], tests[i][0]);
+        }
+
+        test.done();
+    }
+};

data/vendor/assets/components/qunit-bdd/.bower.json

@@ -0,0 +1,31 @@
+{
+  "name": "qunit-bdd",
+  "version": "0.6.1",
+  "authors": [
+    "Brian Donovan <donovan@squareup.com>"
+  ],
+  "description": "BDD-style testing for QUnit.",
+  "main": "lib/qunit-bdd.js",
+  "keywords": [
+    "qunit",
+    "bdd"
+  ],
+  "license": "Apache 2",
+  "homepage": "https://github.com/square/qunit-bdd",
+  "ignore": [
+    "**/.*",
+    "node_modules",
+    "bower_components",
+    "test",
+    "tests"
+  ],
+  "_release": "0.6.1",
+  "_resolution": {
+    "type": "version",
+    "tag": "v0.6.1",
+    "commit": "ca514b74473b3224fc7c52a3f7552f3a8bd11aa2"
+  },
+  "_source": "git://github.com/square/qunit-bdd.git",
+  "_target": "~0.6.1",
+  "_originalSource": "qunit-bdd"
+}

data/vendor/assets/components/qunit-bdd/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2014 Square Inc.
+ 
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+ 
+    http://www.apache.org/licenses/LICENSE-2.0
+ 
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/vendor/assets/components/qunit-bdd/README.md

@@ -0,0 +1,282 @@
+## qunit-bdd
+
+BDD-style testing for QUnit.
+
+```js
+describe('keys', function() {
+  describe('.camelize', function() {
+    it('camelizes top-level keys', function() {
+      expect(camelize({ ohai_there: 'friend' })).to.eql({ ohaiThere: 'friend' });
+    });
+
+    it('camelizes nested keys', function() {
+      expect(camelize({ foo_bar: { bar_baz: 'baz' } }))
+        .to.eql({ fooBar: { barBaz: 'baz' } });
+    });
+
+    it('camelizes array objects', function() {
+      expect(camelize([{ foo_bar: { bar_baz: 'baz' } }, { ohai_there: 'friend' }]))
+        .to.eql([{ fooBar: { barBaz: 'baz' } }, { ohaiThere: 'friend' }]);
+    });
+  });
+});
+```
+
+### Installation
+
+```
+# Install via NPM.
+$ npm install [--save-dev] qunit-bdd
+
+# Install via Bower.
+$ bower install [-D] qunit-bdd
+
+# Install from Git.
+$ git clone https://github.com/square/qunit-bdd.git
+$ cp qunit-bdd/lib/qunit-bdd.js my-project/vendor/qunit-bdd.js
+```
+
+### Usage
+
+qunit-bdd has `describe` and `context`, just like Mocha and Jasmine. It also
+provides an assertion syntax similar to expect.js.
+
+```js
+describe('Math', function() {
+  describe('#pow', function() {
+    it('raises the first argument to the power of the second argument', function() {
+      expect(Math.pow(0, 6)).to.equal(0, '0**x == 0');
+      expect(Math.pow(1, 99)).to.equal(1, '1**x == 1');
+      expect(Math.pow(99, 0)).to.equal(1, 'x**0 == 1');
+      expect(Math.pow(2, 3)).to.equal(8, 'positive exponent works');
+      expect(Math.pow(4, -1)).to.equal(2, 'negative exponent works');
+    });
+  });
+});
+```
+
+qunit-bdd also has `before` and `after` to run blocks of code before an after
+each test run within a context:
+
+```js
+// This example uses sinon.js, not included with qunit-bdd.
+describe('Profile Page', function() {
+  before(function() {
+    this.alertStub = sinon.stub(window, 'alert');
+  });
+
+  it('alerts on errors', function() {
+    doSomethingToCauseAnError();
+    expect(this.alertStub.calledWith('UH OH!')).to.be.true();
+  });
+
+  after(function() {
+    this.alertStub.restore();
+  });
+});
+```
+
+Additionally, qunit-bdd ships with support for RSpec-style per-context `let`
+values, called `lazy` values in qunit-bdd. This is very useful when you want to
+declare how to set up a complex object in a top-level context, overriding parts
+of that setup in nested contexts:
+
+```js
+describe('Person', function() {
+  lazy('person', function() {
+    return new Person({
+      firstName: this.firstName,
+      lastName: this.lastName,
+      dob: this.dob,
+      address: this.address
+    });
+  });
+
+  lazy('address', function() {
+    return {
+      street1: this.street1,
+      street2: this.street2,
+      city: this.city,
+      state: this.state,
+      postal: this.postal
+    };
+  });
+
+  // Defaults for dependent values could be put here (e.g. firstName, street1, etc).
+
+  describe('#canVote', function() {
+    context('when the person is not yet 18', function() {
+      lazy('dob', function(){ return new Date(); });
+
+      it('is false', function() {
+        expect(this.person.canVote()).to.be.false();
+      });
+    });
+
+    context('when the person is over 18', function() {
+      lazy('dob', function(){ return new Date(0); });
+
+      it('is true', function() {
+        expect(this.person.canVote()).to.be.true();
+      });
+    });
+  });
+});
+```
+
+The benefit to this approach over setting up your test objects in `before` is
+that you can override parts of the built objects declaratively in nested
+contexts, something you might have used a bunch of helper functions to do with
+QUnit's default `module`/`test` functions.
+
+You can also use `helper` to define helper functions that have access to
+everything defined on the test context. This is useful for reusing a
+piece of code between tests that have different setups. Example:
+
+```js
+describe('APIRequest', function() {
+  before(function() {
+    this.url = "http://api.endpoint.com";
+    this.apiController = new ApiController();
+    this.moreTestState = {};
+  });
+
+  helper('fireApiRequest', function() {
+    // full access to everything on current context.
+    this.apiController.ajax(this.url, this.moreTestState);
+  });
+
+  it('works', function() {
+    // ... test-specific setup
+    this.fireApiRequest();
+  });
+
+  it('works in another context', function() {
+    // ... test-specific setup
+    this.fireApiRequest();
+  });
+});
+```
+
+### Configuration
+
+It's still QUnit, so you can write some tests using the `module`/`test` style,
+complete with the usual `ok`/`equal`/`deepEqual` assertions, if you find it
+more appropriate sometimes. Also, you can export as much or as little of
+qunit-bdd to the global scope as you like:
+
+```js
+// Turn off `lazy` and `context` exports.
+// Make sure to set this before loading qunit-bdd.js.
+QUNIT_BDD_OPTIONS = {
+  GLOBALS: {
+    lazy: false,  // don't use lazy
+    expect: false // use the regular QUnit assertions (or another set altogether)
+  }
+};
+```
+
+#### Randomness
+
+By default your tests will run in the order in which they are defined. This is
+usually desirable for interactive development and debugging. But for continuous
+integration you may want to run your tests in a random order to reveal any
+hidden dependencies between your tests that may be causing them not to work as
+expected. To turn this on, set `QUNIT_BDD_OPTIONS.randomize` to `true`. Doing
+so will first shuffle your `describe`s, then shuffle the `it`s within.
+
+If you want to use a particular randomizer, pass a function that takes an array
+and returns a shuffled array instead of `true`.  For example, here's how to
+configure qunit-bdd to use [chance.js][chance.js] with a random (but
+repeatable, for reproducing failures locally) seed:
+
+```js
+var seed = Math.floor(Math.random() * 1000);
+console.log('Random test order seed:', seed);
+var chance = new Chance(seed);
+QUNIT_BDD_OPTIONS = {
+  randomize: function(array) {
+    return chance.shuffle(array);
+  }
+};
+```
+
+#### Skipping Tests
+
+You can also configure which tests are run, which can aid in debugging. To skip
+a particular test (or context), use `it.skip()` instead of `it()` (or
+`describe.skip()` instead of `describe()`). To run *only* a particular test (or
+context), use `it.only()` instead of `it` (or `describe.only()` instead of
+`describe()`).
+
+#### Expectations / Assertions
+
+You can configure the built-in assertion `expect()` function to add your own
+custom assertions or override the built-in ones:
+
+```js
+expect.configure({
+  // expect(2).to.be.even();
+  even: function() {
+    QUnit.ok(!(this._actual % 2), 'expected ' + this._actual + ' to be even');
+  }
+});
+```
+
+Note that the `expect()` function can still be used as you would while writing
+QUnit tests the normal way, i.e. as `expect(4)` to set the number of expected
+assertions.
+
+### Community
+
+Come chat on our [Google Group][google-group] page or use the
+[qunit-bdd][stack-overflow] tag on Stack Overflow.
+
+### Contributing
+
+#### Setup
+
+First, install the development dependencies:
+
+```
+$ npm install
+```
+
+Then, try running the tests:
+
+```
+$ npm test
+```
+
+### Development
+
+As you make changes you may find it useful to have everything automatically
+compiled and ready to test interactively in the browser. You can do that using
+the `develop` script:
+
+```
+$ npm run develop
+```
+
+Then go to http://localhost:8000/test in your browser (run with `PORT={port}`
+to override the default port).
+
+### Pull Requests
+
+Contributions via pull requests are very welcome! Follow the steps in
+Developing above, then add your feature or bugfix with tests to cover it, push
+to a branch, and open a pull request.
+
+Any contributors to the master qunit-bdd repository must sign the [Individual
+Contributor License Agreement (CLA)][cla]. It's a short form that covers our
+bases and makes sure you're eligible to contribute.
+
+[cla]: https://spreadsheets.google.com/spreadsheet/viewform?formkey=dDViT2xzUHAwRkI3X3k5Z0lQM091OGc6MQ&ndplr=1
+
+When you have a change you'd like to see in the master repository, [send a pull
+request](https://github.com/square/qunit-bdd/pulls). Before we merge your
+request, we'll make sure you're in the list of people who have signed a CLA.
+
+[chance.js]: http://chancejs.com/
+[google-group]: https://groups.google.com/forum/#!forum/qunit-bdd
+[stack-overflow]: http://stackoverflow.com/questions/tagged/qunit-bdd