hippo-fw 0.9.1

data/spec/factories/user.rb

@@ -0,0 +1,11 @@
+FactoryGirl.define do
+    factory :user, class: Hippo::User do
+        name { Faker::Name.name }
+        email { Faker::Internet.email }
+        login { Faker::Internet.user_name }
+
+        password 'password'
+        password_confirmation 'password'
+        role_names ['administrator']
+    end
+end

data/spec/fixtures/system_settings.yml

@@ -0,0 +1,8 @@
+default:
+  id: 1
+  settings:
+    hippo:
+      smtp:
+        server: test.test.test
+        login: 'test'
+        password: 'test'

data/spec/fixtures/test_printer.tex

@@ -0,0 +1,22 @@
+\documentclass[12pt]{article}
+\begin{document}
+Some work from stories others from requirements,
+If we are lucky the analysts have thought of resources and environments!!
+Does this field accept a digit, a letter or a hash?
+What happens if I inject something here a comma or slash?
+
+How about testing stress, load or capacity?
+I've found a bug developer please don't be mad at me.
+It works on your system? Well it doesn't on mine,
+If you take a look and fix it I'm sure production be fine.
+
+Is it secure or can someone break in?
+Mess with the system send it in a spin.
+Will it failover gracefully and alert you of issues,
+Make supporting the system simple and report any misuse.
+
+Can this talk to that and do it in time?
+Oh God will the users like it and think its sublime.
+Does it do what they want or is it worse than they've got?
+After all of this testing I bloody hope not.
+\end{document}

data/spec/fixtures/user.yml

@@ -0,0 +1,2 @@
+test:
+  login: test

data/spec/hippo/components/grid/GridSpec.coffee

@@ -0,0 +1,56 @@
+#= require hippo/components/grid
+
+
+DATA = {total:2, success:true, message:"Retrieve succeeded", data:[
+    [1, "TEST1", "Nathan Stitt", "swell guy"]
+    [2, "TEST2", "Nathan Stitt", "Dupe of id #1"]
+]}
+
+Model = Hippo.Test.defineModel(
+    props: {id: 'integer', code: 'string', name: 'string', notes: 'string'}
+)
+
+renderGrid = (q, done) ->
+    loaded = spyOn(q.results, 'ensureLoaded').and.callThrough()
+    grid = LT.renderComponent(LC.Grid, props: query: q)
+    expect(loaded).toHaveBeenCalled()
+    _.defer ->
+        expect(_.dom(grid).qs('.r').el).not.toBeNull()
+        done()
+
+
+describe "Hippo.Components.Grid", ->
+
+    beforeEach (done) ->
+        LT.syncRespondWith(DATA)
+        @query = new Hippo.Models.Query(
+            src: Model, fields: [ 'id', 'code', 'name', 'notes' ]
+        )
+        @collection = new Model.Collection
+        @query.ensureLoaded().then => @collection.ensureLoaded().then -> done()
+
+    describe "loading", ->
+
+        it "from a result set", (d) ->
+            renderGrid(@query, d)
+
+        it "from a collection", (d) ->
+            @query.src = @collection
+            renderGrid(@query, d)
+
+    it 'renders toolbar', ->
+        grid = LT.renderComponent(LC.Grid, props: {
+            query: @query, editor: true, allowCreate: true
+        })
+        tb = _.dom(grid).qs('.toolbar')
+        expect(tb).not.toBeUndefined()
+
+    it 'notifies when selection changes', (done) ->
+        spy = jasmine.createSpy('selection')
+        grid = LT.renderComponent(LC.Grid, props: {
+            query: @query, editor: true, onSelectionChange: spy
+        })
+        _.defer ->
+            _.dom(grid).qs('.grid-body .c').click()
+            expect(spy).toHaveBeenCalled()
+            done()

data/spec/hippo/components/grid/PopoverEditorSpec.coffee

@@ -0,0 +1,47 @@
+#= require hippo/components/grid
+
+
+DATA = {total:2, success:true, message:"Retrieve succeeded", data:[
+    [1, "TEST1", "Nathan Stitt", "swell guy"]
+    [2, "TEST2", "Nathan Stitt", "Dupe of id #1"]
+]}
+
+Model = Hippo.Test.defineModel(
+    props: {id: 'integer', code: 'string', name: 'string', notes: 'string'}
+)
+
+LAST_ROW_SELECTOR = '.grid-body .r:last-child'
+ADD_ROW_SELECTOR = 'button.add-row'
+
+describe "Hippo.Components.Grid.PopoverEditor", ->
+
+    beforeEach (done) ->
+        LT.syncRespondWith(DATA)
+        @query = new Hippo.Models.Query(
+            src: Model, fields: [ 'id', 'code', 'name', 'notes' ]
+        )
+        @query.ensureLoaded().then =>
+            @grid = LT.renderComponent(LC.Grid, props: {
+                allowCreate: true, editor: Hippo.Components.Grid.PopoverEditor, query: @query
+            })
+            done()
+
+    it "edits", (done) ->
+        _.dom(@grid).qs(LAST_ROW_SELECTOR).click(clientX: 5)
+        editor = Hippo.Test.Utils.findRenderedComponentWithType(
+            @grid, Hippo.Components.Grid.PopoverEditor
+        )
+        _.dom(editor).qs('.field:nth-of-type(3) input').setValue('BOB')
+        _.dom(editor).qs('.btn.save').click()
+        expect( @query.results.rowAt(1)[2] ).toEqual('BOB')
+        done()
+
+    it 'adds row', (done) ->
+        _.dom(@grid).qs(ADD_ROW_SELECTOR).click()
+        editor = Hippo.Test.Utils.findRenderedComponentWithType(
+            @grid, Hippo.Components.Grid.PopoverEditor
+        )
+        _.dom(editor).qs('.field:nth-of-type(3) input').setValue('BOB')
+        _.dom(editor).qs('.btn.save').click()
+        expect( @query.results.rowAt(0)[2] ).toEqual('BOB')
+        done()

data/spec/hippo/components/grid/RowEditorSpec.coffee

@@ -0,0 +1,98 @@
+#= require hippo/components/grid
+
+COLLECTION_DATA = [
+    {id:1, code:'TEST1', name: 'Nathan Stitt', notes: 'swell guy'}
+    {id:2, code:'TEST2', name: 'Nathan Stitt', notes: 'Dupe of id #1'}
+]
+
+ROW_DATA = _.map COLLECTION_DATA, (r) -> _.values(r)
+
+Model = Hippo.Test.defineModel(
+    props: {id: 'integer', code: 'string', name: 'string', notes: 'string'}
+)
+
+LAST_ROW_SELECTOR = '.grid-body .r:last-child'
+ADD_ROW_SELECTOR = 'button.add-row'
+
+RenderGrid = (q) ->
+    LT.renderComponent(LC.Grid, props: {
+        query: q, editor: true, allowCreate: true
+    })
+
+RenderEdit = (q, value) ->
+    Hippo.Test.syncSucceedWith(ROW_DATA)
+    grid = RenderGrid(q)
+
+    new _.Promise (res, rej) -> _.defer ->
+        _.dom(grid).qs(LAST_ROW_SELECTOR).click()
+        editor = Hippo.Test.Utils.findRenderedComponentWithType(
+            grid, Hippo.Components.Grid.RowEditor
+        )
+        _.dom(editor).qs('.field:nth-of-type(2) input').change(target: {value})
+        res({grid, editor})
+
+
+
+CommonSpecs = ->
+
+    it 'sets the props', (done) ->
+        grid = LT.renderComponent(LC.Grid, props: {
+            query: @query, editor: true
+        })
+        _.defer ->
+            _.dom(grid).qs(LAST_ROW_SELECTOR).click()
+            editor = Hippo.Test.Utils.findRenderedComponentWithType(grid, LC.Grid.RowEditor)
+            expect(editor.props.rowIndex).toEqual(1)
+            expect(editor.props.model).toEqual(jasmine.any(Model))
+            expect(editor.props.model.id).toEqual(2)
+            done()
+
+    it 'can edit', (done) ->
+        RenderEdit(@query, 'BOB').then ({editor}) =>
+            _.dom(editor).qs('.btn.save').click()
+            expect( @query.results.rowAt(1)[1] ).toEqual('BOB')
+            done()
+
+    it 'does not update when edit is canceled', (done) ->
+        expect( @query.results.rowAt(1)[1] ).toEqual('TEST2')
+        RenderEdit(@query, 'CANCKED').then ({editor}) =>
+            _.dom(editor).qs('.btn.cancel').click()
+            expect( @query.results.rowAt(1)[1] ).toEqual('TEST2')
+            done()
+
+    it 'removes an unsaved row when editing is canceled', (done) ->
+        grid = RenderGrid(@query)
+        _.defer =>
+            addRow = spyOn(@query.results, 'addBlankRow').and.callThrough()
+            removeRow = spyOn(@query.results, 'removeRow').and.callThrough()
+            expect(@query.results.length).toEqual(2)
+            _.dom(grid).qs(ADD_ROW_SELECTOR).click()
+            expect(@query.results.addBlankRow).toHaveBeenCalled()
+            editor = Hippo.Test.Utils.findRenderedComponentWithType(
+                grid, Hippo.Components.Grid.RowEditor
+            )
+            expect(@query.results.length).toEqual(3)
+            _.dom(editor).qs('.btn.cancel').click()
+            expect(@query.results.removeRow).toHaveBeenCalled()
+            expect(@query.results.length).toEqual(2)
+            done()
+
+describe "Hippo.Components.Grid.RowEditor", ->
+
+    describe "using row based result set", ->
+        beforeEach (done) ->
+            @query = new Hippo.Models.Query(
+                fields: [ 'id', 'code', 'name', 'notes' ], src: Model
+            )
+            Hippo.Test.syncSucceedWith(ROW_DATA)
+            @query.ensureLoaded().then(done)
+        CommonSpecs()
+
+
+    describe "using a collection", ->
+        beforeEach ->
+            @query = new Hippo.Models.Query(
+                fields: [ 'id', 'code', 'name', 'notes' ],
+                src: new Model.Collection(COLLECTION_DATA)
+            )
+        CommonSpecs()

data/spec/hippo/components/select-field/SelectFieldSpec.coffee

@@ -0,0 +1,106 @@
+#= require hippo/components/select-field
+
+Brand = Hippo.Test.defineModel(
+    props: {id: 'integer', code: 'string', name: 'string'}
+)
+
+BRAND_DATA = {total:3, success:true, message:"Retrieve succeeded", data:[
+    {id: 1, code: "GM",    name: "General Motors"}
+    {id: 2, code: "FORD",  name: "Ford Motor Co."}
+    {id: 3, code: "DODGE", name: "Chrysler/Dodge"}
+]}
+
+VALUE_CLASS = '.form-control-static'
+
+Car = Hippo.Test.defineModel(
+    props: {id: 'integer', code: 'string', brand_id: 'integer'}
+    session:
+        carTypes: 'array'
+
+    associations:
+        brand: {model: Brand}
+)
+
+describe "Hippo.Components.SelectField", ->
+    beforeEach (done) ->
+        @car = new Car
+        LT.syncRespondWith(BRAND_DATA)
+        @brands = new Brand.Collection
+        @brands.ensureLoaded().then(done)
+
+    it "renders read only", (done) ->
+        sf = LT.renderComponent(LC.SelectField,
+             props:{model: @car, name: 'brand', labelField: 'name'})
+        expect(_.dom(sf).qs(VALUE_CLASS).text).toBe('')
+        @car.set(brand: @brands.at(0))
+        _.defer ->
+            expect(_.dom(sf).qs(VALUE_CLASS).text).toBe('General Motors')
+            done()
+
+    it "renders as edit", ->
+        @car.set(brand: @brands.at(1))
+        sf = LT.renderComponent(LC.SelectField, props:{
+             model: @car, name: 'brand', labelField: 'name',
+             editOnly: true, collection: @brands })
+        expect(_.dom(sf).qs('input[type=text]').value).toEqual('Ford Motor Co.')
+
+    it 'uses a custom data source', (done) ->
+        sf = LT.renderComponent(LC.SelectField, props:{
+            model: @car, name: 'brand', editOnly: true
+            value: 4, choices: [{ label: 'Toyota', id: 4 }]
+        })
+        _.defer ->
+            expect(_.dom(sf).qs('input[type=text]').value).toEqual('Toyota')
+            done()
+
+    it 'sets value when changed', ->
+        @car.set(brand: @brands.at(1))
+        sf = LT.renderComponent(LC.SelectField, props:{
+            model: @car, name: 'brand', labelField: 'name',
+            fetchOnSelect: false, editOnly: true, choices: @brands.models
+        })
+        _.dom(sf).qs('.rw-select').click()
+        _.dom(sf).qs('.rw-list li:last-child').click()
+        expect(@car.brand.code).toEqual('DODGE')
+
+    it 'can select multiple values', (done) ->
+        sf = LT.renderComponent(LC.SelectField, props:{
+            queryModel: Car,
+            multiSelect: true, model: @car, name: 'carTypes', fetchOnSelect: false
+            labelField: 'name', editOnly: true, choices: @brands.models
+        })
+
+        _.dom(sf).qs('.rw-input').focus()
+        _.defer =>
+            expect( _.dom(sf).qsa('.rw-list li').length ).toEqual(@brands.length)
+            _.dom(sf).qs('.rw-list-option:nth-child(1)').click()
+            _.dom(sf).qs('.rw-input').focus()
+            _.dom(sf).qs('.rw-list-option:nth-child(2)').click()
+            expect(_.map(@car.carTypes, 'id')).toEqual([1, 3])
+            done()
+
+    it 'renders label for single values', ->
+        @car.set(brand: @brands.last())
+        sf = LT.renderComponent(LC.SelectField, props:{
+            model: @car, name: 'brand', labelField: 'name',
+            choices: @brands.models
+        })
+        expect(_.dom(sf).qs(VALUE_CLASS).text).toEqual('Chrysler/Dodge')
+
+    it 'renders label for multiple values', ->
+        @car.carTypes = [ @brands.at(0), @brands.at(2) ]
+        sf = LT.renderComponent(LC.SelectField, props:{
+            queryModel: Car, multiSelect: true, model: @car, name: 'carTypes'
+            labelField: 'name', choices: @brands.models
+        })
+        expect(_.dom(sf).qs(VALUE_CLASS).text).toEqual('General Motors and Chrysler/Dodge')
+
+
+    it "renders all choices", ->
+        sf = LT.renderComponent(LC.SelectField, props:{
+            queryModel: Car, model: @car, name: 'brand', labelField: 'name',
+            editOnly: true, choices: @brands.models
+        })
+        _.dom(sf).qs('.rw-select').click()
+        labels = _.map _.dom(sf).qsa('li.rw-list-option'), 'textContent'
+        expect(labels).toEqual(["General Motors", "Ford Motor Co.", "Chrysler/Dodge"])

data/spec/hippo/components/shared/NetworkActivityOverlaySpec.coffee

@@ -0,0 +1,34 @@
+Model = Hippo.Test.defineModel(
+    props: {id: 'integer', code: 'string', name: 'string', notes: 'string'}
+)
+
+describe "Hippo.Components.NetworkActivityOverlay", ->
+
+    it "doesn't render unless requesting", ->
+        na = LT.renderComponent(LC.NetworkActivityOverlay, props:{message: 'Lookout 4 Bears'})
+        expect(_.dom(na).el).toBe(null)
+
+    it "renders message", ->
+        na = LT.renderComponent(LC.NetworkActivityOverlay, props:{
+            visible: true, message: 'Lookout 4 Bears'})
+        expect(_.dom(na).qs('.message').text).toBe('Lookout 4 Bears')
+
+    it 'chooses message based on request type', ->
+        na = LT.renderComponent(LC.NetworkActivityOverlay, props:{visible:true})
+        na.setState(isRequesting: 'GET')
+        expect(_.dom(na).qs('.message').text).toBe('Loading…')
+        na.setState(isRequesting: 'POST')
+        expect(_.dom(na).qs('.message').text).toBe('Saving…')
+        na.setState(isRequesting: 'DELETE')
+        expect(_.dom(na).qs('.message').text).toBe('Deleting…')
+
+    it 'briefly displays an error message', (done) ->
+        model = new Model
+        na = LT.renderComponent(LC.NetworkActivityOverlay, props:{
+            errorTimeout: 2, model:model})
+        na.setModelState(hasError: true)
+        expect(_.dom(na).qs('.message').text).toBe('Error')
+        _.delay( ->
+            expect(_.dom(na).el).toBe(null)
+            done()
+        , 3)

data/spec/hippo/helpers/hippo-helpers.coffee

@@ -0,0 +1,5 @@
+Hippo.Vendor.MessageBus = {
+    subscribe:   jasmine.createSpy('subscribe')
+    unsubscribe: jasmine.createSpy('unsubscribe')
+    start: Hippo.emptyFn
+}

data/spec/hippo/helpers/jasmine-matchers.js

@@ -0,0 +1,1580 @@
+/*
+ * Copyright © Jamie Mason, @fold_left,
+ * https://github.com/JamieMason
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+(function() {
+    const matchers = {};
+    const priv = {};
+
+  /**
+   * @inner
+   * @param  {Object} object
+   * @param  {Function} fn
+   */
+    priv.each = function(object, fn) {
+        for (const key in object) {
+            if (object.hasOwnProperty(key)) {
+                fn.call(this, object[key], key, object);
+            }
+        }
+    };
+
+  /**
+   * @inner
+   * @param  {Object} object
+   * @param  {Function} fn
+   * @param  {*} memo
+   * @return {*} memo
+   */
+    priv.reduce = function(object, fn, memo) {
+        priv.each.call(this, object, (el, ix, list) => {
+            memo = fn(memo, el, ix, list);
+        });
+        return memo;
+    };
+
+  /**
+   * @inner
+   * @param  {Array} array
+   * @param  {Function} fn
+   * @return {Boolean}
+   */
+    priv.all = function(array, fn) {
+        let i;
+        const len = array.length;
+        for (i = 0; i < len; i++) {
+            if (false === fn.call(this, array[i], i, array)) {
+                return false;
+            }
+        }
+        return true;
+    };
+
+  /**
+   * @inner
+   * @param  {String} matcherName
+   * @return {Boolean}
+   */
+    priv.expectAllMembers = function(matcherName) {
+        return priv.all.call(this, this.actual, item => matchers[matcherName].call({
+            actual: item,
+        }));
+    };
+
+  /**
+   * Assert subject is of type
+   * @inner
+   * @param  {*} subject
+   * @param  {String} type
+   * @return {Boolean}
+   */
+    priv.is = function(subject, type) {
+        return Object.prototype.toString.call(subject) === `[object ${type}]`;
+    };
+
+  /**
+   * Assert subject is an HTML Element with the given node type
+   * @inner
+   * @param  {*} subject
+   * @param  {String} type
+   * @return {Boolean}
+   */
+    priv.isHtmlElementOfType = function(subject, type) {
+        return subject && subject.nodeType === type;
+    };
+
+  /**
+   * Convert Array-like Object to true Array
+   * @inner
+   * @param  {*} list
+   * @return {Array}
+   */
+    priv.toArray = function(list) {
+        return [].slice.call(list);
+    };
+
+  /**
+   * @inner
+   * @param  {String} matcherName
+   * @param  {String} memberName
+   * @param  (*) ...
+   * @return {Boolean}
+   */
+    priv.assertMember = function(/* matcherName, memberName, ... */) {
+        const args = priv.toArray(arguments);
+        const matcherName = args.shift();
+        const memberName = args.shift();
+        return priv.is(this.actual, 'Object') && matchers[matcherName].apply({
+            actual: this.actual[memberName],
+        }, args);
+    };
+
+  /**
+   * @summary
+   * Format the failure message for member matchers such as toHaveString('surname').
+   *
+   * @inner
+   * @param  {Object}  util   Provided by Jasmine.
+   * @param  {String}  name   Name of the matcher, such as toBeString.
+   * @param  {Array}   args   converted arguments.
+   * @param  {Boolean} pass   Whether the test passed.
+   * @param  {*}       actual The expected value.
+   * @return {String}         The message to display on failure.
+   */
+    priv.formatFailMessage = function(util, name, args, pass, actual) {
+        if (-1 === name.search(/^toHave/)) {
+            return util.buildFailureMessage.apply(null, [name, pass, actual].concat(args));
+        }
+        const memberName = args.shift();
+        return util.buildFailureMessage.apply(null, [name, pass, actual].concat(args))
+      .replace('Expected', `Expected member "${memberName}" of`)
+      .replace(' to have ', ' to be ');
+    };
+
+  /**
+   * @summary
+   * Convert Jasmine 1.0 matchers into the format introduced in Jasmine 2.0.
+   *
+   * @inner
+   * @param  {Object} v1Matchers
+   * @return {Object} v2Matchers
+   */
+    priv.adaptMatchers = function(v1Matchers) {
+        return priv.reduce(v1Matchers, (v2Matchers, matcher, name) => {
+            v2Matchers[name] = function(util) {
+                return {
+                    compare(actual /* , expected, ...*/) {
+                        const args = priv.toArray(arguments).slice(1);
+                        const pass = matcher.apply({
+                            actual,
+                        }, args);
+                        return {
+                            pass,
+                            message: priv.formatFailMessage(util, name, args, pass, actual),
+                        };
+                    },
+                };
+            };
+            return v2Matchers;
+        }, {});
+    };
+
+  /**
+   * @file Arrays
+   *
+   * @description
+   * See {@link http://git.io/jasmine-array-testing|Unit testing Arrays with Jasmine}.
+   */
+
+  /**
+   * @alias
+   * expect(array):toBeArray
+   *
+   * @summary
+   * Assert subject is a true Array, created in the parent document — those created and imported
+   * from within iframes or other windows will not match.
+   *
+   * @return {Boolean}
+   */
+    matchers.toBeArray = function() {
+        return this.actual instanceof Array;
+    };
+
+  /**
+   * @alias
+   * expect(array):toBeArrayOfSize
+   *
+   * @summary
+   * Assert subject is not only a true Array, but one with a specific number of members.
+   *
+   * @param {Number} size
+   * @return {Boolean}
+   */
+    matchers.toBeArrayOfSize = function(size) {
+        return priv.is(this.actual, 'Array') && this.actual.length === size;
+    };
+
+  /**
+   * @alias
+   * expect(array):toBeEmptyArray
+   *
+   * @summary
+   * Assert subject is not only a true Array, but one without any members.
+   *
+   * @return {Boolean}
+   */
+    matchers.toBeEmptyArray = function() {
+        return matchers.toBeArrayOfSize.call(this, 0);
+    };
+
+  /**
+   * @alias
+   * expect(array):toBeNonEmptyArray
+   *
+   * @summary
+   * Assert subject is not only a true Array, but one with at least one member.
+   *
+   * @return {Boolean}
+   */
+    matchers.toBeNonEmptyArray = function() {
+        return priv.is(this.actual, 'Array') && 0 < this.actual.length;
+    };
+
+  /**
+   * @inner
+   * @param {String} toBeX
+   * @return {Function}
+   */
+    priv.createToBeArrayOfXsMatcher = function(toBeX) {
+        return function() {
+            return priv.is(this.actual, 'Array') && priv.expectAllMembers.call(this, toBeX);
+        };
+    };
+
+  /**
+   * @alias
+   * expect(array):toBeArrayOfObjects
+   *
+   * @summary
+   * Assert subject is an Array which is either empty or contains only Objects.
+   *
+   * @return {Boolean}
+   */
+    matchers.toBeArrayOfObjects = function() {
+        return priv.is(this.actual, 'Array') && priv.expectAllMembers.call(this, 'toBeObject');
+    };
+
+  /**
+   * @alias
+   * expect(array):toBeArrayOfStrings
+   *
+   * @summary
+   * Assert subject is an Array which is either empty or contains only Strings.
+   *
+   * @return {Boolean}
+   */
+    matchers.toBeArrayOfStrings = function() {
+        return priv.is(this.actual, 'Array') && priv.expectAllMembers.call(this, 'toBeString');
+    };
+
+  /**
+   * @alias
+   * expect(array):toBeArrayOfNumbers
+   *
+   * @summary
+   * Assert subject is an Array which is either empty or contains only Numbers.
+   *
+   * @return {Boolean}
+   */
+    matchers.toBeArrayOfNumbers = function() {
+        return priv.is(this.actual, 'Array') && priv.expectAllMembers.call(this, 'toBeNumber');
+    };
+
+  /**
+   * @alias
+   * expect(array):toBeArrayOfBooleans
+   *
+   * @summary
+   * Assert subject is an Array which is either empty or contains only Booleans.
+   *
+   * @return {Boolean}
+   */
+    matchers.toBeArrayOfBooleans = function() {
+        return priv.is(this.actual, 'Array') && priv.expectAllMembers.call(this, 'toBeBoolean');
+    };
+
+  /**
+   * @file Booleans
+   *
+   * @description
+   * See {@link http://git.io/jasmine-boolean-testing|Unit testing Booleans with Jasmine}.
+   */
+
+  /**
+   * @alias
+   * expect(boolean):toBeBoolean
+   *
+   * @summary
+   * Assert subject is not only truthy or falsy, but an actual Boolean.
+   *
+   * @return {Boolean}
+   */
+    matchers.toBeBoolean = function() {
+        return matchers.toBeTrue.call(this) || matchers.toBeFalse.call(this);
+    };
+
+  /**
+   * @alias
+   * expect(boolean):toBeTrue
+   *
+   * @summary
+   * Assert subject is not only truthy, but an actual Boolean true.
+   *
+   * @return {Boolean}
+   */
+    matchers.toBeTrue = function() {
+        return true === this.actual || this.actual instanceof Boolean && true === this.actual.valueOf();
+    };
+
+  /**
+   * @alias
+   * expect(boolean):toBeFalse
+   *
+   * @summary
+   * Assert subject is not only falsy, but an actual Boolean false.
+   *
+   * @return {Boolean}
+   */
+    matchers.toBeFalse = function() {
+        return false === this.actual || this.actual instanceof Boolean && false === this.actual.valueOf();
+    };
+
+  /**
+   * @file Browser
+   *
+   * @description
+   * See {@link http://git.io/jasmine-browser-testing|Unit testing Browsers with Jasmine}.
+   */
+
+  /**
+   * @alias
+   * expect(window):toBeWindow
+   *
+   * @summary
+   * Assert subject is a browser Window global, whether that be the parent window or those
+   * created within iframes or other windows.
+   *
+   * @return {Boolean}
+   */
+    matchers.toBeWindow = function() {
+        return this.actual && 'object' === typeof this.actual && this.actual.window === this.actual;
+    };
+
+  /**
+   * @alias
+   * expect(document):toBeDocument
+   *
+   * @summary
+   * Assert subject is a browser Window global, whether that be the parent window or those
+   * created within iframes or other windows.
+   *
+   * @return {Boolean}
+   */
+    matchers.toBeDocument = function() {
+        return this.actual && 'object' === typeof this.actual && this.actual instanceof window.HTMLDocument;
+    };
+
+  /**
+   * @alias
+   * expect(htmlElement):toBeHtmlNode
+   *
+   * @summary
+   * Assert subject is an HTML Element.
+   *
+   * @return {Boolean}
+   */
+    matchers.toBeHtmlNode = function() {
+        return priv.isHtmlElementOfType(this.actual, 1);
+    };
+
+  /**
+   * @alias
+   * expect(htmlElement):toBeHtmlTextNode
+   *
+   * @summary
+   * Assert subject is an HTML Text Element.
+   *
+   * @return {Boolean}
+   */
+    matchers.toBeHtmlTextNode = function() {
+        return priv.isHtmlElementOfType(this.actual, 3);
+    };
+
+  /**
+   * @alias
+   * expect(htmlElement):toBeHtmlCommentNode
+   *
+   * @summary
+   * Assert subject is an HTML Comment Element.
+   *
+   * @return {Boolean}
+   */
+    matchers.toBeHtmlCommentNode = function() {
+        return priv.isHtmlElementOfType(this.actual, 8);
+    };
+
+  /**
+   * @file Dates
+   *
+   * @description
+   * See {@link http://git.io/jasmine-date-testing|Unit testing Dates with Jasmine}.
+   */
+
+  /**
+   * @alias
+   * expect(date):toBeDate
+   *
+   * @summary
+   * Assert subject is a true Date, created in the parent document — those created and imported
+   * from within iframes or other windows will not match.
+   *
+   * @return {Boolean}
+   */
+    matchers.toBeDate = function() {
+        return this.actual instanceof Date;
+    };
+
+  /**
+   * @alias
+   * expect(string):toBeIso8601
+   *
+   * @summary
+   * Assert subject is a Date String conforming to the ISO 8601 standard.
+   *
+   * @return {Boolean}
+   */
+    matchers.toBeIso8601 = function() {
+        return matchers.toBeString.call(this)
+      && 10 <= this.actual.length
+      && 'Invalid Date' !== new Date(this.actual).toString()
+      && new Date(this.actual).toISOString().slice(0, this.actual.length) === this.actual;
+    };
+
+  /**
+   * @alias
+   * expect(date):toBeBefore
+   *
+   * @summary
+   * Assert subject is a Date occurring before another Date.
+   *
+   * @param {Date} date
+   * @return {Boolean}
+   */
+    matchers.toBeBefore = function(date) {
+        return matchers.toBeDate.call(this) && matchers.toBeDate.call({ actual: date }) && this.actual.getTime() < date.getTime();
+    };
+
+  /**
+   * @alias
+   * expect(date):toBeAfter
+   *
+   * @summary
+   * Assert subject is a Date occurring after another Date.
+   *
+   * @param {Date} date
+   * @return {Boolean}
+   */
+    matchers.toBeAfter = function(date) {
+        return matchers.toBeBefore.call({ actual: date }, this.actual);
+    };
+
+  /**
+   * @file Errors
+   *
+   * @description
+   * See {@link http://git.io/jasmine-error-testing|Unit testing Errors with Jasmine}.
+   */
+
+  /**
+   * @alias
+   * expect(function):toThrowError
+   *
+   * @summary
+   * Asserts subject throws an Error of any type.
+   *
+   * @return {Boolean}
+   */
+    matchers.toThrowError = function() {
+        let threwError = false;
+        try {
+            this.actual();
+        } catch (e) {
+            threwError = true;
+        }
+        return threwError;
+    };
+
+  /**
+   * @alias
+   * expect(function):toThrowErrorOfType
+   *
+   * @summary
+   * Asserts subject throws an Error of a specific type, such as "TypeError".
+   *
+   * @param  {String} type
+   * @return {Boolean}
+   */
+    matchers.toThrowErrorOfType = function(type) {
+        let threwErrorOfType = false;
+        try {
+            this.actual();
+        } catch (e) {
+            threwErrorOfType = (e.name === type);
+        }
+        return threwErrorOfType;
+    };
+
+  /**
+   * @file Numbers
+   *
+   * @description
+   * See {@link http://git.io/jasmine-number-testing|Unit testing Numbers with Jasmine}.
+   */
+
+  /**
+   * @alias
+   * expect(number):toBeNumber
+   *
+   * @summary
+   * Assert subject is not only calculable, but an actual Number
+   *
+   * @return {Boolean}
+   */
+    matchers.toBeNumber = function() {
+        return !isNaN(parseFloat(this.actual)) && !priv.is(this.actual, 'String');
+    };
+
+  /**
+   * @alias
+   * expect(number):toBeEvenNumber
+   *
+   * @summary
+   * Assert subject is an even Number.
+   *
+   * @return {Boolean}
+   */
+    matchers.toBeEvenNumber = function() {
+        return matchers.toBeNumber.call(this) && 0 === this.actual % 2;
+    };
+
+  /**
+   * @alias
+   * expect(number):toBeOddNumber
+   *
+   * @summary
+   * Assert subject is an odd Number.
+   *
+   * @return {Boolean}
+   */
+    matchers.toBeOddNumber = function() {
+        return matchers.toBeNumber.call(this) && 0 !== this.actual % 2;
+    };
+
+  /**
+   * @alias
+   * expect(mixed):toBeCalculable
+   *
+   * @summary
+   * Assert subject can be used in Mathemetic calculations, despite not being an actual Number.
+   *
+   * @example
+   * // If all strings are numeric, JavaScript will cast them all as expect(number):
+   * "1" * "2" === 2 (pass)
+   *
+   * @example
+   * // If any string is not numeric, JavaScript will cast them all as Strings.
+   * "wut?" * 2 === NaN (fail)
+   *
+   * @return {Boolean}
+   */
+    matchers.toBeCalculable = function() {
+        return !isNaN(this.actual * 2);
+    };
+
+  /**
+   * @alias
+   * expect(number):toBeWithinRange
+   *
+   * @summary
+   * Assert value falls on or between floor and ceiling.
+   *
+   * @param {Number} floor
+   * @param {Number} ceiling
+   * @return {Boolean}
+   */
+    matchers.toBeWithinRange = function(floor, ceiling) {
+        return matchers.toBeNumber.call(this) && this.actual >= floor && this.actual <= ceiling;
+    };
+
+  /**
+   * @alias
+   * expect(number):toBeWholeNumber
+   *
+   * @summary
+   * Assert value is a number with no decimal places.
+   *
+   * @return {Boolean}
+   */
+    matchers.toBeWholeNumber = function() {
+        return matchers.toBeNumber.call(this) && (0 === this.actual || 0 === this.actual % 1);
+    };
+
+  /**
+   * @file Objects
+   *
+   * @description
+   * See {@link http://git.io/jasmine-object-testing|Unit testing Objects with Jasmine}.
+   */
+
+  /**
+   * @inner
+   *
+   * @summary
+   * Report how many instance members the given Object has.
+   *
+   * @param  {Object} object
+   * @return {Number}
+   */
+    priv.countMembers = function(object) {
+        return priv.reduce(object, (memo, el, ix) => memo + 1, 0);
+    };
+
+  /**
+   * @alias
+   * expect(object):toBeObject
+   *
+   * @summary
+   * Assert subject is a true Object, created in the parent document — those created and imported
+   * from within iframes or other windows will not match.
+   *
+   * @return {Boolean}
+   */
+    matchers.toBeObject = function() {
+        return this.actual instanceof Object;
+    };
+
+  /**
+   * @alias
+   * expect(object):toBeEmptyObject
+   *
+   * @summary
+   * Assert subject is a true Object with no instance members.
+   *
+   * @return {Boolean}
+   */
+    matchers.toBeEmptyObject = function() {
+        return priv.is(this.actual, 'Object') && 0 === priv.countMembers(this.actual);
+    };
+
+  /**
+   * @alias
+   * expect(object):toBeNonEmptyObject
+   *
+   * @summary
+   * Assert subject is a true Object with at least one instance member.
+   *
+   * @return {Boolean}
+   */
+    matchers.toBeNonEmptyObject = function() {
+        return priv.is(this.actual, 'Object') && 0 < priv.countMembers(this.actual);
+    };
+
+  /**
+   * @alias
+   * expect(object):toImplement
+   *
+   * @summary
+   * Assert subject is a true Object which features at least the same keys as `other` (regardless of
+   * whether it also has other members).
+   *
+   * @param  {Object} other
+   * @return {Boolean}
+   */
+    matchers.toImplement = function(other) {
+        if (!priv.is(this.actual, 'Object') || !priv.is(other, 'Object')) {
+            return false;
+        }
+        for (const key in other) {
+            if (key in this.actual) {
+                continue;
+            }
+            return false;
+        }
+        return true;
+    };
+
+  /**
+   * @alias
+   * expect(function):toBeFunction
+   *
+   * @summary
+   * Assert subject is a true Function, created in the parent document — those created and imported
+   * from within iframes or other windows will not match.
+   *
+   * @return {Boolean}
+   */
+    matchers.toBeFunction = function() {
+        return this.actual instanceof Function;
+    };
+
+  /**
+   * @file Strings
+   *
+   * @description
+   * See {@link http://git.io/jasmine-string-testing|Unit testing Strings with Jasmine}.
+   */
+
+  /**
+   * @alias
+   * expect(string):toBeString
+   *
+   * @summary
+   * Assert subject is a String.
+   *
+   * @return {Boolean}
+   */
+    matchers.toBeString = function() {
+        return priv.is(this.actual, 'String');
+    };
+
+  /**
+   * @alias
+   * expect(string):toBeEmptyString
+   *
+   * @summary
+   * Assert subject is a String of length 0.
+   *
+   * @return {Boolean}
+   */
+    matchers.toBeEmptyString = function() {
+        return '' === this.actual;
+    };
+
+  /**
+   * @alias
+   * expect(string):toBeNonEmptyString
+   *
+   * @summary
+   * Assert subject is a String with at least 1 character.
+   *
+   * @return {Boolean}
+   */
+    matchers.toBeNonEmptyString = function() {
+        return matchers.toBeString.call(this) && 0 < this.actual.length;
+    };
+
+  /**
+   * @alias
+   * expect(string):toBeHtmlString
+   *
+   * @summary
+   * Assert subject is string containing HTML Markup.
+   *
+   * @return {Boolean}
+   */
+    matchers.toBeHtmlString = function() {
+    // <           start with opening tag "<"
+    //  (          start group 1
+    //    "[^"]*"  allow string in "double quotes"
+    //    |        OR
+    //    '[^']*'  allow string in "single quotes"
+    //    |        OR
+    //    [^'">]   cant contains one single quotes, double quotes and ">"
+    //  )          end group 1
+    //  *          0 or more
+    // >           end with closing tag ">"
+        return matchers.toBeString.call(this) && -1 !== this.actual.search(/<("[^"]*"|'[^']*'|[^'">])*>/);
+    };
+
+  /**
+   * @alias
+   * expect(string):toBeJsonString
+   *
+   * @summary
+   * Assert subject is string containing parseable JSON.
+   *
+   * @return {Boolean}
+   */
+    matchers.toBeJsonString = function() {
+        let isParseable;
+        let json;
+        try {
+            json = JSON.parse(this.actual);
+        } catch (e) {
+            isParseable = false;
+        }
+        return false !== isParseable && null !== json;
+    };
+
+  /**
+   * @alias
+   * expect(string):toBeWhitespace
+   *
+   * @summary
+   * Assert subject is a String containing nothing but whitespace.
+   *
+   * @return {Boolean}
+   */
+    matchers.toBeWhitespace = function() {
+        return matchers.toBeString.call(this) && -1 === this.actual.search(/\S/);
+    };
+
+  /**
+   * @alias
+   * expect(string):toStartWith
+   *
+   * @summary
+   * Assert subject is a String whose first characters match our expected string.
+   *
+   * @param  {String} expected
+   * @return {Boolean}
+   */
+    matchers.toStartWith = function(expected) {
+        if (!matchers.toBeNonEmptyString.call(this) || !matchers.toBeNonEmptyString.call({
+            actual: expected,
+        })) {
+            return false;
+        }
+        return this.actual.slice(0, expected.length) === expected;
+    };
+
+  /**
+   * @alias
+   * expect(string):toEndWith
+   *
+   * @summary
+   * Assert subject is a String whose last characters match our expected string.
+   *
+   * @param  {String} expected
+   * @return {Boolean}
+   */
+    matchers.toEndWith = function(expected) {
+        if (!matchers.toBeNonEmptyString.call(this) || !matchers.toBeNonEmptyString.call({
+            actual: expected,
+        })) {
+            return false;
+        }
+        return this.actual.slice(this.actual.length - expected.length, this.actual.length) === expected;
+    };
+
+  /**
+   * @alias
+   * expect(string):toBeLongerThan
+   *
+   * @summary
+   * Assert subject is a String whose length is greater than our other string.
+   *
+   * @param  {String} other
+   * @return {Boolean}
+   */
+    matchers.toBeLongerThan = function(other) {
+        return matchers.toBeString.call(this) && matchers.toBeString.call({
+            actual: other,
+        }) && this.actual.length > other.length;
+    };
+
+  /**
+   * @alias
+   * expect(string):toBeShorterThan
+   *
+   * @summary
+   * Assert subject is a String whose length is greater than our other string.
+   *
+   * @param  {String} other
+   * @return {Boolean}
+   */
+    matchers.toBeShorterThan = function(other) {
+        return matchers.toBeString.call(this) && matchers.toBeString.call({
+            actual: other,
+        }) && this.actual.length < other.length;
+    };
+
+  /**
+   * @alias
+   * expect(string):toBeSameLengthAs
+   *
+   * @summary
+   * Assert subject is a String whose length is equal to our other string.
+   *
+   * @param  {String} other
+   * @return {Boolean}
+   */
+    matchers.toBeSameLengthAs = function(other) {
+        return matchers.toBeString.call(this) && matchers.toBeString.call({
+            actual: other,
+        }) && this.actual.length === other.length;
+    };
+
+  /**
+   * ArrayMembers
+   */
+
+  /**
+   * @alias
+   * expect(object):toHaveArray
+   *
+   * @summary
+   * .
+   *
+   * @description
+   * See {@link http://git.io/jasmine-array-testing|Unit testing Arrays with Jasmine}.
+   *
+   * @param  {String} memberName
+   * @return {Boolean}
+   */
+    matchers.toHaveArray = function(memberName) {
+        return priv.assertMember.call(this, 'toBeArray', memberName);
+    };
+
+  /**
+   * @alias
+   * expect(object):toHaveArrayOfBooleans
+   *
+   * @summary
+   * .
+   *
+   * @description
+   * See {@link http://git.io/jasmine-array-testing|Unit testing Arrays with Jasmine}.
+   *
+   * @param  {String} memberName
+   * @return {Boolean}
+   */
+    matchers.toHaveArrayOfBooleans = function(memberName) {
+        return priv.assertMember.call(this, 'toBeArrayOfBooleans', memberName);
+    };
+
+  /**
+   * @alias
+   * expect(object):toHaveArrayOfNumbers
+   *
+   * @summary
+   * .
+   *
+   * @description
+   * See {@link http://git.io/jasmine-array-testing|Unit testing Arrays with Jasmine}.
+   *
+   * @param  {String} memberName
+   * @return {Boolean}
+   */
+    matchers.toHaveArrayOfNumbers = function(memberName) {
+        return priv.assertMember.call(this, 'toBeArrayOfNumbers', memberName);
+    };
+
+  /**
+   * @alias
+   * expect(object):toHaveArrayOfObjects
+   *
+   * @summary
+   * .
+   *
+   * @description
+   * See {@link http://git.io/jasmine-array-testing|Unit testing Arrays with Jasmine}.
+   *
+   * @param  {String} memberName
+   * @return {Boolean}
+   */
+    matchers.toHaveArrayOfObjects = function(memberName) {
+        return priv.assertMember.call(this, 'toBeArrayOfObjects', memberName);
+    };
+
+  /**
+   * @alias
+   * expect(object):toHaveArrayOfSize
+   *
+   * @summary
+   * .
+   *
+   * @description
+   * See {@link http://git.io/jasmine-array-testing|Unit testing Arrays with Jasmine}.
+   *
+   * @param  {String} memberName
+   * @param  {Number} size
+   * @return {Boolean}
+   */
+    matchers.toHaveArrayOfSize = function(memberName, size) {
+        return priv.assertMember.call(this, 'toBeArrayOfSize', memberName, size);
+    };
+
+  /**
+   * @alias
+   * expect(object):toHaveNonEmptyArray
+   *
+   * @summary
+   * .
+   *
+   * @description
+   * See {@link http://git.io/jasmine-array-testing|Unit testing Arrays with Jasmine}.
+   *
+   * @param  {String} memberName
+   * @return {Boolean}
+   */
+    matchers.toHaveNonEmptyArray = function(memberName) {
+        return priv.assertMember.call(this, 'toBeNonEmptyArray', memberName);
+    };
+
+  /**
+   * @alias
+   * expect(object):toHaveEmptyArray
+   *
+   * @summary
+   * .
+   *
+   * @description
+   * See {@link http://git.io/jasmine-array-testing|Unit testing Arrays with Jasmine}.
+   *
+   * @param  {String} memberName
+   * @return {Boolean}
+   */
+    matchers.toHaveEmptyArray = function(memberName) {
+        return priv.assertMember.call(this, 'toBeEmptyArray', memberName);
+    };
+
+  /**
+   * @alias
+   * expect(object):toHaveArrayOfStrings
+   *
+   * @summary
+   * .
+   *
+   * @description
+   * See {@link http://git.io/jasmine-array-testing|Unit testing Arrays with Jasmine}.
+   *
+   * @param  {String} memberName
+   * @return {Boolean}
+   */
+    matchers.toHaveArrayOfStrings = function(memberName) {
+        return priv.assertMember.call(this, 'toBeArrayOfStrings', memberName);
+    };
+
+  /**
+   * BooleanMembers
+   */
+
+  /**
+   * @alias
+   * expect(object):toHaveBoolean
+   *
+   * @summary
+   * .
+   *
+   * @description
+   * See {@link http://git.io/jasmine-boolean-testing|Unit testing Booleans with Jasmine}.
+   *
+   * @param  {String} memberName
+   * @return {Boolean}
+   */
+    matchers.toHaveBoolean = function(memberName) {
+        return priv.assertMember.call(this, 'toBeBoolean', memberName);
+    };
+
+  /**
+   * @alias
+   * expect(object):toHaveFalse
+   *
+   * @summary
+   * .
+   *
+   * @description
+   * See {@link http://git.io/jasmine-boolean-testing|Unit testing Booleans with Jasmine}.
+   *
+   * @param  {String} memberName
+   * @return {Boolean}
+   */
+    matchers.toHaveFalse = function(memberName) {
+        return priv.assertMember.call(this, 'toBeFalse', memberName);
+    };
+
+  /**
+   * @alias
+   * expect(object):toHaveTrue
+   *
+   * @summary
+   * .
+   *
+   * @description
+   * See {@link http://git.io/jasmine-boolean-testing|Unit testing Booleans with Jasmine}.
+   *
+   * @param  {String} memberName
+   * @return {Boolean}
+   */
+    matchers.toHaveTrue = function(memberName) {
+        return priv.assertMember.call(this, 'toBeTrue', memberName);
+    };
+
+  /**
+   * BrowserMembers
+   */
+
+  /**
+   * @alias
+   * expect(object):toHaveHtmlNode
+   *
+   * @summary
+   * Assert subject is a true Object containing a property at memberName which is an HTML Element.
+   *
+   * @description
+   * See {@link http://git.io/jasmine-browser-testing|Unit testing Browsers with Jasmine}.
+   *
+   * @param {Boolean} memberName
+   * @return {Boolean}
+   */
+    matchers.toHaveHtmlNode = function(memberName) {
+        return priv.assertMember.call(this, 'toBeHtmlNode', memberName);
+    };
+
+  /**
+   * DateMembers
+   */
+
+  /**
+   * @alias
+   * expect(object):toHaveDate
+   *
+   * @summary
+   * .
+   *
+   * @description
+   * See {@link http://git.io/jasmine-date-testing|Unit testing Dates with Jasmine}.
+   *
+   * @param  {String} memberName
+   * @return {Boolean}
+   */
+    matchers.toHaveDate = function(memberName) {
+        return priv.assertMember.call(this, 'toBeDate', memberName);
+    };
+
+  /**
+   * @alias
+   * expect(object):toHaveDateAfter
+   *
+   * @summary
+   * .
+   *
+   * @description
+   * See {@link http://git.io/jasmine-bdate-testing|Unit testing Dates with Jasmine}.
+   *
+   * @param  {String} memberName
+   * @param  {Date} date
+   * @return {Boolean}
+   */
+    matchers.toHaveDateAfter = function(memberName, date) {
+        return priv.assertMember.call(this, 'toBeDateAfter', memberName, date);
+    };
+
+  /**
+   * @alias
+   * expect(object):toHaveDateBefore
+   *
+   * @summary
+   * .
+   *
+   * @description
+   * See {@link http://git.io/jasmine-browser-date|Unit testing Browsers with Dates}.
+   *
+   * @param  {String} memberName
+   * @param  {Date} date
+   * @return {Boolean}
+   */
+    matchers.toHaveDateBefore = function(memberName, date) {
+        return priv.assertMember.call(this, 'toBeDateBefore', memberName, date);
+    };
+
+  /**
+   * @alias
+   * expect(object):toHaveIso8601
+   *
+   * @summary
+   * .
+   *
+   * @description
+   * See {@link http://git.io/jasmine-date-testing|Unit testing Dates with Jasmine}.
+   *
+   * @param  {String} memberName
+   * @return {Boolean}
+   */
+    matchers.toHaveIso8601 = function(memberName) {
+        return priv.assertMember.call(this, 'toBeIso8601', memberName);
+    };
+
+  /**
+   * NumberMembers
+   */
+
+  /**
+   * @alias
+   * expect(object):toHaveNumber
+   *
+   * @summary
+   * .
+   *
+   * @description
+   * See {@link http://git.io/jasmine-number-testing|Unit testing Numbers with Jasmine}.
+   *
+   * @param  {String} memberName
+   * @return {Boolean}
+   */
+    matchers.toHaveNumber = function(memberName) {
+        return priv.assertMember.call(this, 'toBeNumber', memberName);
+    };
+
+  /**
+   * @alias
+   * expect(object):toHaveNumberWithinRange
+   *
+   * @summary
+   * .
+   *
+   * @description
+   * See {@link http://git.io/jasmine-number-testing|Unit testing Numbers with Jasmine}.
+   *
+   * @param  {String} memberName
+   * @param  {Number} floor
+   * @param  {Number} ceiling
+   * @return {Boolean}
+   */
+    matchers.toHaveNumberWithinRange = function(memberName, floor, ceiling) {
+        return priv.assertMember.call(this, 'toBeWithinRange', memberName, floor, ceiling);
+    };
+
+  /**
+   * @alias
+   * expect(object):toHaveCalculable
+   *
+   * @summary
+   * .
+   *
+   * @description
+   * See {@link http://git.io/jasmine-number-testing|Unit testing Numbers with Jasmine}.
+   *
+   * @param  {String} memberName
+   * @return {Boolean}
+   */
+    matchers.toHaveCalculable = function(memberName) {
+        return priv.assertMember.call(this, 'toBeCalculable', memberName);
+    };
+
+  /**
+   * @alias
+   * expect(object):toHaveEvenNumber
+   *
+   * @summary
+   * .
+   *
+   * @description
+   * See {@link http://git.io/jasmine-number-testing|Unit testing Numbers with Jasmine}.
+   *
+   * @param  {String} memberName
+   * @return {Boolean}
+   */
+    matchers.toHaveEvenNumber = function(memberName) {
+        return priv.assertMember.call(this, 'toBeEvenNumber', memberName);
+    };
+
+  /**
+   * @alias
+   * expect(object):toHaveOddNumber
+   *
+   * @summary
+   * .
+   *
+   * @description
+   * See {@link http://git.io/jasmine-number-testing|Unit testing Numbers with Jasmine}.
+   *
+   * @param  {String} memberName
+   * @return {Boolean}
+   */
+    matchers.toHaveOddNumber = function(memberName) {
+        return priv.assertMember.call(this, 'toBeOddNumber', memberName);
+    };
+
+  /**
+   * @alias
+   * expect(object):toHaveWholeNumber
+   *
+   * @summary
+   * .
+   *
+   * @description
+   * See {@link http://git.io/jasmine-number-testing|Unit testing Numbers with Jasmine}.
+   *
+   * @param  {String} memberName
+   * @return {Boolean}
+   */
+    matchers.toHaveWholeNumber = function(memberName) {
+        return priv.assertMember.call(this, 'toBeWholeNumber', memberName);
+    };
+
+  /**
+   * ObjectMembers
+   */
+
+  /**
+   * @alias
+   * expect(object):toHaveMethod
+   *
+   * @summary
+   * Assert subject is a true Object containing a property at memberName which is a Function.
+   *
+   * @description
+   * See {@link http://git.io/jasmine-object-testing|Unit testing Objects with Jasmine}.
+   *
+   * @param {Boolean} memberName
+   * @return {Boolean}
+   */
+    matchers.toHaveMethod = function(memberName) {
+        return priv.assertMember.call(this, 'toBeFunction', memberName);
+    };
+
+  /**
+   * @alias
+   * expect(object):toHaveObject
+   *
+   * @summary
+   * Assert subject is a true Object containing a property at memberName which is a true Object.
+   *
+   * @description
+   * See {@link http://git.io/jasmine-object-testing|Unit testing Objects with Jasmine}.
+   *
+   * @param {Boolean} memberName
+   * @return {Boolean}
+   */
+    matchers.toHaveObject = function(memberName) {
+        return priv.assertMember.call(this, 'toBeObject', memberName);
+    };
+
+  /**
+   * @alias
+   * expect(object):toHaveEmptyObject
+   *
+   * @summary
+   * Assert subject is a true Object containing a property at memberName which is a true Object with
+   * no instance members.
+   *
+   * @description
+   * See {@link http://git.io/jasmine-object-testing|Unit testing Objects with Jasmine}.
+   *
+   * @param {Boolean} memberName
+   * @return {Boolean}
+   */
+    matchers.toHaveEmptyObject = function(memberName) {
+        return priv.assertMember.call(this, 'toBeEmptyObject', memberName);
+    };
+
+  /**
+   * @alias
+   * expect(object):toHaveNonEmptyObject
+   *
+   * @summary
+   * Assert subject is a true Object containing a property at memberName which is a true Object with
+   * at least one instance member.
+   *
+   * @description
+   * See {@link http://git.io/jasmine-object-testing|Unit testing Objects with Jasmine}.
+   *
+   * @param {Boolean} memberName
+   * @return {Boolean}
+   */
+    matchers.toHaveNonEmptyObject = function(memberName) {
+        return priv.assertMember.call(this, 'toBeNonEmptyObject', memberName);
+    };
+
+  /**
+   * @alias
+   * expect(object):toHaveMember
+   *
+   * @summary
+   * Assert subject is a true Object containing a property at memberName which is of any value,
+   * including undefined.
+   *
+   * @description
+   * See {@link http://git.io/jasmine-object-testing|Unit testing Objects with Jasmine}.
+   *
+   * @param {Boolean} memberName
+   * @return {Boolean}
+   */
+    matchers.toHaveMember = function(memberName) {
+        return memberName && priv.is(this.actual, 'Object') && memberName in this.actual;
+    };
+
+  /**
+   * StringMembers
+   */
+
+  /**
+   * @alias
+   * expect(object):toHaveEmptyString
+   *
+   * @summary
+   * .
+   *
+   * @description
+   * See {@link http://git.io/jasmine-string-testing|Unit testing Strings with Jasmine}.
+   *
+   * @param  {String} memberName
+   * @return {Boolean}
+   */
+    matchers.toHaveEmptyString = function(memberName) {
+        return priv.assertMember.call(this, 'toBeEmptyString', memberName);
+    };
+
+  /**
+   * @alias
+   * expect(object):toHaveHtmlString
+   *
+   * @summary
+   * .
+   *
+   * @description
+   * See {@link http://git.io/jasmine-string-testing|Unit testing Strings with Jasmine}.
+   *
+   * @param  {String} memberName
+   * @return {Boolean}
+   */
+    matchers.toHaveHtmlString = function(memberName) {
+        return priv.assertMember.call(this, 'toBeHtmlString', memberName);
+    };
+
+  /**
+   * @alias
+   * expect(object):toHaveJsonString
+   *
+   * @summary
+   * .
+   *
+   * @description
+   * See {@link http://git.io/jasmine-string-testing|Unit testing Strings with Jasmine}.
+   *
+   * @param  {String} memberName
+   * @return {Boolean}
+   */
+    matchers.toHaveJsonString = function(memberName) {
+        return priv.assertMember.call(this, 'toBeJsonString', memberName);
+    };
+
+  /**
+   * @alias
+   * expect(object):toHaveNonEmptyString
+   *
+   * @summary
+   * .
+   *
+   * @description
+   * See {@link http://git.io/jasmine-string-testing|Unit testing Strings with Jasmine}.
+   *
+   * @param  {String} memberName
+   * @return {Boolean}
+   */
+    matchers.toHaveNonEmptyString = function(memberName) {
+        return priv.assertMember.call(this, 'toBeNonEmptyString', memberName);
+    };
+
+  /**
+   * @alias
+   * expect(object):toHaveString
+   *
+   * @summary
+   * .
+   *
+   * @description
+   * See {@link http://git.io/jasmine-string-testing|Unit testing Strings with Jasmine}.
+   *
+   * @param  {String} memberName
+   * @return {Boolean}
+   */
+    matchers.toHaveString = function(memberName) {
+        return priv.assertMember.call(this, 'toBeString', memberName);
+    };
+
+  /**
+   * @alias
+   * expect(object):toHaveStringLongerThan
+   *
+   * @summary
+   * .
+   *
+   * @description
+   * See {@link http://git.io/jasmine-string-testing|Unit testing Strings with Jasmine}.
+   *
+   * @param  {String} memberName
+   * @param  {String} other
+   * @return {Boolean}
+   */
+    matchers.toHaveStringLongerThan = function(memberName, other) {
+        return priv.assertMember.call(this, 'toBeLongerThan', memberName, other);
+    };
+
+  /**
+   * @alias
+   * expect(object):toHaveStringSameLengthAs
+   *
+   * @summary
+   * .
+   *
+   * @description
+   * See {@link http://git.io/jasmine-string-testing|Unit testing Strings with Jasmine}.
+   *
+   * @param  {String} memberName
+   * @param  {String} other
+   * @return {Boolean}
+   */
+    matchers.toHaveStringSameLengthAs = function(memberName, other) {
+        return priv.assertMember.call(this, 'toBeSameLengthAs', memberName, other);
+    };
+
+  /**
+   * @alias
+   * expect(object):toHaveStringShorterThan
+   *
+   * @summary
+   * .
+   *
+   * @description
+   * See {@link http://git.io/jasmine-string-testing|Unit testing Strings with Jasmine}.
+   *
+   * @param  {String} memberName
+   * @param  {String} other
+   * @return {Boolean}
+   */
+    matchers.toHaveStringShorterThan = function(memberName, other) {
+        return priv.assertMember.call(this, 'toBeShorterThan', memberName, other);
+    };
+
+  /**
+   * @alias
+   * expect(object):toHaveWhitespaceString
+   *
+   * @summary
+   * .
+   *
+   * @description
+   * See {@link http://git.io/jasmine-string-testing|Unit testing Strings with Jasmine}.
+   *
+   * @param  {String} memberName
+   * @return {Boolean}
+   */
+    matchers.toHaveWhitespaceString = function(memberName) {
+        return priv.assertMember.call(this, 'toBeWhitespace', memberName);
+    };
+
+  // Create adapters for the original matchers so they can be compatible with Jasmine 2.0.
+    const matchersV2 = priv.adaptMatchers(matchers);
+
+    beforeEach(function() {
+        if ('function' === typeof this.addMatchers) {
+            this.addMatchers(matchers);
+        } else if ('function' === typeof jasmine.addMatchers) {
+            jasmine.addMatchers(matchersV2);
+        }
+    });
+}());