UNPKG

@danielkalen/simplybind/test/spec.coffee

Version:
175 kBtext/coffeescriptView Raw
1if mocha? and window?
isBrowser = true
mocha.setup('tdd')
mocha.bail() unless @isSauceLabsTest or location.hostname
5else
isBrowser = false
global.window = global
chai = require 'chai'
chaiSpies = require 'chai-spies'
SimplyBind = require '../dist/simplybind.node.js'
startSandbox = require('./spec-helper.js').startSandbox
restartSandbox = require('./spec-helper.js').restartSandbox
chai.use chaiSpies
14
15expect = chai.expect
16should = chai.should()
17
18
19
20suite "SimplyBind", ()->
suiteSetup(startSandbox)

suite "Options", ()->
test "SimplyBind.options should contain the global options list", ()->
	options = SimplyBind.options
	expect(options.silent).not.to.be.undefined
	expect(options.liveProps).not.to.be.undefined
	expect(options.dispatchEvents).not.to.be.undefined
	expect(options.updateEvenIfSame).not.to.be.undefined
	expect(options.updateOnBind).not.to.be.undefined
	expect(options.mutateInherited).not.to.be.undefined
	expect(options.trackArrayChildren).not.to.be.undefined
	expect(options.simpleSelector).not.to.be.undefined
	expect(options.promiseTransforms).not.to.be.undefined
	expect(options.placeholder).not.to.be.undefined
36
37
38
test "SimplyBind.options should return a non-editable copy of the global options list", ()->
	expect(SimplyBind.options.dispatchEvents).to.be.false
	SimplyBind.options.dispatchEvents = true
	expect(SimplyBind.options.dispatchEvents).to.be.false
43
44
45
test "SimplyBind.setOption() should set a new value for a single option", ()->
	expect(SimplyBind.options.silent).to.equal false
	SimplyBind.setOption 'silent', true
	expect(SimplyBind.options.silent).to.equal true
	SimplyBind.setOption 'silent', false
51
52
53
54
test "SimplyBind.setOptions() should set new values for a all the options passed", ()->
	expect(SimplyBind.options.silent).to.equal false
	expect(SimplyBind.options.liveProps).to.equal true
	
	SimplyBind.setOptions
		'silent': true
		'liveProps': false
	
	expect(SimplyBind.options.silent).to.equal true
	expect(SimplyBind.options.liveProps).to.equal false
	
	SimplyBind.setOptions
		'silent': false
		'liveProps': true
	SimplyBind.setOptions {}
	
	expect(SimplyBind.options.silent).to.equal false
	expect(SimplyBind.options.liveProps).to.equal true
73
74
75
test "SimplyBind.setOptions() should not add non-registered options", ()->
	SimplyBind.setOptions
		placeholder: ['{{', '}}']
		youtube: 'yea!'
	
	expect(SimplyBind.options.placeholder[0]).to.equal '{{'
	expect(SimplyBind.options.placeholder[1]).to.equal '}}'
	expect(SimplyBind.options.youtube).to.be.undefined
84
85
86
test "<bound instance>.setOption should update a registered option only for the instance", ()->
	SimplyBind.setOption 'updateOnBind', false
	expect(SimplyBind.options.updateOnBind).to.be.false
90
	binding = SimplyBind('prop1').of(objectA)
	expect(binding._.options.updateOnBind).to.be.false
93
	binding.setOption 'updateOnBind', true
	expect(binding._.options.updateOnBind).to.be.true
	expect(SimplyBind.options.updateOnBind).to.be.false
97
	SimplyBind.setOption 'updateOnBind', true
	restartSandbox()
100
101
102
test "Creating a new binding interface for a cached binding without passing an options object shouldn't overwrite existing options", ()->
	SimplyBind.setOption 'updateOnBind', false
	expect(SimplyBind.options.updateOnBind).to.be.false
106
	binding = SimplyBind('prop1').of(objectA)
	expect(binding._.options.updateOnBind).to.be.false
109
	binding.setOption 'updateOnBind', true
	expect(SimplyBind('prop1').of(objectA)._.options.updateOnBind).to.be.true
	expect(SimplyBind.options.updateOnBind).to.be.false
113
	SimplyBind.setOption 'updateOnBind', true
	restartSandbox()
116
117
118
test "<bound instance>.setOption should update a registered option only for the instance", ()->
	binding = SimplyBind('prop1').of(objectA)
121
	binding.setOption 'placeholder', ['{{', '}}']
	binding.setOption 'youtube', 'yea'
	
	expect(binding._.options.placeholder[0]).to.equal '{{'
	expect(binding._.options.placeholder[1]).to.equal '}}'
	expect(binding._.options.youtube).to.be.undefined
128
	restartSandbox()
130
131
132
test "Passing an options object as the 2nd param of .of() should update registered options only for the instance", ()->
	SimplyBind.setOption 'updateOnBind', false
	expect(SimplyBind.options.updateOnBind).to.be.false
136
	binding = SimplyBind('prop1', {'updateOnBind':true}).of(objectA)
	expect(binding._.options.updateOnBind).to.be.true
	expect(SimplyBind.options.updateOnBind).to.be.false
	
	SimplyBind.setOption 'updateOnBind', true
	restartSandbox()
143
144
145
test "Passing an options object as the 2nd param of .of() should update the options even for an existing binding instance", ()->
	SimplyBind.setOption 'updateOnBind', false
	expect(SimplyBind.options.updateOnBind).to.be.false
149
	binding = SimplyBind('prop1').of(objectA)
	expect(binding._.options.updateOnBind).to.be.false
152
	binding = SimplyBind('prop1', {'updateOnBind':true, 'nonexistent':true}).of(objectA)
	expect(binding._.options.updateOnBind).to.be.true
	expect(binding._.options.nonexistent).to.be.undefined
	expect(SimplyBind.options.updateOnBind).to.be.false
157
	SimplyBind.setOption 'updateOnBind', true
	restartSandbox()
160
161
162
test "Passing an options object as the 2nd param of .of() for an existing binding should invoke the required methods for these options", ()->
	SimplyBind.setOption 'liveProps', false
	SimplyBind.setOption 'updateOnBind', false
	SimplyBind.setOption 'mutateInherited', false
	SimplyBind.setOption 'trackArrayChildren', false
	Object::id = ''
169
	arrayInvokeCount = 0
	newOptions = {'liveProps':true, 'mutateInherited':true, 'trackArrayChildren':true}
	bindings = 
		'liveProps': SimplyBind('prop1').of(objectA)
		'mutateInherited': SimplyBind('id').of(objectB)
		'trackArrayChildren': SimplyBind(arrayA).to ()-> arrayInvokeCount++
	
	objectA.prop1 = '1'
	expect(bindings.liveProps.value).not.to.equal '1'
179
	objectB.id = '1'
	expect(bindings.mutateInherited.value).not.to.equal '1'
182
	arrayA[3] = '1'
	expect(arrayInvokeCount).to.equal 0
185
186
187
	SimplyBind.setOption 'liveProps', true
	SimplyBind.setOption 'updateOnBind', true
190
	SimplyBind('prop1', newOptions).of(objectA)
	SimplyBind('id', newOptions).of(objectB)
	SimplyBind(arrayA, newOptions)
	
	objectA.prop1 = '2'
	expect(bindings.liveProps.value).to.equal '2'
197
	objectB.id = '2'
	expect(bindings.mutateInherited.value).to.equal '2'
200
	arrayA[5] = '2'
	expect(arrayInvokeCount).to.equal 1
203
	delete Object::id
	restartSandbox()
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
suite "Argument Values", ()->
suiteSetup(restartSandbox)
226
suite "SimplyBind() function", ()->
	test "Can only accept an object type of String, Number, Array, Function, or an existing binding instance", ()->
		expect ()-> SimplyBind('s')
			.not.to.throw()
		
		expect ()-> SimplyBind(0)
			.not.to.throw()
		
		expect ()-> SimplyBind([])
			.not.to.throw()
		
		expect ()-> SimplyBind(()->)
			.not.to.throw()
		
		expect ()-> SimplyBind(SimplyBind('prop1').of(objectA))
			.not.to.throw()
		
		expect ()-> SimplyBind(true)
			.to.throw()
		
		expect ()-> SimplyBind(null)
			.to.throw()
		
		expect ()-> SimplyBind(undefined)
			.to.throw()
		
		expect ()-> SimplyBind({})
			.to.throw()
		
		expect ()-> SimplyBind(new Date())
			.to.throw()
		
		if isBrowser
			expect ()-> SimplyBind($('<div />')[0])
				.to.throw()
		
		if window.Map and window.Set and window.Symbol
			expect ()-> SimplyBind(new Map())
				.to.throw()
			
			expect ()-> SimplyBind(new WeakMap())
				.to.throw()
			
			expect ()-> SimplyBind(new Set())
				.to.throw()
			
			expect ()-> SimplyBind(new WeakSet())
				.to.throw()
		
			expect ()-> SimplyBind(Symbol('a'))
				.to.throw()
278
279
280
	test "Should throw when passing an empty string", ()->
		expect ()-> SimplyBind('')
			.to.throw()
284
285
286
suite ".of() method", ()->
	test "Can only accept non-primitive objects", ()->
		expect ()-> SimplyBind(0).of([])
			.not.to.throw()
						
		expect ()-> SimplyBind(0).of(()->)
			.not.to.throw()
		
		expect ()-> SimplyBind(0).of({})
			.not.to.throw()
		
		expect ()-> SimplyBind(0).of(new Date())
			.not.to.throw()
		
		if isBrowser
			expect ()-> SimplyBind(0).of($('<div />')[0])
				.not.to.throw()
		
		if window.Map and window.Set and window.Symbol
			expect ()-> SimplyBind(0).of(new Map())
				.not.to.throw()
			
			expect ()-> SimplyBind(0).of(new WeakMap())
				.not.to.throw()
			
			expect ()-> SimplyBind(0).of(new Set())
				.not.to.throw()
			
			expect ()-> SimplyBind(0).of(new WeakSet())
				.not.to.throw()
		
			expect ()-> SimplyBind(0).of(Symbol(0))
				.to.throw()
		
		expect ()-> SimplyBind(0).of(SimplyBind('prop1').of(objectA))
			.not.to.throw()
323
		expect ()-> SimplyBind(0).of('s')
			.to.throw()
		
		expect ()-> SimplyBind(0).of(0)
			.to.throw()
		
		expect ()-> SimplyBind(0).of(true)
			.to.throw()
		
		expect ()-> SimplyBind(0).of(null)
			.to.throw()
		
		expect ()-> SimplyBind(0).of(undefined)
			.to.throw()

339
340
341
	test "Will extract and use the subject bound object from the instance if passed a binding instance", ()->
		bound = SimplyBind('prop3').of(objectA).to('prop3').of(objectB)
		
		bound.set 'standard'
		expect(objectA.prop3).to.equal 'standard'
		expect(objectB.prop3).to.equal 'standard'
		
		bound2 = SimplyBind('prop4').of(bound).to('prop4').of(objectB)
		
		bound2.set 'ofBounded'
		expect(objectA.prop4).to.equal 'ofBounded'
		expect(objectB.prop4).to.equal 'ofBounded'
354
355
356
suite ".ofEvent() method", ()->
	test "Can only accept string values", ()->
		expect ()-> SimplyBind(0).ofEvent('s')
			.not.to.throw()
		
		expect ()-> SimplyBind(0).of(objectA).toEvent('s')
			.not.to.throw()
364
		expect ()-> SimplyBind(0).ofEvent([])
			.to.throw()
						
		expect ()-> SimplyBind(0).ofEvent(()->)
			.to.throw()
		
		expect ()-> SimplyBind(0).ofEvent({})
			.to.throw()
		
		expect ()-> SimplyBind(0).ofEvent(new Date())
			.to.throw()
		
		if isBrowser
			expect ()-> SimplyBind(0).ofEvent($('<div />')[0])
				.to.throw()
		
		if window.Map and window.Set and window.Symbol
			expect ()-> SimplyBind(0).ofEvent(new Map())
				.to.throw()
			
			expect ()-> SimplyBind(0).ofEvent(new WeakMap())
				.to.throw()
			
			expect ()-> SimplyBind(0).ofEvent(new Set())
				.to.throw()
			
			expect ()-> SimplyBind(0).ofEvent(new WeakSet())
				.to.throw()
		
			expect ()-> SimplyBind(0).ofEvent(Symbol(0))
				.to.throw()
		
		expect ()-> SimplyBind(0).ofEvent(SimplyBind(0).ofEvent('s'))
			.to.throw()
		
		expect ()-> SimplyBind(0).ofEvent(0)
			.to.throw()
		
		expect ()-> SimplyBind(0).ofEvent(true)
			.to.throw()
		
		expect ()-> SimplyBind(0).ofEvent(null)
			.to.throw()
		
		expect ()-> SimplyBind(0).ofEvent(undefined)
			.to.throw()
411
412
413
suite ".transform/condition/All/Self() methods", ()->
	test "Can only accept function values", ()->
		window.origLog = console.warn
		console.warn = chai.spy()
		timesCalled = 0
419
		SimplyBind(0).of({}).to(()->).transform(()->)
		expect(console.warn).to.have.been.called.exactly(timesCalled += 0)
422
		SimplyBind(0).of({}).to(()->).transformAll(()->)
		expect(console.warn).to.have.been.called.exactly(timesCalled += 0)
						
		SimplyBind(0).of({}).to(()->).condition(()->)
		expect(console.warn).to.have.been.called.exactly(timesCalled += 0)
						
		SimplyBind(0).of({}).to(()->).conditionAll(()->)
		expect(console.warn).to.have.been.called.exactly(timesCalled += 0)
						
		SimplyBind(0).of({}).transformSelf(()->)
		expect(console.warn).to.have.been.called.exactly(timesCalled += 0)
		
		SimplyBind(0).of({}).to(()->).transform([])
		expect(console.warn).to.have.been.called.exactly(timesCalled += 1)
437
		SimplyBind(0).of({}).to(()->).transformAll({})
		expect(console.warn).to.have.been.called.exactly(timesCalled += 1)
		
		SimplyBind(0).of({}).to(()->).conditionAll(new Date())
		expect(console.warn).to.have.been.called.exactly(timesCalled += 1)
		
		if isBrowser
			SimplyBind(0).of({}).to(()->).condition($('<div />')[0])
			expect(console.warn).to.have.been.called.exactly(timesCalled += 1)
		
		if window.Map and window.Set and window.Symbol
			SimplyBind(0).of({}).to(()->).transform(new Map())
			expect(console.warn).to.have.been.called.exactly(timesCalled += 1)
			
			SimplyBind(0).of({}).to(()->).transformAll(new WeakMap())
			expect(console.warn).to.have.been.called.exactly(timesCalled += 1)
			
			SimplyBind(0).of({}).to(()->).condition(new Set())
			expect(console.warn).to.have.been.called.exactly(timesCalled += 1)
			
			SimplyBind(0).of({}).to(()->).conditionAll(new WeakSet())
			expect(console.warn).to.have.been.called.exactly(timesCalled += 1)
		
			SimplyBind(0).of({}).transformSelf(Symbol(0))
			expect(console.warn).to.have.been.called.exactly(timesCalled += 1)
		
		SimplyBind(0).of({}).to(()->).transform(SimplyBind('prop1').of(objectA))
		expect(console.warn).to.have.been.called.exactly(timesCalled += 1)
466
		SimplyBind(0).of({}).to(()->).transformAll('s')
		expect(console.warn).to.have.been.called.exactly(timesCalled += 1)
		
		SimplyBind(0).of({}).to(()->).condition(0)
		expect(console.warn).to.have.been.called.exactly(timesCalled += 1)
		
		SimplyBind(0).of({}).to(()->).conditionAll(true)
		expect(console.warn).to.have.been.called.exactly(timesCalled += 1)
		
		SimplyBind(0).of({}).transformSelf(null)
		expect(console.warn).to.have.been.called.exactly(timesCalled += 1)
		
		SimplyBind(0).of({}).transformSelf(undefined)
		expect(console.warn).to.have.been.called.exactly(timesCalled += 1)
481
		console.warn = origLog
483
484
485
suite ".throttle()", ()->
	test "Will only accept a truthy number-type argument or a boolean false", ()->
		binding = SimplyBind('prop').of(objectA)._
		expect(binding.throttleRate or binding.thR).to.be.undefined
490
		SimplyBind('prop').of(objectA).throttle(200)
		expect(binding.throttleRate or binding.thR).to.equal 200
493
		SimplyBind('prop').of(objectA).throttle(false)
		expect(binding.throttleRate or binding.thR).to.equal.undefined
496
		SimplyBind('prop').of(objectA).throttle(0)
		expect(binding.throttleRate or binding.thR).to.equal.undefined
499
		SimplyBind('prop').of(objectA).throttle('0')
		expect(binding.throttleRate or binding.thR).to.equal.undefined
502
		SimplyBind('prop').of(objectA).throttle(NaN)
		expect(binding.throttleRate or binding.thR).to.equal.undefined
505
		SimplyBind('prop').of(objectA).throttle({})
		expect(binding.throttleRate or binding.thR).to.equal.undefined
508
		SimplyBind('prop').of(objectA).throttle([])
		expect(binding.throttleRate or binding.thR).to.equal.undefined
511
		SimplyBind('prop').of(objectA).throttle(()->)
		expect(binding.throttleRate or binding.thR).to.equal.undefined
514
		if window.Map and window.Set and window.Symbol
			SimplyBind('prop').of(objectA).throttle(new Map())
			expect(binding.throttleRate or binding.thR).to.equal.undefined
			
			SimplyBind('prop').of(objectA).throttle(new WeakMap())
			expect(binding.throttleRate or binding.thR).to.equal.undefined
			
			SimplyBind('prop').of(objectA).throttle(new Set())
			expect(binding.throttleRate or binding.thR).to.equal.undefined
			
			SimplyBind('prop').of(objectA).throttle(new WeakSet())
			expect(binding.throttleRate or binding.thR).to.equal.undefined
527
			SimplyBind('prop').of(objectA).throttle(Symbol(9))
			expect(binding.throttleRate or binding.thR).to.equal.undefined
530
531
		restartSandbox()
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
suite "Errors & Warnings", ()->
suiteSetup(restartSandbox)
553
test "Warning when binding a property of a jQuery object containing multiple els", ()-> if not isBrowser then @skip() else
	window.origLog = console.warn
	console.warn = chai.spy()
	
	SimplyBind('value').of $('input')
	expect(console.warn).to.have.been.called()
560
	console.warn = origLog
562
563
test "Warning when binding a property of a jQuery/NodeList/HTMLCollection object containing zero els", ()-> if not isBrowser then @skip() else
	expect ()-> SimplyBind('value').of $('nonexistent')
		.to.throw()
	
	expect ()-> SimplyBind('value').of document.querySelectorAll('nonexistent')
		.to.throw()
	
	expect ()-> SimplyBind('value').of document.getElementsByTagName('nonexistent')
		.to.throw()
573
574
test "Warning when binding a property of a jQuery object containing zero els", ()-> if not isBrowser then @skip() else
	expect ()-> SimplyBind('value').of $('input[type="nonexistent"]')
		.to.throw()
578
579
test "Warning when binding a property of a NodeList/HTMLCollection containing multiple els", ()-> if not isBrowser then @skip() else
	origLog = console.warn
	console.warn = chai.spy()
	
	SimplyBind('value').of document.querySelectorAll('input')
	expect(console.warn).to.have.been.called()
	
	console.warn = origLog
588

test "No Warning when binding 'checked' of a jQuery object containing multiple radio/checkbox inputs", ()-> if not isBrowser then @skip() else
	origLog = console.warn
	console.warn = chai.spy()
	
	SimplyBind('checked').of $radioFields
	expect(console.warn).not.to.have.been.called()
	
	SimplyBind('value').of $radioFields
	expect(console.warn).to.have.been.called.exactly(1)
599
	console.warn = origLog
601

test "No Warning when binding 'checked' of a NodeList/HTMLCollection/Array containing multiple radio/checkbox inputs", ()-> if not isBrowser then @skip() else
	origLog = console.warn
	console.warn = chai.spy()
	
	SimplyBind('checked').of $radioFields.toArray()
	expect(console.warn).not.to.have.been.called()
	
	SimplyBind('checked').of radioFields
	expect(console.warn).not.to.have.been.called()
	
	SimplyBind('value').of $radioFields.toArray()
	SimplyBind('value').of radioFields
	expect(console.warn).to.have.been.called.exactly(2)
616
	console.warn = origLog
618

test "Warning when binding a property of a NodeList/HTMLCollection/Array/jQuery containing elements with mixed types", ()-> if not isBrowser then @skip() else
	origLog = console.warn
	console.warn = chai.spy()
	
	SimplyBind('checked').of $radioFields.add($checkboxFields).toArray()
	expect(console.warn).to.have.been.called.exactly(1)
	
	SimplyBind('checked').of $radioFields.add($checkboxFields)
	expect(console.warn).to.have.been.called.exactly(2)
	
	SimplyBind('checked').of document.querySelectorAll 'input'
	expect(console.warn).to.have.been.called.exactly(3)
	
	console.warn = origLog
634
635
test "Warning when creating a binding and passing a non-function object to .transform/.condition/All", ()->
	binding = SimplyBind('prop1').of(objectA).to('prop1').of(objectB)
	origLog = console.warn
	console.warn = chai.spy()
	timesCalled = 0

	binding.transform []
	expect(console.warn).to.have.been.called.exactly(timesCalled += 1)

	binding.transformAll []
	expect(console.warn).to.have.been.called.exactly(timesCalled += 1)

	binding.transform {}
	expect(console.warn).to.have.been.called.exactly(timesCalled += 1)

	binding.transform new Date()
	expect(console.warn).to.have.been.called.exactly(timesCalled += 1)

	if isBrowser
		binding.transform $('<div />')[0]
		expect(console.warn).to.have.been.called.exactly(timesCalled += 1)

	if window.Map and window.Set and window.Symbol
		binding.transform new Map()
		expect(console.warn).to.have.been.called.exactly(timesCalled += 1)
	
		binding.transform new WeakMap()
		expect(console.warn).to.have.been.called.exactly(timesCalled += 1)
	
		binding.transform new Set()
		expect(console.warn).to.have.been.called.exactly(timesCalled += 1)
	
		binding.transform new WeakSet()
		expect(console.warn).to.have.been.called.exactly(timesCalled += 1)

		binding.transform Symbol(0)
		expect(console.warn).to.have.been.called.exactly(timesCalled += 1)

	binding.transform 's'
	expect(console.warn).to.have.been.called.exactly(timesCalled += 1)

	binding.transform 0
	expect(console.warn).to.have.been.called.exactly(timesCalled += 1)

	binding.transform true
	expect(console.warn).to.have.been.called.exactly(timesCalled += 1)

	binding.transform null
	expect(console.warn).to.have.been.called.exactly(timesCalled += 1)

	binding.transform undefined
	expect(console.warn).to.have.been.called.exactly(timesCalled += 1)
688
	binding.condition []
	expect(console.warn).to.have.been.called.exactly(timesCalled += 1)

	binding.conditionAll []
	expect(console.warn).to.have.been.called.exactly(timesCalled += 1)


	console.warn = origLog
	restartSandbox()
698
699
test "Warning when passed a non-number argument selector to an event binding", ()->
	origLog = console.warn
	console.warn = chai.spy()
	
	SimplyBind('value').ofEvent 'someEvent'
	SimplyBind('15').ofEvent 'someEvent'
	SimplyBind(' 1aos95').ofEvent 'someEvent'
	
	expect(console.warn).to.have.been.called.exactly(1)
	console.warn = origLog
	
711
712
test "No warnings should be thrown when SimplyBind.options.silent is on", ()->
	SimplyBind.setOption 'silent', true
	
	origLog = console.warn
	console.warn = chai.spy()
	
	SimplyBind('value').ofEvent('someEvent')
	SimplyBind('prop3').of(objectA).to('prop3').of(objectB).transform []
	
	expect(console.warn).not.to.have.been.called()
	
	console.warn = origLog
	SimplyBind.setOption 'silent', false
726
727
test "Errors should still be thrown when SimplyBind.options.silent is on", ()->
	SimplyBind.setOption 'silent', true
	
	expect ()-> SimplyBind ''
		.to.throw()
733
	SimplyBind.setOption 'silent', false
735
736
test "No errors should be thrown when scanning for placeholders on a non-string object", ()->
	dispatcher = 'prop':'value'
	receiver = 'prop':null
	expect(()->
		SimplyBind('prop').of(dispatcher)
			.to('prop.placeholder').of(receiver)
	).not.to.throw()
744
	expect(receiver.prop).not.to.equal('value')
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
suite "Internal Behavior", ()->
suiteSetup(restartSandbox)
766
767
768
769
test "A binding should have the correct public properies available", ()->
	binding = SimplyBind('prop1').of(objectA).to('prop2').of(objectB)
	expect(binding.ID).not.to.be.undefined
	expect(binding.value).not.to.be.undefined
	expect(binding.original).not.to.be.undefined
	expect(binding.dependents).not.to.be.undefined
	expect(binding._).not.to.be.undefined
	restartSandbox()
778
779
780
781
test "Bindings to a nonexistent object prop should not create instantiate the object prop at first", ()->
	expect(objectA.prop20).to.be.undefined
	expect(objectB.prop20).to.be.undefined
	
	binding = SimplyBind('prop20').of(objectA).to('prop20').of(objectB)
	expect(objectA.prop20).to.be.undefined
	expect(objectB.prop20).to.be.undefined
	
	binding.set 'new value'
	expect(objectA.prop20).to.equal 'new value'
	expect(objectB.prop20).to.equal 'new value'
	restartSandbox()
794
795
796
797
test "The binding.value property and binding.get() method should return the same value", ()->
	tempObject = 
		'a': 'with'
		'b': 'text {{verb}} a placeholder'

	SimplyBind('a').of(tempObject).to('b.verb').of tempObject

805
	bound = SimplyBind('b.verb').of(tempObject)
	expect(tempObject.b).to.equal 'text with a placeholder'
	expect(bound.value).to.equal 'text with a placeholder'
	expect(bound.get()).to.equal 'with'
	
811
	tempObject.a = 'without'
	expect(tempObject.b).to.equal 'text without a placeholder'
	expect(bound.value).to.equal 'text without a placeholder'
	expect(bound.get()).to.equal 'without'
816
817
818
819
suite "Method availablity in different stages", ()->
	test "Stage 0 (Selection Stage)", ()->
		binding = ()-> SimplyBind('1')
		expect(()-> binding().of objectA).not.to.throw()
		expect(()-> binding().ofEvent objectA).to.throw()
		expect(()-> binding().to 'prop2').to.throw()
		expect(()-> binding().toEvent '/local').to.throw()
		expect(()-> binding().and 'prop2').to.throw()
		expect(()-> binding().set 'value').to.throw()
		expect(()-> binding().get()).to.throw()
		expect(()-> binding().transform ()->).to.throw()
		expect(()-> binding().transformAll ()->).to.throw()
		expect(()-> binding().transformSelf ()->).to.throw()
		expect(()-> binding().condition ()->).to.throw()
		expect(()-> binding().conditionAll ()->).to.throw()
		expect(()-> binding().bothWays()).to.throw()
		expect(()-> binding().stopPolling()).to.throw()
		expect(()-> binding().pollEvery(1000).stopPolling()).to.throw()
		expect(()-> binding().unBind()).to.throw()
		expect(()-> binding().chainTo ()->).to.throw()
		expect(()-> binding().updateDepsOnEvent 'a').to.throw()
		expect(()-> binding().removeEvent 'a').to.throw()
		expect(()-> binding().throttle 5).to.throw()
843
		binding = ()-> SimplyBind('1').ofEvent 'click'
		expect(()-> binding().of objectA).not.to.throw()
		expect(()-> binding().ofEvent objectA).to.throw()
		expect(()-> binding().to 'prop2').to.throw()
		expect(()-> binding().toEvent '/local').to.throw()
		expect(()-> binding().and 'prop2').to.throw()
		expect(()-> binding().set 'value').to.throw()
		expect(()-> binding().get()).to.throw()
		expect(()-> binding().transform ()->).to.throw()
		expect(()-> binding().transformAll ()->).to.throw()
		expect(()-> binding().transformSelf ()->).to.throw()
		expect(()-> binding().condition ()->).to.throw()
		expect(()-> binding().conditionAll ()->).to.throw()
		expect(()-> binding().bothWays()).to.throw()
		expect(()-> binding().stopPolling()).to.throw()
		expect(()-> binding().pollEvery(1000).stopPolling()).to.throw()
		expect(()-> binding().unBind()).to.throw()
		expect(()-> binding().chainTo ()->).to.throw()
		expect(()-> binding().updateDepsOnEvent 'a').to.throw()
		expect(()-> binding().removeEvent 'a').to.throw()
		expect(()-> binding().throttle 5).to.throw()
865
866
867
868
		
	test "Stage 1 (Indication Stage)", ()->
		binding = ()-> SimplyBind('1').of objectA
		expect(()-> binding().of objectA).to.throw()
		expect(()-> binding().ofEvent objectA).to.throw()
		expect(()-> binding().to 'prop2').not.to.throw()
		expect(()-> binding().toEvent '/local').not.to.throw()
		expect(()-> binding().and 'prop2').to.throw()
		expect(()-> binding().set 'value').not.to.throw()
		expect(()-> binding().get()).not.to.throw()
		expect(()-> binding().transform ()->).to.throw()
		expect(()-> binding().transformAll ()->).to.throw()
		expect(()-> binding().transformSelf ()->).not.to.throw()
		expect(()-> binding().condition ()->).to.throw()
		expect(()-> binding().conditionAll ()->).to.throw()
		expect(()-> binding().bothWays()).to.throw()
		expect(()-> binding().stopPolling()).to.throw()
		expect(()-> binding().pollEvery(1000).stopPolling()).to.throw()
		expect(()-> binding().unBind()).to.throw()
		expect(()-> binding().chainTo ()->).to.throw()
		expect(()-> binding().updateDepsOnEvent 'a').to.throw()
		expect(()-> binding().removeEvent 'a').to.throw()
		expect(()-> binding().throttle 5).not.to.throw()
892
		binding = ()-> SimplyBind('1').ofEvent('click').of eventEmitterA
		expect(()-> binding().of objectA).to.throw()
		expect(()-> binding().ofEvent objectA).to.throw()
		expect(()-> binding().to 'prop2').not.to.throw()
		expect(()-> binding().toEvent '/local').not.to.throw()
		expect(()-> binding().and 'prop2').to.throw()
		expect(()-> binding().set 'value').not.to.throw()
		expect(()-> binding().get()).not.to.throw()
		expect(()-> binding().transform ()->).to.throw()
		expect(()-> binding().transformAll ()->).to.throw()
		expect(()-> binding().transformSelf ()->).not.to.throw()
		expect(()-> binding().condition ()->).to.throw()
		expect(()-> binding().conditionAll ()->).to.throw()
		expect(()-> binding().bothWays()).to.throw()
		expect(()-> binding().stopPolling()).to.throw()
		expect(()-> binding().pollEvery(1000).stopPolling()).to.throw()
		expect(()-> binding().unBind()).to.throw()
		expect(()-> binding().chainTo ()->).to.throw()
		expect(()-> binding().updateDepsOnEvent 'a').to.throw()
		expect(()-> binding().removeEvent 'a').to.throw()
		expect(()-> binding().throttle 5).not.to.throw()
914
		
916
917
918
	test "Stage 2 (Binding Selection Stage)", ()->
		binding = ()-> SimplyBind('1').of(objectA).to 'prop1'
		expect(()-> binding().of objectA).not.to.throw()
		expect(()-> binding().ofEvent objectA).to.throw()
		expect(()-> binding().to 'prop2').to.throw()
		expect(()-> binding().toEvent '/local').to.throw()
		expect(()-> binding().and 'prop2').to.throw()
		expect(()-> binding().set 'value').to.throw()
		expect(()-> binding().get()).to.throw()
		expect(()-> binding().transform ()->).to.throw()
		expect(()-> binding().transformAll ()->).to.throw()
		expect(()-> binding().transformSelf ()->).to.throw()
		expect(()-> binding().condition ()->).to.throw()
		expect(()-> binding().conditionAll ()->).to.throw()
		expect(()-> binding().bothWays()).to.throw()
		expect(()-> binding().stopPolling()).to.throw()
		expect(()-> binding().pollEvery(1000).stopPolling()).to.throw()
		expect(()-> binding().unBind()).to.throw()
		expect(()-> binding().chainTo ()->).to.throw()
		expect(()-> binding().updateDepsOnEvent 'a').to.throw()
		expect(()-> binding().removeEvent 'a').to.throw()
		expect(()-> binding().throttle 5).to.throw()
941
942
		binding = ()-> SimplyBind('1').of(objectA).to('prop:prop1').of(objectB).and 'prop2'
		expect(()-> binding().of objectA).not.to.throw()
		expect(()-> binding().ofEvent objectA).to.throw()
		expect(()-> binding().to 'prop2').to.throw()
		expect(()-> binding().toEvent '/local').to.throw()
		expect(()-> binding().and 'prop2').to.throw()
		expect(()-> binding().set 'value').to.throw()
		expect(()-> binding().get()).to.throw()
		expect(()-> binding().transform ()->).to.throw()
		expect(()-> binding().transformAll ()->).to.throw()
		expect(()-> binding().transformSelf ()->).to.throw()
		expect(()-> binding().condition ()->).to.throw()
		expect(()-> binding().conditionAll ()->).to.throw()
		expect(()-> binding().bothWays()).to.throw()
		expect(()-> binding().stopPolling()).to.throw()
		expect(()-> binding().pollEvery(1000).stopPolling()).to.throw()
		expect(()-> binding().unBind()).to.throw()
		expect(()-> binding().chainTo ()->).to.throw()
		expect(()-> binding().updateDepsOnEvent 'a').to.throw()
		expect(()-> binding().removeEvent 'a').to.throw()
		expect(()-> binding().throttle 5).to.throw()
964
		
966
967
968
	test "Stage 3 (Binding Complete Stage)", ()->
		binding = ()-> SimplyBind('1').of(objectA).to('prop1').of objectB
		expect(()-> binding().of objectA).to.throw()
		expect(()-> binding().ofEvent objectA).to.throw()
		expect(()-> binding().to 'prop2').to.throw()
		expect(()-> binding().toEvent '/local').to.throw()
		expect(()-> binding().and 'prop2').not.to.throw()
		expect(()-> binding().set 'value').not.to.throw()
		expect(()-> binding().get()).not.to.throw()
		expect(()-> binding().transform ()->).not.to.throw()
		expect(()-> binding().transformAll ()->).not.to.throw()
		expect(()-> binding().transformSelf ()->).to.throw()
		expect(()-> binding().condition ()->).not.to.throw()
		expect(()-> binding().conditionAll ()->).not.to.throw()
		expect(()-> binding().bothWays()).not.to.throw()
		expect(()-> binding().stopPolling()).not.to.throw()
		expect(()-> binding().pollEvery(1000).stopPolling()).not.to.throw()
		expect(()-> binding().unBind()).not.to.throw()
		expect(()-> binding().chainTo ()->).not.to.throw()
		expect(()-> binding().updateDepsOnEvent 'a').not.to.throw()
		expect(()-> binding().removeEvent 'a').not.to.throw()
		expect(()-> binding().throttle 5).not.to.throw()
991
		binding = ()-> SimplyBind('1').of(objectA).to('prop1').of(objectB).and('prop2').of objectB
		expect(()-> binding().of objectA).to.throw()
		expect(()-> binding().ofEvent objectA).to.throw()
		expect(()-> binding().to 'prop2').to.throw()
		expect(()-> binding().toEvent '/local').to.throw()
		expect(()-> binding().and 'prop2').not.to.throw()
		expect(()-> binding().set 'value').not.to.throw()
		expect(()-> binding().get()).not.to.throw()
		expect(()-> binding().transform ()->).not.to.throw()
		expect(()-> binding().transformAll ()->).not.to.throw()
		expect(()-> binding().transformSelf ()->).to.throw()
		expect(()-> binding().condition ()->).not.to.throw()
		expect(()-> binding().conditionAll ()->).not.to.throw()
		expect(()-> binding().bothWays()).not.to.throw()
		expect(()-> binding().stopPolling()).not.to.throw()
		expect(()-> binding().pollEvery(1000).stopPolling()).not.to.throw()
		expect(()-> binding().unBind()).not.to.throw()
		expect(()-> binding().chainTo ()->).not.to.throw()
		expect(()-> binding().updateDepsOnEvent 'a').not.to.throw()
		expect(()-> binding().removeEvent 'a').not.to.throw()
		expect(()-> binding().throttle 5).not.to.throw()
1013
		binding = ()-> SimplyBind('1').of(objectA).to('prop1').of(objectB).bothWays()
		expect(()-> binding().of objectA).to.throw()
		expect(()-> binding().ofEvent objectA).to.throw()
		expect(()-> binding().to 'prop2').to.throw()
		expect(()-> binding().toEvent '/local').to.throw()
		expect(()-> binding().and 'prop2').not.to.throw()
		expect(()-> binding().set 'value').not.to.throw()
		expect(()-> binding().get()).not.to.throw()
		expect(()-> binding().transform ()->).not.to.throw()
		expect(()-> binding().transformAll ()->).not.to.throw()
		expect(()-> binding().transformSelf ()->).to.throw()
		expect(()-> binding().condition ()->).not.to.throw()
		expect(()-> binding().conditionAll ()->).not.to.throw()
		expect(()-> binding().bothWays()).not.to.throw()
		expect(()-> binding().stopPolling()).not.to.throw()
		expect(()-> binding().pollEvery(1000).stopPolling()).not.to.throw()
		expect(()-> binding().unBind()).not.to.throw()
		expect(()-> binding().chainTo ()->).not.to.throw()
		expect(()-> binding().updateDepsOnEvent 'a').not.to.throw()
		expect(()-> binding().removeEvent 'a').not.to.throw()
		expect(()-> binding().throttle 5).not.to.throw()
1035
		binding = ()-> SimplyBind('1').of(objectA).to('prop1').of(objectB).transform ()->
		expect(()-> binding().of objectA).to.throw()
		expect(()-> binding().ofEvent objectA).to.throw()
		expect(()-> binding().to 'prop2').to.throw()
		expect(()-> binding().toEvent '/local').to.throw()
		expect(()-> binding().and 'prop2').not.to.throw()
		expect(()-> binding().set 'value').not.to.throw()
		expect(()-> binding().get()).not.to.throw()
		expect(()-> binding().transform ()->).to.throw()
		expect(()-> binding().transformAll ()->).to.throw()
		expect(()-> binding().transformSelf ()->).to.throw()
		expect(()-> binding().condition ()->).not.to.throw()
		expect(()-> binding().conditionAll ()->).not.to.throw()
		expect(()-> binding().bothWays()).not.to.throw()
		expect(()-> binding().stopPolling()).not.to.throw()
		expect(()-> binding().pollEvery(1000).stopPolling()).not.to.throw()
		expect(()-> binding().unBind()).not.to.throw()
		expect(()-> binding().chainTo ()->).not.to.throw()
		expect(()-> binding().updateDepsOnEvent 'a').not.to.throw()
		expect(()-> binding().removeEvent 'a').not.to.throw()
		expect(()-> binding().throttle 5).not.to.throw()
1057
		binding = ()-> SimplyBind('1').of(objectA).to('prop1').of(objectB).transformAll ()->
		expect(()-> binding().of objectA).to.throw()
		expect(()-> binding().ofEvent objectA).to.throw()
		expect(()-> binding().to 'prop2').to.throw()
		expect(()-> binding().toEvent '/local').to.throw()
		expect(()-> binding().and 'prop2').to.throw()
		expect(()-> binding().set 'value').not.to.throw()
		expect(()-> binding().get()).not.to.throw()
		expect(()-> binding().transform ()->).to.throw()
		expect(()-> binding().transformAll ()->).to.throw()
		expect(()-> binding().transformSelf ()->).to.throw()
		expect(()-> binding().condition ()->).not.to.throw()
		expect(()-> binding().conditionAll ()->).not.to.throw()
		expect(()-> binding().bothWays()).to.throw()
		expect(()-> binding().stopPolling()).not.to.throw()
		expect(()-> binding().pollEvery(1000).stopPolling()).not.to.throw()
		expect(()-> binding().unBind()).not.to.throw()
		expect(()-> binding().chainTo ()->).not.to.throw()
		expect(()-> binding().updateDepsOnEvent 'a').not.to.throw()
		expect(()-> binding().removeEvent 'a').not.to.throw()
		expect(()-> binding().throttle 5).not.to.throw()
1079
		binding = ()-> SimplyBind('1').of(objectA).to('prop1').of(objectB).condition ()->
		expect(()-> binding().of objectA).to.throw()
		expect(()-> binding().ofEvent objectA).to.throw()
		expect(()-> binding().to 'prop2').to.throw()
		expect(()-> binding().toEvent '/local').to.throw()
		expect(()-> binding().and 'prop2').not.to.throw()
		expect(()-> binding().set 'value').not.to.throw()
		expect(()-> binding().get()).not.to.throw()
		expect(()-> binding().transform ()->).not.to.throw()
		expect(()-> binding().transformAll ()->).not.to.throw()
		expect(()-> binding().transformSelf ()->).to.throw()
		expect(()-> binding().condition ()->).not.to.throw()
		expect(()-> binding().conditionAll ()->).not.to.throw()
		expect(()-> binding().bothWays()).not.to.throw()
		expect(()-> binding().stopPolling()).not.to.throw()
		expect(()-> binding().pollEvery(1000).stopPolling()).not.to.throw()
		expect(()-> binding().unBind()).not.to.throw()
		expect(()-> binding().chainTo ()->).not.to.throw()
		expect(()-> binding().updateDepsOnEvent 'a').not.to.throw()
		expect(()-> binding().removeEvent 'a').not.to.throw()
		expect(()-> binding().throttle 5).not.to.throw()
1101
		binding = ()-> SimplyBind('1').of(objectA).to('prop1').of(objectB).conditionAll ()->
		expect(()-> binding().of objectA).to.throw()
		expect(()-> binding().ofEvent objectA).to.throw()
		expect(()-> binding().to 'prop2').to.throw()
		expect(()-> binding().toEvent '/local').to.throw()
		expect(()-> binding().and 'prop2').not.to.throw()
		expect(()-> binding().set 'value').not.to.throw()
		expect(()-> binding().get()).not.to.throw()
		expect(()-> binding().transform ()->).not.to.throw()
		expect(()-> binding().transformAll ()->).not.to.throw()
		expect(()-> binding().transformSelf ()->).to.throw()
		expect(()-> binding().condition ()->).not.to.throw()
		expect(()-> binding().conditionAll ()->).not.to.throw()
		expect(()-> binding().bothWays()).not.to.throw()
		expect(()-> binding().stopPolling()).not.to.throw()
		expect(()-> binding().pollEvery(1000).stopPolling()).not.to.throw()
		expect(()-> binding().unBind()).not.to.throw()
		expect(()-> binding().chainTo ()->).not.to.throw()
		expect(()-> binding().updateDepsOnEvent 'a').not.to.throw()
		expect(()-> binding().removeEvent 'a').not.to.throw()
		expect(()-> binding().throttle 5).not.to.throw()
1123
		binding = ()-> SimplyBind('1').of(objectA).to('prop1').of(objectB).transform(()->).and ()->
		expect(()-> binding().of objectA).to.throw()
		expect(()-> binding().ofEvent objectA).to.throw()
		expect(()-> binding().to 'prop2').to.throw()
		expect(()-> binding().toEvent '/local').to.throw()
		expect(()-> binding().and 'prop2').not.to.throw()
		expect(()-> binding().set 'value').not.to.throw()
		expect(()-> binding().get()).not.to.throw()
		expect(()-> binding().transform ()->).not.to.throw()
		expect(()-> binding().transformAll ()->).not.to.throw()
		expect(()-> binding().transformSelf ()->).to.throw()
		expect(()-> binding().condition ()->).not.to.throw()
		expect(()-> binding().conditionAll ()->).not.to.throw()
		expect(()-> binding().bothWays()).not.to.throw()
		expect(()-> binding().stopPolling()).not.to.throw()
		expect(()-> binding().pollEvery(1000).stopPolling()).not.to.throw()
		expect(()-> binding().unBind()).not.to.throw()
		expect(()-> binding().chainTo ()->).not.to.throw()
		expect(()-> binding().updateDepsOnEvent 'a').not.to.throw()
		expect(()-> binding().removeEvent 'a').not.to.throw()
		expect(()-> binding().throttle 5).not.to.throw()
1145
		binding = ()-> SimplyBind('1').of(objectA).to('prop1').of(objectB).transform(()->).and(()->).chainTo ()->
		expect(()-> binding().of objectA).to.throw()
		expect(()-> binding().ofEvent objectA).to.throw()
		expect(()-> binding().to 'prop2').to.throw()
		expect(()-> binding().toEvent '/local').to.throw()
		expect(()-> binding().and 'prop2').not.to.throw()
		expect(()-> binding().set 'value').not.to.throw()
		expect(()-> binding().get()).not.to.throw()
		expect(()-> binding().transform ()->).not.to.throw()
		expect(()-> binding().transformAll ()->).not.to.throw()
		expect(()-> binding().transformSelf ()->).to.throw()
		expect(()-> binding().condition ()->).not.to.throw()
		expect(()-> binding().conditionAll ()->).not.to.throw()
		expect(()-> binding().bothWays()).not.to.throw()
		expect(()-> binding().stopPolling()).not.to.throw()
		expect(()-> binding().pollEvery(1000).stopPolling()).not.to.throw()
		expect(()-> binding().unBind()).not.to.throw()
		expect(()-> binding().chainTo ()->).not.to.throw()
		expect(()-> binding().updateDepsOnEvent 'a').not.to.throw()
		expect(()-> binding().removeEvent 'a').not.to.throw()
		expect(()-> binding().throttle 5).not.to.throw()
1167
1168
1169
1170
suite "Cached Bindings", ()->
	test "A cached version of the binding should be returned when re-creating an existing one", ()->
		# ==== ObjectProp =================================================================================
		expect(SimplyBind('prop1').of(objectA).ID)
			.to.equal(SimplyBind('prop1').of(objectA).ID)
		
		expect(SimplyBind('prop1').of(objectA).to('prop1').of(objectB)._.deps[0].ID)
			.to.equal(SimplyBind('prop1').of(objectB).ID)
		
		if isBrowser
			# ==== DOMAttr =================================================================================
			expect(SimplyBind('attr:someattr').of(regA).ID)
				.to.equal(SimplyBind('attr:someattr').of(regA).ID)
			
			expect(SimplyBind('attr:someattr').of(regA).to('attr:someattr').of(regB)._.deps[0].ID)
				.to.equal(SimplyBind('attr:someattr').of(regB).ID)
			
1188
			# ==== DOMValue =================================================================================
			expect(SimplyBind('value').of(inputA).ID)
				.to.equal(SimplyBind('value').of(inputA).ID)
			
			expect(SimplyBind('value').of(inputA).to('value').of(inputB)._.deps[0].ID)
				.to.equal(SimplyBind('value').of(inputB).ID)
			
1196
			# ==== DOMCheckbox Single =================================================================================
			expect(SimplyBind('checked').of(checkboxA).ID)
				.to.equal(SimplyBind('checked').of(checkboxA).ID)
			
			expect(SimplyBind('checked').of(checkboxA).to('checked').of(checkboxB)._.deps[0].ID)
				.to.equal(SimplyBind('checked').of(checkboxB).ID)
			
1204
			# ==== DOMCheckbox =================================================================================
			expect(SimplyBind('checked').of($checkboxFields).ID)
				.to.equal(SimplyBind('checked').of($checkboxFields).ID)
			
1209
			# ==== DOMRadio =================================================================================
			expect(SimplyBind('checked').of($radioFields).ID)
				.to.equal(SimplyBind('checked').of($radioFields).ID)
								
1214
			# ==== DOMText =================================================================================
			expect(SimplyBind('textContent').of(regA).ID)
				.to.equal(SimplyBind('textContent').of(regA).ID)
			
			expect(SimplyBind('textContent').of(regA).to('textContent').of(regB)._.deps[0].ID)
				.to.equal(SimplyBind('textContent').of(regB).ID)
			
1222
		# ==== Event =================================================================================
		expect(SimplyBind(0).ofEvent('someEvent').of(eventEmitterA).ID)
			.to.equal(SimplyBind(0).ofEvent('someEvent').of(eventEmitterA).ID)
		
		expect(SimplyBind(0).ofEvent('someEvent').of(eventEmitterA).toEvent('someEvent').of(eventEmitterB)._.deps[0].ID)
			.to.equal(SimplyBind(0).ofEvent('someEvent').of(eventEmitterB).ID)
1229
1230
		# ==== Array =================================================================================
		expect(SimplyBind(arrayA).ID)
			.to.equal(SimplyBind(arrayA).ID)
		
		expect(SimplyBind(arrayA).to(arrayB)._.deps[0].ID)
			.to.equal(SimplyBind(arrayB).ID)
1237
1238
		# ==== Function =================================================================================
		expect(SimplyBind(fnA).ID)
			.to.equal(SimplyBind(fnA).ID)
		
		expect(SimplyBind(fnA).to(fnB)._.deps[0].ID)
			.to.equal(SimplyBind(fnB).ID)
1245
1246
		restartSandbox()
1248
1249
1250
	test "When binding an object prop with a placeholder indicator in the selector for an existing binding that didn't have indicators, placeholders will be rescanned", ()->
		dispatcher = 'prop':'This is an {{size}} size shirt'
		receiver = 'prop':''
1254
		SimplyBind('prop').of(dispatcher)
			.to('prop').of(receiver)
1257
		expect(receiver.prop).to.equal(dispatcher.prop)
		expect(dispatcher.prop).to.equal 'This is an {{size}} size shirt'
1260
1261
		SimplyBind('prop').of(dispatcher)
			.to('prop.size').of(receiver)
		
		dispatcher.prop = 'XXL'
		expect(dispatcher.prop).to.equal 'XXL'
		expect(receiver.prop).to.equal 'This is an XXL size shirt'
1268
1269
	
	test "When re-binding a binding with placeholder where the global placeholders regEx has changed to a diff regEx from present in the original binding, the binding's regEx shouldn't change", ()->
		dispatcher = 'noun':'', 'adjective':''
		receiver = 'prop':'This {{noun}} is **adjective**'
1274
		SimplyBind('noun').of(dispatcher)
			.to('prop.noun').of(receiver)
1277
		dispatcher.noun = 'test'
		expect(receiver.prop).to.equal 'This test is **adjective**'
1280
1281
		SimplyBind.setOption 'placeholder', ['**', '**']
1283
		SimplyBind('adjective').of(dispatcher)
			.to('prop.adjective').of(receiver)
1286
		dispatcher.adjective = 'good'
		expect(receiver.prop).to.equal 'This test is **adjective**'
		
		dispatcher.noun = 'suite'
		expect(receiver.prop).to.equal 'This suite is **adjective**'
		
		SimplyBind.setOption 'placeholder', ['{{', '}}']
1294
1295
1296
	test "When re-binding an object prop that was deleted manually make sure to re-make the property a live one", ()->
		objectA.prop = 1
		SimplyBind('prop').of(objectA)
			.to('prop').of(objectB)
1301
		expect(objectB.prop).to.equal(objectA.prop)
		objectA.prop = 2
		expect(objectB.prop).to.equal(objectA.prop)
1305
		delete objectB.prop
		objectA.prop = 3
		expect(objectB.prop).not.to.equal(objectA.prop)
		
		
		SimplyBind('prop').of(objectA)
			.to('prop').of(objectB)
		
		expect(objectB.prop).to.equal(objectA.prop)
		
		objectA.prop = 4
		expect(objectB.prop).to.equal(objectA.prop)
		
		restartSandbox()
1320
1321
1322
	test "When binding an index of an array that's brand new and the array is tracked and so are its children, the new index should be made so it also tracked", ()->
		invokeCount = 0
		SimplyBind(arrayA, 'trackArrayChildren':true).to ()-> invokeCount++
1326
		expect(invokeCount).to.equal 1
1328
		arrayA[3] = 44
		expect(invokeCount).to.equal 2
1331
		arrayA[20] = 21
		expect(invokeCount).to.equal 2
1334
		SimplyBind('18').of(arrayA)
		arrayA[18] = 188
		expect(invokeCount).to.equal 4
		
		arrayA[18] = 1888
		expect(invokeCount).to.equal 5
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
suite "Data Binding Behavior", ()->
suiteSetup(restartSandbox)
test "Object properties should behave the same way across all object types", ()->
	dispatcher = 
		'standard': objectA
		'array': arrayA
		'function': ()->
		'domDiv': if isBrowser then $('<div />')[0] else {}
		'domInput': if isBrowser then $('<input />')[0] else {}
		'domNode': if isBrowser then $('<div>text</div>')[0].childNodes[0] else {}
		'date': new Date()
	receiver =
		'standard': objectB
		'array': arrayB
		'function': ()->
		'domDiv': if isBrowser then $('<div />')[0] else {}
		'domInput': if isBrowser then $('<input />')[0] else {}
		'domNode': if isBrowser then $('<div>text</div>')[0].childNodes[0] else {}
		'date': new Date()
1398
	for name,object of dispatcher
		SimplyBind('prop').of(dispatcher[name]).to('prop').of(receiver[name])
		expect(receiver[name].prop).to.be.undefined
		
		SimplyBind('prop').of(dispatcher[name]).set(100)
		expect(receiver[name].prop).to.equal(100)
1405
	restartSandbox()
1407
1408
1409
test "Object properties should be made into live properties when SimplyBind.options.liveProps is on", ()->
	expect(SimplyBind.options.liveProps).to.be.true
	invokeCount = 0
	
	SimplyBind('prop1').of(objectA).to ()-> invokeCount++
	expect(invokeCount).to.equal(1)
1416
	objectA.prop1 = !objectA.prop1
	expect(invokeCount).to.equal(2)
1419
	SimplyBind('prop1').of(objectA).set !objectA.prop1
	expect(invokeCount).to.equal(3)
1422
1423
	SimplyBind.setOption 'liveProps', false
	invokeCount = 0
	
	SimplyBind('prop1').of(objectB).to ()-> invokeCount++
	expect(invokeCount).to.equal(1)
1429
	objectB.prop1 = !objectB.prop1
	expect(invokeCount).to.equal(1)
1432
	SimplyBind('prop1').of(objectB).set !objectB.prop1
	expect(invokeCount).to.equal(2)
1435
1436
1437
	SimplyBind.setOption 'liveProps', true
	restartSandbox()
1440
1441
1442
test "Object properties inherited from the prototype should be made into live properties when SimplyBind.options.mutateInherited is on", ()->
	testArray = []
	
	SimplyBind.setOption 'mutateInherited', true
	Array::inherited = 'I was inherited'
	
	SimplyBind('inherited').of(testArray).to('prop1').of objectB
	
	testArray.inherited = 'inherited live prop change :)'
	expect(objectB.prop1).to.equal 'inherited live prop change :)'
	delete Array::inherited
	
1455
1456
	SimplyBind.setOption 'mutateInherited', false
	Array::inherited2 = 'I was inherited'
	
	SimplyBind('inherited2').of(testArray).to('prop2').of objectB
	
	testArray.inherited2 = 'inherited prop shouldn\'t change'
	expect(objectB.prop2).not.to.equal 'inherited prop shouldn\'t change'
	delete Array::inherited2
	
1466
	SimplyBind.setOption 'mutateInherited', false
	restartSandbox()
1469
1470
1471
test "The property's original setter (if exists) should be invoked during a live property update", ()->
	prop7 = 'hey!'
	invokeCountGet = 0
	invokeCountSet = 0
	
	Object.defineProperty objectA, 'prop7',
		enumerable: true
		configurable: true
		get: ()->
			invokeCountGet++
			prop7
		set: (val)->
			invokeCountSet++
			prop7 = val
1486
1487
1488
	expect(objectA.prop7).to.equal 'hey!'
	expect(invokeCountGet).to.equal 1
	expect(invokeCountSet).to.equal 0

	SimplyBind('prop7').of(objectA).to('prop3').of objectB

	objectA.prop7 = 'hello!'
	expect(invokeCountGet).to.equal 2
	expect(invokeCountSet).to.equal 1
	expect(objectA.prop7).to.equal 'hello!'

	objectA.prop7 = 'hi!'
	expect(invokeCountGet).to.equal 2
	expect(invokeCountSet).to.equal 2
	restartSandbox()
1504
1505
1506
test "Bindings will update dependents even if their value is falsy", ()->
	binding = SimplyBind('prop1').of(objectA).to('prop1').of(objectB)
	
	binding.set ''
	expect(objectB.prop1).to.equal ''
	
	binding.set 0
	expect(objectB.prop1).to.equal 0
	
	binding.set false
	expect(objectB.prop1).to.equal false
	
	binding.set undefined
	expect(objectB.prop1).to.equal undefined
	
	binding.set null
	expect(objectB.prop1).to.equal null
1524
	restartSandbox()
1526
1527
1528
test "Update dependents of a binding even if it's unchanged when SimplyBind.options.updateEvenIfSame is on or if the binding type is Func or Event", ()->
	invokeCount = object:0, func:0, event:0
	objectA.prop6 = 'start'
	objectB.prop6 = ''
1533
	eventEmitterA.on 'alwaysEmit', ()-> invokeCount.event++
	
	bindings =
		'object': SimplyBind('prop6').of(objectA).to('prop6').of(objectB).transform (value)-> invokeCount.object++; return value
		'func': SimplyBind('prop7', updateEvenIfSame:true).of(objectA).to(()-> invokeCount.func++)
		'event': SimplyBind('prop8', updateEvenIfSame:true).of(objectA).toEvent('alwaysEmit').of(eventEmitterA)
	
	expect(objectB.prop6).to.equal 'start'
	expect(invokeCount.object).to.equal 1
	
	objectA.prop6 = "shouldn't update"
	expect(objectB.prop6).to.equal "shouldn't update"
	expect(invokeCount.object).to.equal 2
	
	objectA.prop6 = "shouldn't update"
	expect(objectB.prop6).to.equal "shouldn't update"
	expect(invokeCount.object).to.equal 2
	
1552
	expect(invokeCount.func).to.equal 1
	
	objectA.prop7 = 'should update'
	expect(invokeCount.func).to.equal 2
1557
	objectA.prop7 = 'should update'
	expect(invokeCount.func).to.equal 3
	
1561
1562
	expect(invokeCount.event).to.equal 1
	
	objectA.prop8 = 'should update'
	expect(invokeCount.event).to.equal 2
1567
	objectA.prop8 = 'should update'
	expect(invokeCount.event).to.equal 3
1570
1571
1572
	bindings.object.setOption 'updateEvenIfSame', true
	
	objectA.prop6 = 'should update'
	expect(objectB.prop6).to.equal 'should update'
	expect(invokeCount.object).to.equal 3

	objectA.prop6 = 'should update'
	objectA.prop6 = 'should update'
	objectA.prop6 = 'should update'
	objectA.prop6 = 'should update'
	expect(invokeCount.object).to.equal 7
	
1585
	bindings.object.setOption 'updateEvenIfSame', false
	
	objectA.prop6 = "shouldn't update"
	expect(objectB.prop6).to.equal "shouldn't update"
	expect(invokeCount.object).to.equal 8
	
	objectA.prop6 = "shouldn't update"
	objectA.prop6 = "shouldn't update"
	objectA.prop6 = "shouldn't update"
	objectA.prop6 = "shouldn't update"
	expect(invokeCount.object).to.equal 8
	restartSandbox()
1598
1599
1600
test "Should update dependents even when its new value is undefined", ()->
	binding = SimplyBind('prop1').of(objectA).to('prop1').of(objectB)
	objectA.prop1 = 10
	expect(objectB.prop1).to.equal 10
	
	objectA.prop1 = window.nonexistent # undefined value
	expect(objectB.prop1).to.be.undefined
	
1609
	objectA.prop1 = 20
	expect(objectB.prop1).to.equal 20
	
	objectA.prop1 = window.nonexistent # undefined value
	expect(objectB.prop1).to.be.undefined
	
	restartSandbox()
1617
1618
1619
test "Dependents should update their subdependents when being updated by an independent, even if these dependents are not liveProps", ()-> if not isBrowser then @skip() else
	objectA.prop2 = 0.8
	
	SimplyBind('prop2').of(objectA)
		.to('opacity').of regA.style
	
	SimplyBind('opacity').of(regA.style)
		.to('font-size').of(regA.style)
			.transform (opacity)-> opacity * 20 + 'px'
		.and('font-size').of(regB.style)
			.transform (opacity)-> opacity * 40 + 'px'
	
1632
	expect(regA.style.opacity.toString()).to.equal '0.8'
	expect(regA.style['font-size']).to.equal '16px'
	expect(regB.style['font-size']).to.equal '32px'
	
1637
	objectA.prop2 = 0.5
	expect(regA.style.opacity.toString()).to.equal '0.5'
	expect(regA.style['font-size']).to.equal '10px'
	expect(regB.style['font-size']).to.equal '20px'
	restartSandbox()
1643
1644
1645
test "Placeholder indicators in a property name will be ignored if SimplyBind.options.simpleSelector is on", ()->
	objA = 'first': 'This {{placeholder}} will change'
	objB = 'second': 'This {{nonplaceholder}} will remain the same'
1649
	SimplyBind('prop1').of(objectA).to('first.placeholder').of(objA)
	objectA.prop1 = 'placeholder'
1652
	SimplyBind('prop1').of(objectB).to('second.nonplaceholder', {'simpleSelector':true}).of(objB)
	objectB.prop1 = 'placeholder'
1655
	expect(objA['first']).to.equal 'This placeholder will change'
	expect(objB['second']).to.equal 'This {{nonplaceholder}} will remain the same'
1658
1659
1660
test "Dependents shouldn't be updated when SimplyBind.options.updateOnBind is off even when a transform function is applied", ()->
	dispatcher = 'value': 123
	invokeCount =
		'object': 0
		'array': 0
		'function': 0
		'domAttr': 0
		'domText': 0
		'domInput': 0
		'jQueryProp': 0
		'event': 0
1672
	fakeTransform = (value)-> value
	SimplyBind.setOption 'updateOnBind', false
	SimplyBind('prop').of(objectA).to(()-> invokeCount.object++).transform(fakeTransform)
	SimplyBind(arrayA).to(()-> invokeCount.array++).transform(fakeTransform)
	SimplyBind(fn = ()-> true).to(()-> invokeCount.function++).transform(fakeTransform)
	SimplyBind('attr:prop').of(regA).to(()-> invokeCount.domAttr++).transform(fakeTransform) if isBrowser
	SimplyBind('textContent').of(regA).to(()-> invokeCount.domText++).transform(fakeTransform) if isBrowser
	SimplyBind('value').of(inputA).to(()-> invokeCount.domInput++).transform(fakeTransform) if isBrowser
	SimplyBind('prop').of($regB).to(()-> invokeCount.jQueryProp++).transform(fakeTransform) if isBrowser
	SimplyBind(0).ofEvent('someEvent').of(eventEmitterA).to(()-> invokeCount.event++).transform(fakeTransform)
1683
1684
	SimplyBind.setOption 'updateOnBind', true
	
	SimplyBind('value').of(dispatcher).to('prop').of(objectA)
	SimplyBind('value').of(dispatcher).to(arrayA)
	SimplyBind('value').of(dispatcher).to(fn)
	SimplyBind('value').of(dispatcher).to('attr:prop').of(regA) if isBrowser
	SimplyBind('value').of(dispatcher).to('textContent').of(regA) if isBrowser
	SimplyBind('value').of(dispatcher).to('value').of(inputA) if isBrowser
	SimplyBind('value').of(dispatcher).to('prop').of($regB) if isBrowser
	SimplyBind('value').of(dispatcher).toEvent('someEvent').of(eventEmitterA)
1695
	expect(invokeCount.object).to.equal 1
	expect(invokeCount.array).to.equal 0 # Cannot get updated
	expect(invokeCount.function).to.equal 3 # Ignores updateOnBind
	expect(invokeCount.event).to.equal 1
	if isBrowser
		expect(invokeCount.domAttr).to.equal 1
		expect(invokeCount.domText).to.equal 1
		expect(invokeCount.domInput).to.equal 1
		expect(invokeCount.jQueryProp).to.equal 1
1705
	restartSandbox()
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
suite "Data Binding", ()->
suiteSetup(restartSandbox)
test "Live properties should be supported on all object properties", ()->
	dispatcher = 
		'standard': objectA
		'array': arrayA
		'function': ()->
		'domDiv': if isBrowser then $('<div />')[0] else {}
		'domInput': if isBrowser then $('<input />')[0] else {}
		'domNode': if isBrowser then $('<div>text</div>')[0].childNodes[0] else {}
	receiver =
		'standard': null
		'array': null
		'function': null
		'domDiv': null
		'domInput': null
		'domNode': null
1740
	for name,object of dispatcher
		SimplyBind('prop').of(dispatcher[name]).to(name).of(receiver)
		expect(receiver[name]).to.equal(undefined)
		
		object.prop = 100
		expect(receiver[name]).to.equal(100)
1747
	restartSandbox()
1749
1750
1751
1752
1753
test "Infinite loops should not occur in looping update chains", ()->
	SimplyBind.setOption 'updateEvenIfSame', true
1756
	# ==== Objects =================================================================================
	SimplyBind('prop').of(objectA)
		.to('prop').of(objectB).bothWays()
			.chainTo('prop').of(objectC).bothWays()
				.chainTo('prop').of(objectA).bothWays()
1762
	objectA.prop = 'from objectA'
	expect(objectA.prop).to.equal 'from objectA'
	expect(objectB.prop).to.equal 'from objectA'
	expect(objectC.prop).to.equal 'from objectA'
1767
	objectB.prop = 'from objectB'
	expect(objectA.prop).to.equal 'from objectB'
	expect(objectB.prop).to.equal 'from objectB'
	expect(objectC.prop).to.equal 'from objectB'
1772
1773
1774
	# ==== Arrays =================================================================================
	SimplyBind(0).of(arrayA)
		.to(0).of(arrayB).bothWays()
			.chainTo(0).of(arrayC).bothWays()
				.chainTo(0).of(arrayA).bothWays()
1780
	arrayA[0] = 'from arrayA'
	expect(arrayA[0]).to.equal 'from arrayA'
	expect(arrayB[0]).to.equal 'from arrayA'
	expect(arrayC[0]).to.equal 'from arrayA'
1785
	arrayB[0] = 'from arrayB'
	expect(arrayA[0]).to.equal 'from arrayB'
	expect(arrayB[0]).to.equal 'from arrayB'
	expect(arrayC[0]).to.equal 'from arrayB'
	
1791
1792
	if isBrowser
		# ==== DOMAttr =================================================================================
		SimplyBind('attr:someattr').of(regA)
			.to('attr:someattr').of(regB).bothWays()
				.chainTo('attr:someattr').of(regC).bothWays()
					.chainTo('attr:someattr').of(regA).bothWays()
1799
		# regA.setAttribute 'someattr', 'from regElementA'
		SimplyBind('attr:someattr').of(regA).set('from regElementA')
		expect(regA.getAttribute 'someattr').to.equal 'from regElementA'
		expect(regB.getAttribute 'someattr').to.equal 'from regElementA'
		expect(regC.getAttribute 'someattr').to.equal 'from regElementA'
1805
		# regB.setAttribute 'someattr', 'from regElementB'
		SimplyBind('attr:someattr').of(regB).set('from regElementB')
		expect(regA.getAttribute 'someattr').to.equal 'from regElementB'
		expect(regB.getAttribute 'someattr').to.equal 'from regElementB'
		expect(regC.getAttribute 'someattr').to.equal 'from regElementB'
		
1812
1813
		# ==== DOMText =================================================================================
		SimplyBind('textContent').of(regA)
			.to('textContent').of(regB).bothWays()
				.chainTo('textContent').of(regC).bothWays()
					.chainTo('textContent').of(regA).bothWays()
1819
		SimplyBind('textContent').of(regA).set 'from regElementA'
		expect(regA.textContent).to.equal 'from regElementA'
		expect(regB.textContent).to.equal 'from regElementA'
		expect(regC.textContent).to.equal 'from regElementA'
1824
		SimplyBind('textContent').of(regB).set 'from regElementB'
		expect(regA.textContent).to.equal 'from regElementB'
		expect(regB.textContent).to.equal 'from regElementB'
		expect(regC.textContent).to.equal 'from regElementB'
		
1830
1831
		# ==== DOMValue =================================================================================
		SimplyBind('value').of(inputA)
			.to('value').of(inputB).bothWays()
				.chainTo('value').of(inputC).bothWays()
					.chainTo('value').of(inputA).bothWays()
1837
		inputA.value = 'from inputElementA'
		inputA.emit 'change'
		expect(inputA.value).to.equal 'from inputElementA'
		expect(inputB.value).to.equal 'from inputElementA'
		expect(inputC.value).to.equal 'from inputElementA'
1843
		inputB.value = 'from inputElementB'
		inputB.emit 'change'
		expect(inputA.value).to.equal 'from inputElementB'
		expect(inputB.value).to.equal 'from inputElementB'
		expect(inputC.value).to.equal 'from inputElementB'
1849
1850
1851
	# ==== Events =================================================================================			
	SimplyBind(0).ofEvent('eventA').of(eventEmitterA)
		.toEvent('eventB').of(eventEmitterA).bothWays()
	
	SimplyBind(0).ofEvent('eventB').of(eventEmitterA)
		.toEvent('eventC').of(eventEmitterA).bothWays()
	
	SimplyBind(0).ofEvent('eventC').of(eventEmitterA)
		.toEvent('eventA').of(eventEmitterA).bothWays()
1861
	invokeCountA = invokeCountB = invokeCountC = 0
	eventEmitterA.on 'eventA', ()-> invokeCountA++
	eventEmitterA.on 'eventB', ()-> invokeCountB++
	eventEmitterA.on 'eventC', ()-> invokeCountC++
	
	eventEmitterA.emit 'eventA'
	eventEmitterA.emit 'eventB'
	eventEmitterA.emit 'eventC'
1870
	expect(invokeCountA).to.equal 3
	expect(invokeCountB).to.equal 3
	expect(invokeCountC).to.equal 3
	SimplyBind.setOption 'updateEvenIfSame', false
	restartSandbox()
1876
1877
1878
1879
test "Infinite loops should not occur for colliding two-way bindings", ()->
	SimplyBind.setOption 'updateEvenIfSame', true
	dispatcher = 'prop': 0
	objectA.prop1 = 0
	objectB.prop1 = 0
	objectC.prop1 = 0
	SimplyBind('prop').of(dispatcher)
		.to('prop1').of(objectA).bothWays().transform (v, ov)-> v+ov
		.and('prop1').of(objectB).bothWays().transform (v, ov)-> v+ov
		.and('prop1').of(objectC).bothWays().transform (v, ov)-> v+ov
1890
	expect(dispatcher.prop).to.equal 0
	expect(objectA.prop1).to.equal 0
	expect(objectB.prop1).to.equal 0
	expect(objectC.prop1).to.equal 0
	
	dispatcher.prop = 1
	expect(dispatcher.prop).to.equal 1
	expect(objectA.prop1).to.equal 1
	expect(objectB.prop1).to.equal 1
	expect(objectC.prop1).to.equal 1
1901
	objectA.prop1 = 2
	expect(dispatcher.prop).to.equal 3
	expect(objectA.prop1).to.equal 2
	expect(objectB.prop1).to.equal 4 # not 3 because dispatcher.prop gets a 2 from objectA.prop1 but then it transforms it to 3 and passes to this binding.
	expect(objectC.prop1).to.equal 4 # not 3 because dispatcher.prop gets a 2 from objectA.prop1 but then it transforms it to 3 and passes to this binding.
1907
	objectC.prop1 = 3
	expect(dispatcher.prop).to.equal 6
	expect(objectA.prop1).to.equal 8
	expect(objectB.prop1).to.equal 10
	expect(objectC.prop1).to.equal 3
1913
1914
	SimplyBind.setOption 'updateEvenIfSame', false
	restartSandbox()	
1917
1918
1919
test "Infinite loops should occur only when a value is bound to a function and that function updates the value", ()->
	invokeCount = 0
1922
	SimplyBind('prop1').of(objectA)
		.to ()-> unless invokeCount is 15
			objectA.prop1 = ++invokeCount
1926
	expect(invokeCount).to.equal(objectA.prop1)
	expect(invokeCount).to.equal(15)
	restartSandbox()
1930
1931
1932
1933
test "Update dependents", ()->
	invokeCount =
		'object': 0
		'array': 0
		'function': 0
		'domAttr': 0
		'domText': 0
		'domValue': 0
		'domCheckboxSingle': 0
		'domCheckbox': 0
		'domRadioSingle': 0
		'domRadio': 0
		'event': 0
	SimplyBind.setOption('updateOnBind', false)
	
1949
	# ==== Objects =================================================================================
	SimplyBind('prop').of(objectA).to ()-> invokeCount.object++
	objectA.prop = true
	expect(invokeCount.object).to.equal(1)
1954
1955
	# ==== Arrays =================================================================================
	SimplyBind(arrayA).to ()-> invokeCount.array++
	arrayA.push(1)
	arrayA.unshift(1)
	arrayA.pop()
	arrayA.shift()
	arrayA.splice(0,1)
	expect(invokeCount.array).to.equal(5)
1964
1965
	# ==== Functions =================================================================================
	SimplyBind(()->true).to ()-> invokeCount.function++
	expect(invokeCount.function).to.equal(1)
1969
1970
	if isBrowser
		# ==== DOMAttr =================================================================================
		SimplyBind('attr:someattr').of(regA).to ()-> invokeCount.domAttr++
		regA.setAttribute('someattr', 10)
		SimplyBind('attr:someattr').of(regA).set(true)
		expect(invokeCount.domAttr).to.equal(1)
1977
1978
		# ==== DOMText =================================================================================
		SimplyBind('textContent').of(regA).to ()-> invokeCount.domText++
		SimplyBind('textContent').of(regA).set 'true'
		expect(invokeCount.domText).to.equal(1)
1983
1984
		# ==== DOMValue =================================================================================
		SimplyBind('value').of(inputA).to ()-> invokeCount.domValue++
		inputA.value = 'true'
		inputA.emit 'change'
		expect(invokeCount.domValue).to.equal(1)
1990
1991
		# ==== DOMCheckbox Single =================================================================================
		SimplyBind('checked').of(checkboxA).to ()-> invokeCount.domCheckboxSingle++
		checkboxA.checked = true
		checkboxA.emit 'change'
		expect(invokeCount.domCheckboxSingle).to.equal(1)
1997
1998
		# ==== DOMCheckbox =================================================================================
		SimplyBind('checked').of(checkboxFields).to ()-> invokeCount.domCheckbox++
		checkboxB.checked = true
		checkboxB.emit 'change'
		expect(invokeCount.domCheckbox).to.equal(1)
2004
2005
		# ==== DOMRadio Single =================================================================================
		SimplyBind('checked').of(radioA).to ()-> invokeCount.domRadioSingle++
		radioA.checked = true
		radioA.emit 'change'
		expect(invokeCount.domRadioSingle).to.equal(1)
2011
2012
		# ==== DOMRadio =================================================================================
		SimplyBind('checked').of(radioFields).to ()-> invokeCount.domRadio++
		radioB.checked = true
		radioB.emit 'change'
		expect(invokeCount.domRadio).to.equal(1)
2018
2019
	# ==== Event =================================================================================
	SimplyBind.setOption('updateEvenIfSame', true)
	SimplyBind(0).ofEvent('someEvent').of(eventEmitterA).to ()-> invokeCount.event++
	eventEmitterA.emit 'someEvent'
	
2025
	expect(invokeCount.event).to.equal(1)

	SimplyBind.setOption('updateEvenIfSame', false)
	SimplyBind.setOption('updateOnBind', true)
	restartSandbox()
2031
2032
2033
2034
2035
2036
2037
test "Receive a value as a dependent", ()->
	invokeCount =
		'object': 0
		'array': 0
		'function': 0
		'domAttr': 0
		'domText': 0
		'domValue': 0
		'domCheckboxSingle': 0
		'domCheckbox': 0
		'domRadio': 0
		'event': 0
	SimplyBind.setOption('updateOnBind', false)
	
2052
	# ==== Objects =================================================================================
	SimplyBind('prop').of(objectA).to ()-> invokeCount.object++
	SimplyBind(()-> true).to('prop').of(objectA)
2056
	expect(objectA.prop).to.equal(true)
	expect(invokeCount.object).to.equal(1)
2059
2060
	# ==== Arrays =================================================================================
	SimplyBind(arrayA).to ()-> invokeCount.array++
	SimplyBind(()-> []).to('prop').of(objectA)
	
	expect(arrayA.length).not.to.equal(0)
	expect(invokeCount.array).to.equal(0)
2067
	if isBrowser
		# ==== DOMAttr =================================================================================
		SimplyBind('attr:someattr').of(regA).to ()-> invokeCount.domAttr++
		SimplyBind(()-> 'true').to('attr:someattr').of(regA)
2072
		expect(regA.getAttribute('someattr')).to.equal('true')
		expect(invokeCount.domAttr).to.equal(1)
2075
2076
		# ==== DOMText =================================================================================
		SimplyBind('textContent').of(regA).to ()-> invokeCount.domText++
		SimplyBind(()-> 'true').to('textContent').of(regA)
2080
		expect(regA.textContent).to.equal('true')
		expect(invokeCount.domText).to.equal(1)
2083
2084
		# ==== DOMValue =================================================================================
		SimplyBind('value').of(inputA).to ()-> invokeCount.domValue++
		SimplyBind(()-> 'true').to('value').of(inputA)
		
		expect(inputA.value).to.equal('true')
		expect(invokeCount.domValue).to.equal(1)
2091
2092
		# ==== DOMCheckbox Single =================================================================================
		expect(checkboxA.checked).to.be.false
		SimplyBind('checked').of(checkboxA).to ()-> invokeCount.domCheckboxSingle++
		SimplyBind(()-> 'truthy').to('checked').of(checkboxA)
		
		expect(checkboxA.checked).to.be.true
		expect(invokeCount.domCheckboxSingle).to.equal(1)
2100
2101
		# ==== DOMCheckbox =================================================================================
		SimplyBind('checked').of($checkboxFields).to ()-> invokeCount.domCheckbox++
		SimplyBind(()-> ['checkboxB', 'checkboxC']).to('checked').of($checkboxFields)
		
		expect(checkboxA.checked).to.be.false
		expect(checkboxB.checked).to.be.true
		expect(checkboxC.checked).to.be.true
		expect(invokeCount.domCheckbox).to.equal(1)
		
		SimplyBind(()-> 'checkboxA').to('checked').of($checkboxFields)
		
		expect(checkboxA.checked).to.be.true
		expect(checkboxB.checked).to.be.false
		expect(checkboxC.checked).to.be.false
		expect(invokeCount.domCheckbox).to.equal(2)
2117
2118
		# ==== DOMRadio =================================================================================
		SimplyBind('checked').of($radioFields).to ()-> invokeCount.domRadio++
		SimplyBind(()-> 'radioC').to('checked').of($radioFields)
		
		expect(radioA.checked).to.be.false
		expect(radioB.checked).to.be.false
		expect(radioC.checked).to.be.true
		expect(invokeCount.domRadio).to.equal(1)
2127
2128
	# ==== Event =================================================================================
	SimplyBind(0).ofEvent('someEvent').of(eventEmitterA).to ()-> invokeCount.event++
	SimplyBind(()-> true).toEvent('someEvent').of(eventEmitterA)
2132
	expect(invokeCount.event).to.equal(1)
	
2135
	SimplyBind.setOption('updateOnBind', true)
	restartSandbox()
2138
2139
2140
2141
2142
2143
2144
2145
suite "Placeholders", ()->
	test "Property names with periods (.) indicate a placeholder", ()->
		dispatcher = 'value': 'Medium'
2149
		objectA.prop = 'The size of this shirt is {{size}}, man!'
		if isBrowser
			inputA.value = 'The size of this shirt is {{size}}, man!'
			regA.textContent = 'The size of this shirt is {{size}}, man!'
			regA.setAttribute 'someattr', 'The size of this shirt is {{size}}, man!'
2155
		SimplyBind('value').of(dispatcher)
			.to('prop.size').of(objectA)
2158
		if isBrowser
			SimplyBind('value').of(dispatcher)
				.to('value.size').of(inputA)
				.and('textContent.size').of(regA)
				.and('attr:someattr.size').of(regA)
			
		expect(objectA.prop).to.equal 'The size of this shirt is Medium, man!'
		if isBrowser
			expect(inputA.value).to.equal 'The size of this shirt is Medium, man!'
			expect(regA.textContent).to.equal 'The size of this shirt is Medium, man!'
			expect(regA.getAttribute 'someattr').to.equal 'The size of this shirt is Medium, man!'
		restartSandbox()
	
2172
2173
	test "No changes should be made to the string when trying to update a placeholder that doesn't exist", ()->
		objectB.prop1 = 'The size of this shirt is _____, man!'
		binding = SimplyBind('prop1').of(objectA).to('prop1.size').of(objectB)
2177
		binding.set 'Medium'
		expect(objectB.prop1).to.equal 'The size of this shirt is _____, man!'
		restartSandbox()
2181
2182
2183
	test "The updating value doesn't have to be a string", ()->
		objectB.prop1 = 'The size of this shirt is {{size}}, man!'
		binding = SimplyBind('prop1').of(objectA).to('prop1.size').of(objectB)
		binding.set false
		expect(objectB.prop1).to.equal 'The size of this shirt is false, man!'
		binding.set null
		expect(objectB.prop1).to.equal 'The size of this shirt is null, man!'
		binding.set {}
		expect(objectB.prop1).to.equal 'The size of this shirt is [object Object], man!'
2193
		restartSandbox()
2195
2196
2197
	test "If a property name has more than one period, only the first will be accounted for", ()->
		objectB.prop1 = 'The size of this shirt is {{size.redundant}}, man!'
		binding = SimplyBind('prop1').of(objectA).to('prop1.size.redundant').of(objectB)
		
		binding.set 'Medium'
		expect(objectB.prop1).to.equal 'The size of this shirt is Medium, man!'
		restartSandbox()
2205
2206
2207
	test "Custom placeholder markers can be set", ()->
		SimplyBind.setOption 'placeholder', ['^^', '$$']
		
		objectB.prop1 = 'The size of this shirt is ^^size$$, man!'
		
		binding = SimplyBind('prop1').of(objectA).to('prop1.size').of(objectB)
		binding.set 'XXS'
		
		expect(objectB.prop1).to.equal 'The size of this shirt is XXS, man!'
		SimplyBind.setOption 'placeholder', ['{{', '}}']
2218
		restartSandbox()
2220
2221
2222
	test "Target strings can have multiple placeholders", ()->
		dispatcher = 'value': 'Large'
2225
		objectA.prop = 'The size of this shirt is {{size}}, and {{size}} is {{size}}ly rad!'
		if isBrowser
			inputA.value = 'The size of this shirt is {{size}}, and {{size}} is {{size}}ly rad!'
			regA.textContent = 'The size of this shirt is {{size}}, and {{size}} is {{size}}ly rad!'
			regA.setAttribute 'someattr', 'The size of this shirt is {{size}}, and {{size}} is {{size}}ly rad!'
2231
		SimplyBind('value').of(dispatcher)
			.to('prop.size').of(objectA)
2234
		if isBrowser
			SimplyBind('value').of(dispatcher)
				.to('value.size').of(inputA)
				.and('textContent.size').of(regA)
				.and('attr:someattr.size').of(regA)
		
		expect(objectA.prop).to.equal 'The size of this shirt is Large, and Large is Largely rad!'
		if isBrowser
			expect(inputA.value).to.equal 'The size of this shirt is Large, and Large is Largely rad!'
			expect(regA.textContent).to.equal 'The size of this shirt is Large, and Large is Largely rad!'
			expect(regA.getAttribute 'someattr').to.equal 'The size of this shirt is Large, and Large is Largely rad!'
		restartSandbox()
2247
2248
2249
2250
	test "Multiple values can be set for the same target that has multiple placeholders", ()->
		dispatcher =
			'verb': 'not'
			'nounOne': 'small'
			'nounTwo': 'pretty'
2256
		objectB.prop = 'The following text is {{verb}} {{nounOne}} and {{nounTwo}}'
		if isBrowser
			inputB.value = 'The following text is {{verb}} {{nounOne}} and {{nounTwo}}'
			regB.setAttribute 'someattr', 'The following text is {{verb}} {{nounOne}} and {{nounTwo}}'
2261
		SimplyBind('verb').of(dispatcher)
			.to('prop.verb').of(objectB)
		
		if isBrowser
			SimplyBind('verb').of(dispatcher)
				.to('value.verb').of(inputB)
				.and('textContent.verb').of(regB)
				.and('attr:someattr.verb').of(regB)
		
2271
2272
		SimplyBind('nounOne').of(dispatcher)
			.to('prop.nounOne').of(objectB)
		
		if isBrowser
			SimplyBind('nounOne').of(dispatcher)
				.to('value.nounOne').of(inputB)
				.and('textContent.nounOne').of(regB)
				.and('attr:someattr.nounOne').of(regB)
		
2282
2283
		SimplyBind('nounTwo').of(dispatcher)
			.to('prop.nounTwo').of(objectB)
		
		if isBrowser
			SimplyBind('nounTwo').of(dispatcher)
				.to('value.nounTwo').of(inputB)
				.and('textContent.nounTwo').of(regB)
				.and('attr:someattr.nounTwo').of(regB)
		
2293
		values = ()-> if not isBrowser then [objectB.prop] else [objectB.prop, inputB.value, regB.textContent, regB.getAttribute 'someattr']
		for value in values()
			expect(value).to.equal 'The following text is not small and pretty'
2297
2298
2299
		dispatcher.verb = 'very'
		dispatcher.nounOne = 'big'
		dispatcher.nounTwo = 'ugly'
		for value in values()
			expect(value).to.equal 'The following text is very big and ugly'
2305
2306
		restartSandbox()
2308
2309
2310
2311
	test "Multiple values can be set for the same target that has multiple placeholders + transforms", ()->
		dispatcher =
			'verbOne': 'not'
			'verbTwo': 'not'
			'nounOne': 'small'
			'nounTwo': 'pretty'
2318
		objectC.prop = 'The following text is {{verbOne}} ({{verbTwo}}) {{nounOne}} and {{nounTwo}}'
		if isBrowser
			inputC.value = 'The following text is {{verbOne}} ({{verbTwo}}) {{nounOne}} and {{nounTwo}}'
			regC.textContent = 'The following text is {{verbOne}} ({{verbTwo}}) {{nounOne}} and {{nounTwo}}'
			regC.setAttribute 'someattr', 'The following text is {{verbOne}} ({{verbTwo}}) {{nounOne}} and {{nounTwo}}'
2324
2325
2326
		SimplyBind('verbOne').of(dispatcher)
			.to('prop.verbOne').of(objectC).transform (value)-> value.toUpperCase()
2329
		if isBrowser
			SimplyBind('verbOne').of(dispatcher)
				.to('value.verbOne').of(inputC)
				.and('textContent.verbOne').of(regC)
				.and('attr:someattr.verbOne').of(regC)
				.transformAll (value)-> value.toUpperCase()
2336
2337
2338
		SimplyBind('verbTwo').of(dispatcher)
			.to('prop.verbTwo').of(objectC).transform (value)-> value.toLowerCase()
2341
		if isBrowser
			SimplyBind('verbTwo').of(dispatcher)
				.to('value.verbTwo').of(inputC)
				.and('textContent.verbTwo').of(regC)
				.and('attr:someattr.verbTwo').of(regC)
				.transformAll (value)-> value.toLowerCase()
		
2349
2350
		SimplyBind('nounOne').of(dispatcher)
			.to('prop.nounOne').of(objectC).transform (value)-> value.toUpperCase()
2353
		if isBrowser
			SimplyBind('nounOne').of(dispatcher)
				.to('value.nounOne').of(inputC)
				.and('textContent.nounOne').of(regC)
				.and('attr:someattr.nounOne').of(regC)
				.transformAll (value)-> value.toUpperCase()
		
2361
2362
		SimplyBind('nounTwo').of(dispatcher)
			.to('prop.nounTwo').of(objectC).transform (value)-> value.toUpperCase()
2365
		if isBrowser
			SimplyBind('nounTwo').of(dispatcher)
				.to('value.nounTwo').of(inputC)
				.and('textContent.nounTwo').of(regC)
				.and('attr:someattr.nounTwo').of(regC)
				.transformAll (value)-> value.toUpperCase()
		
2373
2374
		values = ()-> if not isBrowser then [objectC.prop] else [objectC.prop, inputC.value, regC.textContent, regC.getAttribute 'someattr']
		for value in values()
			expect(value).to.equal 'The following text is NOT (not) SMALL and PRETTY'
2378
2379
		dispatcher.verbOne = dispatcher.verbTwo = 'Very'
		dispatcher.nounOne = 'Big'
		dispatcher.nounTwo = 'Ugly'
		for value in values()
			expect(value).to.equal 'The following text is VERY (very) BIG and UGLY'
2385
2386
		restartSandbox()
2388
2389
2390
2391
	test "Multiple placeholder bindings to textContent with multiple placeholders in a single textNode containing nested placeholders should function properly", ()-> if not isBrowser then @skip() else
		dispatcher = 'wordA':'', 'wordB':''
2394
		expect(regD.textContent).to.equal 'The following {{wordA}} and {{wordB}} replaced correctly'
2396
		SimplyBind('wordA').of(dispatcher)
			.to('textContent.wordA').of(regD)
2399
		SimplyBind('wordB').of(dispatcher)
			.to('textContent.wordB').of(regD)
2402
		expect(regD.textContent).to.equal 'The following  and  replaced correctly'
2404
2405
		dispatcher.wordA = 'firstWord'
		dispatcher.wordB = 'secondWord'
		expect(regD.textContent).to.equal 'The following firstWord and secondWord replaced correctly'
		restartSandbox()
2410
2411
2412
2413
	test "When an object prop with placeholders is an updater, it can either update individual placeholder values or its entire value", ()->
		window.dispatcher = 'nounA':'color', 'nounB':'car', 'adverb':'very', 'color':'red'
		window.receiver = 'prop':'The {{nounA}} of this {{nounB}} is {{adverb}} {{color}}'
		window.lastReceiver = 'prop':''
2418
		SimplyBind('nounA').of(dispatcher).to('prop.nounA').of(receiver)
		SimplyBind('nounB').of(dispatcher).to('prop.nounB').of(receiver)
		SimplyBind('adverb').of(dispatcher).to('prop.adverb').of(receiver)
		SimplyBind('color').of(dispatcher).to('prop.color').of(receiver)
		expect(receiver.prop).to.equal 'The color of this car is very red'
		
		SimplyBind('prop.nounA').of(receiver)
			.to('prop').of(lastReceiver)
2427
		expect(lastReceiver.prop).to.equal 'color'
		dispatcher.nounA = 'colour'
		expect(lastReceiver.prop).to.equal 'colour'
2431
2432
		SimplyBind('prop.nounB').of(receiver)
			.to('prop').of(lastReceiver)
2435
		expect(lastReceiver.prop).to.equal 'car'
		dispatcher.nounB = 'airplane'
		expect(lastReceiver.prop).to.equal 'airplane'
2439
2440
		SimplyBind('prop').of(receiver)
			.to('prop').of(lastReceiver)
2443
		expect(lastReceiver.prop).to.equal 'The colour of this airplane is very red'
2445
2446
2447
2448
	test "When manually changing the value of the prop after binding, the application of the placeholders will ignore the changes", ()-> if not isBrowser then @skip() else
		dispatcher = 'verb':'', 'nounOne':'', 'nounTwo':''
		objectA.prop1 = regB.textContent
2452
		SimplyBind('verb').of(dispatcher)
			.to('prop1.verb').of(objectA)
			.and('textContent.verb').of(regB)
		
		SimplyBind('nounOne').of(dispatcher)
			.to('prop1.nounOne').of(objectA)
			.and('textContent.nounOne').of(regB)
		
		SimplyBind('nounTwo').of(dispatcher)
			.to('prop1.nounTwo').of(objectA)
			.and('textContent.nounTwo').of(regB)
2464
		dispatcher.verb = 'looking'
		dispatcher.nounOne = 'nice'
		dispatcher.nounTwo = 'long'
		expect(objectA.prop1).to.equal 'The following text is looking nice and long'
		expect(objectA.prop1).to.equal(regB.textContent)
2470
2471
		upperCaseNodes = (nodes)-> for node in nodes
			if node.nodeType is 3
				node.textContent = node.textContent.toUpperCase()
			else
				upperCaseNodes(node)
		
		upperCaseNodes(regB.childNodes)
		objectA.prop1 = 'modified'
		
		dispatcher.verb = 'not looking'
		dispatcher.nounOne = 'ugly'
		dispatcher.nounTwo = 'short'
		expect(objectA.prop1).to.equal 'The following text is not looking ugly and short'
		expect(objectA.prop1).to.equal(regB.textContent)
2486
		# But new text nodes won't be replaced!
		$regBH1.append '<span> and some other attribute</span>'
		dispatcher.verb = 'looking'
		dispatcher.nounOne = 'nice'
		dispatcher.nounTwo = 'long'
		expect(objectA.prop1).to.equal 'The following text is looking nice and long'
		expect(regB.textContent).to.equal 'The following text is looking nice and long and some other attribute'
2494
2495
2496
2497
2498
2499
2500
2501
2502
2503
2504
suite "Binding-Type Specific", ()->
	suite "DOMValue", ()->
		suiteSetup ()-> if not isBrowser then @skip()
		test "Dispatching an event isn't necessary when updating the value for a binding's .set()/.update() method", ()->
			binding = SimplyBind('value').of(inputA).to('prop2').of(objectA)
			binding.set 'changed from binding instance'
			expect(objectA.prop2).to.equal 'changed from binding instance'
2512
2513
		test "Bindings to a DOM element's .value property will only create a DOMValue binding if it is an input/select/textarea field", ()->
			expect(SimplyBind('value').of(inputA)._.type).to.equal 'DOMValue'
			expect(SimplyBind('value').of(regA)._.type).to.equal 'ObjectProp'
			expect(SimplyBind('value').of(document)._.type).to.equal 'ObjectProp'
2518
2519
		test "When passing an element collection to .of() in the form of a jQuery object/NodeList/HTMLCollection, only the first element will be used", ()->
			SimplyBind('prop1').of(objectA)
				.to('value').of $inputA
				.and('value').of document.querySelectorAll('#input2')
			
			objectA.prop1 = 'updated'
			expect($inputA.val()).to.equal 'updated'
			expect($inputB.val()).to.equal 'updated'
			restartSandbox()
2529
2530
		test "A change event will be dispatched upon value update if SimplyBind.options.dispatchEvents is on", ()->
			invokeCountSelect = 0
			invokeCountRadio = 0
			SimplyBind.setOption 'dispatchEvents', true
			SimplyBind.setOption 'updateEvenIfSame', true
			
			
			SimplyBind('prop4').of(objectA)
				.to('value').of $select
				.and('checked').of $radioFields
			
			$select[0].on 'change', ()-> invokeCountSelect++
			$radioFields.each ()-> @on 'change', ()-> invokeCountRadio++
			objectA.prop4 = 'radioA'
			objectA.prop4 = 'radioB'
			objectA.prop4 = 'radioB'
			
2548
			expect(invokeCountSelect).to.equal 3
			expect(invokeCountRadio).to.equal 3
			
			SimplyBind.setOption 'dispatchEvents', false
			SimplyBind.setOption 'updateEvenIfSame', false
			restartSandbox()
2555
2556
2557
2558
2559
	suite "DOMCheckbox", ()->
		suiteSetup ()-> if not isBrowser then @skip()
		test "When attempting to bind a property other than 'checked' of a checkbox element list, only the first element will be used", ()->
			origLog = console.warn
			console.warn = chai.spy()
			SimplyBind('prop1').of(objectA)
				.to('newProp').of checkboxFields
				.and('newProp').of [].reverse.call($checkboxFields)
			
			objectA.prop1 = 'updated'
			expect(checkboxA.newProp).to.equal 'updated'
			expect(checkboxC.newProp).to.equal 'updated'
			expect(checkboxB.newProp).not.to.be.defined
			expect(console.warn).to.have.been.called()
2574
			console.warn = origLog
			restartSandbox()
2577
2578
		test "A change event will be dispatched upon value update if SimplyBind.options.dispatchEvents is on", ()->
			invokeCount = 0
			SimplyBind.setOption 'dispatchEvents', true
			SimplyBind.setOption 'updateEvenIfSame', true
			
			
			SimplyBind('prop4').of(objectA)
				.to('checked').of checkboxFields
			
			$checkboxFields.each ()-> @on 'change', ()-> invokeCount++
			objectA.prop4 = 'checkboxA'
			objectA.prop4 = 'checkboxB'
			objectA.prop4 = 'checkboxB'
			
			expect(invokeCount).to.equal 3
			
			SimplyBind.setOption 'dispatchEvents', false
			SimplyBind.setOption 'updateEvenIfSame', false
			restartSandbox()
2598
2599
		test "Initial checked values should be noted during initial binding", ()->
			expect(checkboxA.checked).to.be.false
			expect(checkboxB.checked).to.be.false
			expect(checkboxC.checked).to.be.false
2604
			checkboxB.checked = true
			checkboxC.checked = true
2607
			SimplyBind('checked').of(checkboxFields).to (checkedFields)->
				expect(checkedFields).to.be.instanceOf Array
				expect(checkedFields.length).to.equal 2
				expect(checkedFields[0]).to.equal 'checkboxB'
				expect(checkedFields[1]).to.equal 'checkboxC'
2613
2614
2615
2616
2617
	suite "DOMRadio", ()->
		suiteSetup ()-> if not isBrowser then @skip()
		test "When attempting to bind a property other than 'checked' of a radio element list, only the first element will be used", ()->
			origLog = console.warn
			console.warn = chai.spy()
			SimplyBind('prop1').of(objectA)
				.to('newProp').of radioFields
				.and('newProp').of [].reverse.call($radioFields)
			
			objectA.prop1 = 'updated'
			expect(radioA.newProp).to.equal 'updated'
			expect(radioC.newProp).to.equal 'updated'
			expect(radioB.newProp).not.to.be.defined
			expect(console.warn).to.have.been.called()
2632
			console.warn = origLog
			restartSandbox()
2635
2636
		test "A change event will be dispatched upon value update if SimplyBind.options.dispatchEvents is on", ()->
			invokeCount = 0
			SimplyBind.setOption 'dispatchEvents', true
			SimplyBind.setOption 'updateEvenIfSame', true
			
			
			SimplyBind('prop4').of(objectA)
				.to('checked').of radioFields
			
			$radioFields.each ()-> @on 'change', ()-> invokeCount++
			objectA.prop4 = 'radioA'
			objectA.prop4 = 'radioB'
			objectA.prop4 = 'radioB'
			
			expect(invokeCount).to.equal 3
			
			SimplyBind.setOption 'dispatchEvents', false
			SimplyBind.setOption 'updateEvenIfSame', false
			restartSandbox()
2656
2657
		test "Initial checked values should be noted during initial binding", ()->
			expect(radioA.checked).to.be.false
			expect(radioB.checked).to.be.false
			expect(radioC.checked).to.be.false
2662
			radioB.checked = true
2664
			SimplyBind('checked').of(radioFields).to (selectedRadio)->
				expect(selectedRadio).to.equal 'radioB'
2667
2668
2669
2670
	suite "DOMAttr", ()->
		suiteSetup ()-> if not isBrowser then @skip()
		test "Requires the 'attr:' prefix in the property name in order to bind the attribute values and not the property values", ()->
			nonPrefix = SimplyBind('first').of(regA).to('first').of(regB)
			withPrefix = SimplyBind('attr:second').of(regA).to('attr:second').of(regB)
2676
			nonPrefix.set 'someValue'
			expect(regA.first).to.equal 'someValue'
			expect(regB.first).to.equal 'someValue'
			expect(regA.getAttribute 'first').not.to.equal 'someValue'
			expect(regB.getAttribute 'first').not.to.equal 'someValue'
			
			withPrefix.set 'someValue'
			expect(regA.second).not.to.equal 'someValue'
			expect(regB.second).not.to.equal 'someValue'
			expect(regA.getAttribute 'second').to.equal 'someValue'
			expect(regB.getAttribute 'second').to.equal 'someValue'
			restartSandbox()
2689
2690
2691
	suite "Function", ()->
		test "Will be invoked on bind and have its return value used as the value that the dependents will receive", ()->
			SimplyBind ()-> 123
				.to('prop').of(objectA)
2696
			expect(objectA.prop).to.equal 123
		
2699
		test "Will be invoked on bind as a dependent and will receive 2 arguments - 1st is the new value passed while the 2nd is the prev value passed", ()->
			invokeCount = 0
			objectA.prop1 = 'some value'
			SimplyBind('prop1').of(objectA)
				.to (newValue, prevValue)->
					switch invokeCount
						when 0
							expect(newValue).to.equal 'some value'
							expect(prevValue).to.be.undefined
						when 1
							expect(newValue).to.equal 'new value'
							expect(prevValue).to.equal 'some value'
						when 2
							expect(newValue).to.equal 'newer value'
							expect(prevValue).to.equal 'new value'
					invokeCount++
2716
			objectA.prop1 = 'new value'
			objectA.prop1 = 'newer value'
2719
			restartSandbox()
2721
2722
		test "Will be invoked when is the first part of an argument regardless of whether or not SimplyBind.options.updateOnBind is on", ()->
			invokeCount = 0
			expect(SimplyBind.options.updateOnBind).to.be.true
			
			SimplyBind ()-> invokeCount++; 123
				.to('prop').of(objectA)
			expect(invokeCount).to.equal 1
2730
			
			SimplyBind.setOption 'updateOnBind', false
2733
			SimplyBind ()-> invokeCount++; 456
				.to('prop').of(objectA)
			expect(invokeCount).to.equal 2
2737
			SimplyBind.setOption 'updateOnBind', true
2739
2740
2741
2742
	suite "Array", ()->
		test "can bind an array to anything and update dependents even when calling the .push, .pop, .shift, .unshift, .splice, .reverse, and .sort methods", ()->
			sampleArray = [1,2,3,4,5,6,7,8,9,10]
			mutations = 0
			SimplyBind(sampleArray).to('prop4').of(objectB).and ()-> mutations++
2748
			expect(objectB.prop4.length).to.equal 10
			expect(mutations).to.equal 1
			sampleArray.push 11
			expect(objectB.prop4.length).to.equal 11
			expect(mutations).to.equal 2
			sampleArray.shift()
			sampleArray.shift()
			expect(objectB.prop4.length).to.equal 9
			expect(mutations).to.equal 4
			sampleArray.unshift 2
			sampleArray.unshift 1
			expect(objectB.prop4.length).to.equal 11
			expect(mutations).to.equal 6
			sampleArray.pop()
			sampleArray.pop()
			expect(objectB.prop4.length).to.equal 9
			expect(mutations).to.equal 8
			sampleArray.splice 0, 5
			expect(objectB.prop4.length).to.equal 4
			expect(mutations).to.equal 9
			sampleArray.reverse()
			expect(objectB.prop4.length).to.equal 4
			expect(mutations).to.equal 10
			sampleArray.sort()
			expect(objectB.prop4.length).to.equal 4
			expect(mutations).to.equal 11
			sampleArray.sort ()->
				1
			expect(objectB.prop4.length).to.equal 4
			expect(mutations).to.equal 12
2779
2780
2781
		test "it's impossible to replace the array object in an array binding.", ()->
			sampleArray = [1,2,3,4,5,6,7,8,9,10]
			mutations = 0
			SimplyBind(sampleArray).to('prop4').of(objectB).and ()-> mutations++
2786
			expect(objectB.prop4.length).to.equal 10
			expect(mutations).to.equal 1
			SimplyBind(sampleArray).set [1,2,3,4,5,6,7,8,9,10]
			# Replace array. If it were to replace it, the mutations count will increase by one.
			SimplyBind(sampleArray).set [1,2,3,4,5,6,7,8,9,10]
			SimplyBind(sampleArray).set [1,2,3,4,5,6,7,8,9,10]
			sampleArray.push 11
			expect(objectB.prop4.length).to.equal 11
			expect(mutations).to.equal 2
			sampleArray.shift()
			sampleArray.shift()
			expect(objectB.prop4.length).to.equal 9
			expect(mutations).to.equal 4
			sampleArray.unshift 2
			sampleArray.unshift 1
			expect(objectB.prop4.length).to.equal 11
			expect(mutations).to.equal 6
			sampleArray.pop()
			sampleArray.pop()
			expect(objectB.prop4.length).to.equal 9
			expect(mutations).to.equal 8
			sampleArray.splice 0, 5
			expect(objectB.prop4.length).to.equal 4
			expect(mutations).to.equal 9
2811
2812
2813
		test "will update dependents when its children get modified if specified via the trackArrayChildren option", ()->
			sampleArray = [1,2,3,4,5,6,7,8,9,10]
			sampleArray2 = [1,2,3,4,5,6,7,8,9,10]
			mutations = 0
			SimplyBind(sampleArray).to('prop5').of(objectA).and ()-> mutations++
2819
			expect(objectA.prop5).to.equal sampleArray
			sampleArray[0] = 100
			sampleArray[1] = 200
			sampleArray[2] = 300
			expect(objectA.prop5[0]).to.equal 100
			expect(objectA.prop5[1]).to.equal 200
			expect(objectA.prop5[2]).to.equal 300
			expect(mutations).to.equal 1
			mutations = 0
			SimplyBind(sampleArray2, 'trackArrayChildren': true).to('prop6').of(objectA).and ()-> mutations++
2830
			expect(objectA.prop6).to.equal sampleArray2
			sampleArray2[0] = 100
			sampleArray2[1] = 200
			sampleArray2[2] = 300
			expect(objectA.prop6[0]).to.equal 100
			expect(objectA.prop6[1]).to.equal 200
			expect(objectA.prop6[2]).to.equal 300
			expect(mutations).to.equal 4
2839
2840
2841
		test "will update dependents even when there is a sepearate binding on a reference of the same array", ()->
			sampleArrayA = [1,2,3,4,5,6,7,8,9,10]
			sampleArrayB = sampleArrayA
			mutationsA = 0
			mutationsB = 0
			SimplyBind(sampleArrayA)
				.to('prop6').of(objectA)
				.and ()-> mutationsA++
			
			SimplyBind(sampleArrayB)
				.to('prop6').of(objectB)
				.and ()-> mutationsB++
2854
			expect(sampleArrayA).to.equal sampleArrayB
			expect(mutationsA).to.equal 1
			expect(mutationsB).to.equal 1
			sampleArrayA.push 11
			sampleArrayA.push 12
			sampleArrayB.push 13
			sampleArrayB.push 14
			expect(mutationsA).to.equal 5
			expect(mutationsB).to.equal 5
2864
2865
		test "Will update Func dependents with a clone to prevent possible infinite loops and for comparison", ()->
			receivedValues = 'current':null, 'prev':null
			middleMan = 'value':null
			prevCurrent = null
			
			SimplyBind(arrayA).to (currentArray, prevArray)->
				receivedValues.current = currentArray
				receivedValues.prev = prevArray
2874
			prevCurrent = receivedValues.current
			expect(receivedValues.current).to.be.instanceOf(Array)
			expect(receivedValues.current.length).to.equal(arrayA.length)
			expect(receivedValues.current).not.to.equal(arrayA)
			expect(receivedValues.prev).to.be.undefined
2880
			arrayA.push(10)
			expect(receivedValues.current.length).to.equal(arrayA.length)
			expect(receivedValues.current).not.to.equal(arrayA)
			expect(receivedValues.current).not.to.equal(prevCurrent)
			expect(receivedValues.prev).to.equal(prevCurrent)
2886
2887
			SimplyBind(arrayB)
				.to('value').of(middleMan).transform (array)-> array.length
				.chainTo (currentArray, prevArray)->
					receivedValues.current = currentArray
					receivedValues.prev = prevArray
2893
			arrayB.unshift(-1)
			expect(middleMan.value).to.equal(arrayB.length)
			expect(receivedValues.current).to.equal(arrayB.length)
2897
			restartSandbox()
2899
2900
2901
2902
2903
	suite "Event", ()->
		test "The specified selector will indicate which argument index of the event emitter callback should be saved to the binding", ()->
			emptyObj = {}
			sampleObject = 'holder': emptyObj
2908
			SimplyBind(0).ofEvent('focus').of(eventEmitterA)
				.to('holder').of sampleObject
			
			expect(sampleObject.holder).to.equal emptyObj
			
			eventEmitterA.emit 'focus', eventEmitterA
			if isBrowser
				expect(sampleObject.holder.target).to.equal eventEmitterA
			else
				expect(sampleObject.holder).to.equal eventEmitterA
2919
			restartSandbox()
2921
2922
2923
2924
		test "Custom events will behave exactly like regular events", ()->
			emptyObj = {}
			sampleObject = 'holder': emptyObj
2928
			SimplyBind(0).ofEvent('somethingCustom').of(eventEmitterA).to('holder').of sampleObject
			expect(sampleObject.holder).to.equal emptyObj
2931
			eventEmitterA.emit 'somethingCustom', eventEmitterA
			if isBrowser
				expect(sampleObject.holder.target).to.equal eventEmitterA
			else
				expect(sampleObject.holder).to.equal eventEmitterA
2937
2938
2939
2940
		test "Custom listener/emitter methods can be used", ()->
			emitCount = 0
			receiveCount = 0
			$eventEmitterA.customListener 'click', ()-> emitCount++
2945
			SimplyBind('prop2').of(objectA)
				.toEvent('click', 'customEmitter', 'customListener').of($eventEmitterA).bothWays ()-> ++receiveCount
			expect(emitCount).to.equal 1
			expect(receiveCount).to.equal 0
			
			objectA.prop2 = 'whatever'
			expect(emitCount).to.equal 2
			
			$eventEmitterA.customEmitter 'click'
			expect(receiveCount).to.equal 1
			expect(objectA.prop2).to.equal 1
			expect(emitCount).to.equal 3
			
			objectA.prop2 = 'whatever again'
			expect(emitCount).to.equal 4
			
			$eventEmitterA.customEmitter 'click'
			expect(receiveCount).to.equal 2
			expect(objectA.prop2).to.equal 2
			restartSandbox()
2966
2967
2968
2969
		test "jQuery listener/emitter methods can be used", ()-> if not isBrowser then @skip() else
			emitCount = 0
			receiveCount = 0
			$eventEmitterA.on 'click', ()-> emitCount++
2974
			SimplyBind('prop2').of(objectA)
				.toEvent('click', 'trigger', 'on').of($eventEmitterA).bothWays ()-> ++receiveCount
			expect(emitCount).to.equal 1
			expect(receiveCount).to.equal 0
			
			objectA.prop2 = 'whatever'
			expect(emitCount).to.equal 2
			
			$eventEmitterA.trigger 'click'
			expect(receiveCount).to.equal 1
			expect(objectA.prop2).to.equal 1
			expect(emitCount).to.equal 3
			
			objectA.prop2 = 'whatever again'
			expect(emitCount).to.equal 4
			
			$eventEmitterA.trigger 'click'
			expect(receiveCount).to.equal 2
			expect(objectA.prop2).to.equal 2
			restartSandbox()
2995
2996
2997
2998
		test "Default listener/emitter methods will be used if custom listener/emitter methods don't exist on the target object", ()->
			emitCount = 0
			receiveCount = 0
			$eventEmitterA.customListener 'click', ()-> emitCount++
3003
			SimplyBind('prop2').of(objectA)
				.toEvent('click', 'nonexistentDispatcher', 'nonexistentListener').of($eventEmitterA).bothWays ()-> ++receiveCount
			expect(emitCount).to.equal 1
			expect(receiveCount).to.equal 0
			
			objectA.prop2 = 'whatever'
			expect(emitCount).to.equal 2
			
			$eventEmitterA.customEmitter 'click'
			expect(receiveCount).to.equal 1
			expect(objectA.prop2).to.equal 1
			expect(emitCount).to.equal 3
			
			objectA.prop2 = 'whatever again'
			expect(emitCount).to.equal 4
			
			$eventEmitterA.customEmitter 'click'
			expect(receiveCount).to.equal 2
			expect(objectA.prop2).to.equal 2
			restartSandbox()
3024
3025
3026
3027
3028
3029
3030
3031
3032
suite "Create bindings to/from multiple objects using the 'multi:' descriptor as a shortcut", ()->
3034
	suite "Basic Bindings", ()->
		test "Binding single prop to multiple ObjectProps", ()->
			dispatcher = 'prop':'value1'
			objectA.prop1 = objectB.prop1 = objectC.prop1 = null
3039
			SimplyBind('prop').of(dispatcher)
				.to('multi:prop1').of([objectA, objectB, objectC])
3042
			expect(objectA.prop1).to.equal 'value1'
			expect(objectB.prop1).to.equal 'value1'
			expect(objectC.prop1).to.equal 'value1'
3046
			dispatcher.prop = 'value2'
			expect(objectA.prop1).to.equal 'value2'
			expect(objectB.prop1).to.equal 'value2'
			expect(objectC.prop1).to.equal 'value2'
3051
			restartSandbox()
3053
3054
3055
		test "Binding multiple ObjectProp to a single prop", ()->
			receiver = 'prop':null
			objectA.prop1 = objectB.prop1 = objectC.prop1 = 'value1'
3059
			SimplyBind('multi:prop1').of([objectA, objectB, objectC])
				.to('prop').of(receiver)
3062
			expect(receiver.prop).to.equal 'value1'
			expect(objectA.prop1).to.equal 'value1'
			expect(objectB.prop1).to.equal 'value1'
			expect(objectC.prop1).to.equal 'value1'
3067
			objectA.prop1 = 'value2'
			expect(receiver.prop).to.equal 'value2'
			expect(objectA.prop1).to.equal 'value2'
			expect(objectB.prop1).to.equal 'value1'
			expect(objectC.prop1).to.equal 'value1'
3073
			objectB.prop1 = 'value3'
			expect(receiver.prop).to.equal 'value3'
			expect(objectA.prop1).to.equal 'value2'
			expect(objectB.prop1).to.equal 'value3'
			expect(objectC.prop1).to.equal 'value1'
3079
			objectC.prop1 = 'value4'
			expect(receiver.prop).to.equal 'value4'
			expect(objectA.prop1).to.equal 'value2'
			expect(objectB.prop1).to.equal 'value3'
			expect(objectC.prop1).to.equal 'value4'
3085
			restartSandbox()
3087
3088
3089
		test "Binding multiple ObjectProp to a single prop both ways", ()->
			receiverDispatcher = 'prop':'valueP1'
			objectA.prop1 = objectB.prop1 = objectC.prop1 = 'value1'
3093
			SimplyBind('multi:prop1').of([objectA, objectB, objectC])
				.to('prop').of(receiverDispatcher).bothWays()
3096
			expect(receiverDispatcher.prop).to.equal 'value1'
			expect(objectA.prop1).to.equal 'value1'
			expect(objectB.prop1).to.equal 'value1'
			expect(objectC.prop1).to.equal 'value1'
3101
			objectA.prop1 = 'value2'
			expect(receiverDispatcher.prop).to.equal 'value2'
			expect(objectA.prop1).to.equal 'value2'
			expect(objectB.prop1).to.equal 'value2'
			expect(objectC.prop1).to.equal 'value2'
3107
			objectB.prop1 = 'value3'
			receiverDispatcher.prop = 'valueP3'
			expect(receiverDispatcher.prop).to.equal 'valueP3'
			expect(objectA.prop1).to.equal 'valueP3'
			expect(objectB.prop1).to.equal 'valueP3'
			expect(objectC.prop1).to.equal 'valueP3'
3114
			objectC.prop1 = 'value4'
			expect(receiverDispatcher.prop).to.equal 'value4'
			expect(objectA.prop1).to.equal 'value4'
			expect(objectB.prop1).to.equal 'value4'
			expect(objectC.prop1).to.equal 'value4'
3120
			restartSandbox()
3122
3123
3124
3125
3126
	suite "Transform Bindings", ()->
		test "Binding single prop to multiple ObjectProps + transform", ()->
			dispatcher = 'prop':'value1'
			objectA.prop1 = objectB.prop1 = objectC.prop1 = null
3131
			SimplyBind('prop').of(dispatcher)
				.to('multi:prop1').of([objectA, objectB, objectC])
					.transform (value)-> value.toUpperCase()
3135
			dispatcher.prop = 'value2'
			expect(dispatcher.prop).to.equal 'value2'
			expect(objectA.prop1).to.equal 'VALUE2'
			expect(objectB.prop1).to.equal 'VALUE2'
			expect(objectC.prop1).to.equal 'VALUE2'
3141
			restartSandbox()
3143
3144
3145
		test "Binding multiple ObjectProp to a single prop + transform", ()->
			receiver = 'prop':null
			objectA.prop1 = objectB.prop1 = objectC.prop1 = 'value1'
3149
			SimplyBind('multi:prop1').of([objectA, objectB, objectC])
				.to('prop').of(receiver)
					.transform (value)-> value.toUpperCase()
3153
3154
			objectA.prop1 = 'value2'
			expect(receiver.prop).to.equal 'VALUE2'
			expect(objectA.prop1).to.equal 'value2'
			expect(objectB.prop1).to.equal 'value1'
			expect(objectC.prop1).to.equal 'value1'
3160
			objectB.prop1 = 'value3'
			expect(receiver.prop).to.equal 'VALUE3'
			expect(objectA.prop1).to.equal 'value2'
			expect(objectB.prop1).to.equal 'value3'
			expect(objectC.prop1).to.equal 'value1'
3166
			objectC.prop1 = 'value4'
			expect(receiver.prop).to.equal 'VALUE4'
			expect(objectA.prop1).to.equal 'value2'
			expect(objectB.prop1).to.equal 'value3'
			expect(objectC.prop1).to.equal 'value4'
3172
			restartSandbox()
3174
3175
3176
		test "Binding multiple ObjectProp to a single prop both ways + transform", ()->
			receiverDispatcher = 'prop':'valueP1'
			objectA.prop1 = objectB.prop1 = objectC.prop1 = 'value1'
3180
			SimplyBind('multi:prop1').of([objectA, objectB, objectC])
				.to('prop').of(receiverDispatcher).bothWays()
					.transform (value)-> value.toUpperCase()
3184
			objectA.prop1 = 'value2'
			expect(receiverDispatcher.prop).to.equal 'VALUE2'
			expect(objectA.prop1).to.equal 'value2'
			expect(objectB.prop1).to.equal 'VALUE2'
			expect(objectC.prop1).to.equal 'VALUE2'
3190
			objectB.prop1 = 'value3'
			receiverDispatcher.prop = 'valueP3'
			expect(receiverDispatcher.prop).to.equal 'valueP3'
			expect(objectA.prop1).to.equal 'VALUEP3'
			expect(objectB.prop1).to.equal 'VALUEP3'
			expect(objectC.prop1).to.equal 'VALUEP3'
3197
			objectC.prop1 = 'value4'
			expect(receiverDispatcher.prop).to.equal 'VALUE4'
			expect(objectA.prop1).to.equal 'VALUE4'
			expect(objectB.prop1).to.equal 'VALUE4'
			expect(objectC.prop1).to.equal 'value4'
3203
			restartSandbox()
3205
3206
3207
3208
3209
	suite "Condition Bindings", ()->
		test "Binding single prop to multiple ObjectProps + condition", ()->
			dispatcher = 'prop':'value1'
			objectA.prop1 = objectB.prop1 = objectC.prop1 = null
			allowUpdate = false
3215
			SimplyBind('prop', {updateOnBind:false}).of(dispatcher)
				.to('multi:prop1').of([objectA, objectB, objectC])
					.condition ()-> allowUpdate
3219
			expect(objectA.prop1).to.equal null
			expect(objectB.prop1).to.equal null
			expect(objectC.prop1).to.equal null
3223
			dispatcher.prop = 'value2'
			expect(dispatcher.prop).to.equal 'value2'
			expect(objectA.prop1).to.equal null
			expect(objectB.prop1).to.equal null
			expect(objectC.prop1).to.equal null
3229
			allowUpdate = true
			dispatcher.prop = 'value3'
			expect(dispatcher.prop).to.equal 'value3'
			expect(objectA.prop1).to.equal 'value3'
			expect(objectB.prop1).to.equal 'value3'
			expect(objectC.prop1).to.equal 'value3'
3236
			restartSandbox()
3238
3239
3240
		test "Binding multiple ObjectProp to a single prop + condition", ()->
			receiver = 'prop':null
			objectA.prop1 = objectB.prop1 = objectC.prop1 = 'value1'
			allowUpdate = false
3245
			SimplyBind('multi:prop1', {updateOnBind:false}).of([objectA, objectB, objectC])
				.to('prop').of(receiver)
					.condition ()-> allowUpdate
3249
			expect(receiver.prop).to.equal null
			expect(objectA.prop1).to.equal 'value1'
			expect(objectB.prop1).to.equal 'value1'
			expect(objectC.prop1).to.equal 'value1'
3254
			objectA.prop1 = 'value2'
			expect(receiver.prop).to.equal null
			expect(objectA.prop1).to.equal 'value2'
			expect(objectB.prop1).to.equal 'value1'
			expect(objectC.prop1).to.equal 'value1'
3260
			allowUpdate = true
			objectB.prop1 = 'value3'
			expect(receiver.prop).to.equal 'value3'
			expect(objectA.prop1).to.equal 'value2'
			expect(objectB.prop1).to.equal 'value3'
			expect(objectC.prop1).to.equal 'value1'
3267
			restartSandbox()
3269
3270
3271
		test "Binding multiple ObjectProp to a single prop both ways + condition", ()->
			receiverDispatcher = 'prop':'valueP1'
			objectA.prop1 = objectB.prop1 = objectC.prop1 = 'value1'
			allowUpdate = false
3276
			SimplyBind('multi:prop1', {updateOnBind:false}).of([objectA, objectB, objectC])
				.to('prop').of(receiverDispatcher).bothWays()
					.condition ()-> allowUpdate
			
			expect(receiverDispatcher.prop).to.equal 'valueP1'
			expect(objectA.prop1).to.equal 'value1'
			expect(objectB.prop1).to.equal 'value1'
			expect(objectC.prop1).to.equal 'value1'
3285
			objectA.prop1 = 'value2'
			expect(receiverDispatcher.prop).to.equal 'valueP1'
			expect(objectA.prop1).to.equal 'value2'
			expect(objectB.prop1).to.equal 'value1'
			expect(objectC.prop1).to.equal 'value1'
3291
			allowUpdate = true
			receiverDispatcher.prop = 'valueP3'
			expect(receiverDispatcher.prop).to.equal 'valueP3'
			expect(objectA.prop1).to.equal 'valueP3'
			expect(objectB.prop1).to.equal 'valueP3'
			expect(objectC.prop1).to.equal 'valueP3'
3298
			objectC.prop1 = 'value4'
			expect(receiverDispatcher.prop).to.equal 'value4'
			expect(objectA.prop1).to.equal 'value4'
			expect(objectB.prop1).to.equal 'value4'
			expect(objectC.prop1).to.equal 'value4'
3304
			restartSandbox()
3306
3307
3308
3309
	suite "Miscellenious", ()->
		test "Binding single prop to multiple ObjectProps' placeholders", ()->
			dispatcher = 'prop':'word'
			objectA.prop1 = objectB.prop1 = objectC.prop1 = 'some {{noun}} here'
3314
			SimplyBind('prop').of(dispatcher)
				.to('multi:prop1.noun').of([objectA, objectB, objectC])
3317
			expect(objectA.prop1).to.equal 'some word here'
			expect(objectB.prop1).to.equal 'some word here'
			expect(objectC.prop1).to.equal 'some word here'
3321
			dispatcher.prop = 'letter'
			expect(objectA.prop1).to.equal 'some letter here'
			expect(objectB.prop1).to.equal 'some letter here'
			expect(objectC.prop1).to.equal 'some letter here'
3326
			restartSandbox()
		
3329
3330
		test "Fetching the value using the .get() method of a multi binding should yield an array of all the values", ()->
			objectA.prop1 = 'A'
			objectB.prop1 = 'B'
			objectC.prop1 = 'C'
3335
			binding = SimplyBind('multi:prop1').of([objectA, objectB, objectC])
			values = binding.get()
3338
			expect(objectA.prop1).to.equal 'A'
			expect(objectB.prop1).to.equal 'B'
			expect(objectC.prop1).to.equal 'C'
			expect(values).to.be.instanceOf Array
			expect(values[0]).to.equal 'A'
			expect(values[1]).to.equal 'B'
			expect(values[2]).to.equal 'C'
3346
			restartSandbox()
		
3349
3350
		test "Fetching the value using the .get() method of a multi binding w/ placeholders should yield an the value of the first binding only", ()->
			dispatcher = 'prop':'word'
			objectA.prop1 = objectB.prop1 = objectC.prop1 = 'some {{noun}} here'
3354
			SimplyBind('prop').of(dispatcher)
				.to('multi:prop1.noun').of([objectA, objectB, objectC])
3357
			binding = SimplyBind('multi:prop1.noun').of([objectA, objectB, objectC])
			value = binding.get()
3360
			expect(objectA.prop1).to.equal 'some word here'
			expect(objectB.prop1).to.equal 'some word here'
			expect(objectC.prop1).to.equal 'some word here'
			expect(value).to.equal 'word'
3365
			restartSandbox()
3367
3368
3369
		test "Binding single prop to multiple ObjectProps with a self transform should be applied to all bindings", ()->
			dispatcher = 'prop':'value1'
			objectA.prop1 = objectB.prop1 = objectC.prop1 = null
3373
			SimplyBind('prop').of(dispatcher)
				.to('multi:prop1').of([objectA, objectB, objectC])
3376
			SimplyBind('multi:prop1.noun').of([objectA, objectB, objectC])
				.transformSelf (value)-> value.toUpperCase()
3379
			expect(objectA.prop1).to.equal 'VALUE1'
			expect(objectB.prop1).to.equal 'VALUE1'
			expect(objectC.prop1).to.equal 'VALUE1'
3383
			dispatcher.prop = 'value2'
			expect(objectA.prop1).to.equal 'VALUE2'
			expect(objectB.prop1).to.equal 'VALUE2'
			expect(objectC.prop1).to.equal 'VALUE2'
3388
			restartSandbox()
3390
3391
3392
		test ".throttle() on a multi binding will throttle the dep update frequency to once in a given timeframe", (done)->
			invokeCount = 0
			lastValue = null
			objectA.prop1 = objectB.prop1 = objectC.prop1 = 'same'
3397
			SimplyBind('multi:prop1').of([objectA, objectB, objectC])
				.to (v)-> lastValue=v; invokeCount++
				.throttle(15)
3401
			expect(invokeCount).to.equal(3)
			expect(lastValue).to.equal 'same'
3404
			objectA.prop1 = 'another1'
			objectA.prop1 = 'another2'
			objectA.prop1 = 'another3'
			objectA.prop1 = 'another4'
			expect(invokeCount).to.equal(4)
			expect(lastValue).to.equal('another1')
3411
			objectB.prop1 = 'another5'
			expect(lastValue).to.equal('another5')
			expect(invokeCount).to.equal(5)
3415
			objectC.prop1 = 'another6'
			expect(lastValue).to.equal('another6')
			expect(invokeCount).to.equal(6)
			
			objectC.prop1 = 'another7'
			expect(invokeCount).to.equal(6)
			expect(lastValue).to.equal('another6')
3423
			setTimeout ()->
				expect(invokeCount).to.equal(8)
				expect(lastValue).to.equal('another7')
				done()
				restartSandbox()
			, 25
3430
3431
3432
		test "Using the 'multi:' descriptor on a empty DOM list should throw an error", ()->
			expect ()-> SimplyBind('multi:prop').of($('nonexistent'))
				.to.throw()
			
			expect ()-> SimplyBind('multi:prop').of(document.querySelectorAll('nonexistent'))
				.to.throw()
3439
			expect ()-> SimplyBind('multi:prop').of([])
				.to.throw()
3442
			restartSandbox()
3444
3445
3446
	suite "Unbinding", ()->
		test "Binding single prop to multiple ObjectProps and then calling .unBind() should unbind all", ()->
			dispatcher = 'prop':'value1'
			objectA.prop1 = objectB.prop1 = objectC.prop1 = null
3451
			binding = SimplyBind('prop').of(dispatcher)
				.to('multi:prop1').of([objectA, objectB, objectC])
3454
			expect(objectA.prop1).to.equal 'value1'
			expect(objectB.prop1).to.equal 'value1'
			expect(objectC.prop1).to.equal 'value1'
3458
			binding.unBind()
3460
			dispatcher.prop = 'value2'
			expect(objectA.prop1).to.equal 'value1'
			expect(objectB.prop1).to.equal 'value1'
			expect(objectC.prop1).to.equal 'value1'
3465
			restartSandbox()
		
3468
3469
		test "Binding multiple ObjectProps to a single prop and then calling .unBind() should unbind all props from that single prop", ()->
			receiver = 'prop':null
			objectA.prop1 = objectB.prop1 = objectC.prop1 = 'value1'
3473
			binding = SimplyBind('multi:prop1').of([objectA, objectB, objectC])
				.to('prop').of(receiver)
3476
			expect(receiver.prop).to.equal 'value1'
			expect(objectA.prop1).to.equal 'value1'
			expect(objectB.prop1).to.equal 'value1'
			expect(objectC.prop1).to.equal 'value1'
3481
			binding.unBind()
			
			objectA.prop1 = 'value2'
			expect(receiver.prop).to.equal 'value1'
			expect(objectA.prop1).to.equal 'value2'
			expect(objectB.prop1).to.equal 'value1'
			expect(objectC.prop1).to.equal 'value1'
3489
			objectB.prop1 = 'value3'
			expect(receiver.prop).to.equal 'value1'
			expect(objectA.prop1).to.equal 'value2'
			expect(objectB.prop1).to.equal 'value3'
			expect(objectC.prop1).to.equal 'value1'
3495
			objectC.prop1 = 'value4'
			expect(receiver.prop).to.equal 'value1'
			expect(objectA.prop1).to.equal 'value2'
			expect(objectB.prop1).to.equal 'value3'
			expect(objectC.prop1).to.equal 'value4'
3501
			restartSandbox()
3503
3504
3505
3506
3507
3508
3509
3510
3511
3512
3513
3514
suite "Stage 3 methods", ()->
suite ".and()", ()->
	suiteSetup(restartSandbox)
	test "Behaves just like .to() which allows to bind a value to multiple targets", ()->
		SimplyBind('prop1').of(objectA)
			.to('prop1').of(objectB)
			.and('prop2').of(objectB)
			.and('prop3').of(objectB)
			.and('prop4').of(objectB)
	
		objectA.prop1 = 'all at once'
		expect(objectB.prop1).to.equal 'all at once'
		expect(objectB.prop2).to.equal 'all at once'
		expect(objectB.prop3).to.equal 'all at once'
		expect(objectB.prop4).to.equal 'all at once'
		restartSandbox()
3531
3532
3533
3534
3535
3536
3537
3538
3539
3540
3541
3542
3543
3544
3545
3546
3547
3548
suite ".chainTo()/.pipe()", ()->
	suiteSetup(restartSandbox)
	
	test "Helps create complex chainings", ()->
		outerstate = 
			'first': null
			'second': null
			'third': null
	
		objectA.prop1 = 'Hello World'
		SimplyBind('prop1').of(objectA)
			.to('prop1').of(objectB)
			.and('prop2').of(objectA)
			.and (val)-> outerstate.first = val
				.transformAll (val)-> val.toUpperCase()
			
			.chainTo('prop2').of(objectB)
				.and('prop3').of(objectA)
					.transform (val)-> val.toLowerCase()
			
					.chainTo('prop3').of(objectB)
						.and('prop4').of(objectA)
						.and (val)-> outerstate.second = val
			
						.chainTo('prop4').of(objectB)
							.and (val)-> outerstate.third = val.slice(0, 5)
3575
3576
3577
		expect(outerstate.first).to.equal 'HELLO WORLD'
		expect(outerstate.second).to.equal 'hello world'
		expect(outerstate.third).to.equal 'hello'
		expect(objectA.prop1).to.equal 'Hello World'
		expect(objectA.prop2).to.equal 'HELLO WORLD'
		expect(objectB.prop1).to.equal 'HELLO WORLD'
		expect(objectB.prop2).to.equal 'HELLO WORLD'
		expect(objectA.prop3).to.equal 'hello world'
		expect(objectB.prop3).to.equal 'hello world'
		expect(objectA.prop4).to.equal 'hello world'
		expect(objectB.prop4).to.equal 'hello world'
		restartSandbox()
3590
	
3592
3593
3594
3595
3596
3597
3598
3599
3600
3601
3602
3603
3604
3605
3606
3607
3608
3609
suite ".transform()", ()->
	suiteSetup(restartSandbox)
	test "Will apply a transformation to the value before updating the dependent", ()->
		dispatcher = 'value': 'current'
		transformFn = (newValue, currentValue)-> newValue+'+'+currentValue
3615
		objectA.prop = ''
		if isBrowser
			inputA.value = ''
			regA.textContent = ''
			regA.setAttribute 'someattr', ''
3621
		SimplyBind('value').of(dispatcher)
			.to('prop').of(objectA).transform(transformFn)
3624
		if isBrowser
			SimplyBind('value').of(dispatcher)
				.to('value').of(inputA).transform(transformFn)
				.and('textContent').of(regA).transform(transformFn)
				.and('attr:someattr').of(regA).transform(transformFn)
3630
3631
		values = ()-> if not isBrowser then [objectA.prop] else [objectA.prop, inputA.value, regA.textContent, regA.getAttribute 'someattr']
		for value in values()
			expect(value).to.equal 'current+current'
		
		
		dispatcher.value = 'new'
		for value in values()
			expect(value).to.equal 'new+current+current'
		
		
		dispatcher.value = 'new'
		for value in values()
			expect(value).to.equal 'new+current+current'
		
		
		dispatcher.value = 'newer'
		for value in values()
			expect(value).to.equal 'newer+new+current+current'
3650
		restartSandbox()
3652
3653
3654
3655
	test "Will apply transformations to event bindings", ()-> if not isBrowser then @skip() else
		resultHolder = 'event':null
3658
		SimplyBind(0).ofEvent('someEvent').of(eventEmitterA)
			.to('event').of(resultHolder)
				.transform (event)-> event.type
3662
		eventEmitterA.emit 'someEvent'
		expect(resultHolder.event).to.equal 'someEvent'
3665
3666
3667
3668
	test "Will cause a re-update only to the last proxied dependent", ()->
		invokeCount = 
			'A':0
			'B':0
			'C':0
3674
		SimplyBind('prop1').of(objectA)
			.to ()-> invokeCount.A++
				.transform (v)-> v
			.and ()-> invokeCount.B++
				.transform (v)-> v
			.and ()-> invokeCount.C++
				.transform (v)-> v
3682
		expect(invokeCount.A).to.equal 2
		expect(invokeCount.B).to.equal 2
		expect(invokeCount.C).to.equal 2
3686
		objectA.prop1 = !objectA.prop1
		expect(invokeCount.A).to.equal 3
		expect(invokeCount.B).to.equal 3
		expect(invokeCount.C).to.equal 3
3691
3692
3693
	test "Promise transforms can be used instead of regular return values if SimplyBind.options.promiseTransforms is on", (done)->
		objectA.prop2 = 'current'
		
		SimplyBind('prop1', {'updateOnBind':false}).of(objectA)
			.to (result)-> expect(result.then).not.to.be.undefined
			.transform ()-> new Promise ()->
3700
		SimplyBind('prop2', {'promiseTransforms':true}).of(objectA)
			.to('prop2').of(objectB)
			.transform (newValue, currentValue)-> new Promise (resolve)-> resolve(newValue+'+'+currentValue)
3704
		setTimeout ()->
			expect(objectB.prop2).to.equal 'current+current'
			objectA.prop2 = 'new'
			
			setTimeout ()->
				expect(objectB.prop2).to.equal 'new+current+current'
				restartSandbox()
				done()
			, 0
		, 0
3715
3716
3717
3718
	test "A transform will only be used for the last declared dependent", ()->
		dispatcher = 'value': 'test'
		objectA.prop1 = ''
		objectB.prop1 = ''
3723
		SimplyBind('value').of(dispatcher)
			.to('prop1').of(objectA)
			.and('prop1').of(objectB)
				.transform (value)-> value.toUpperCase()
3728
		expect(objectA.prop1).to.equal 'test'
		expect(objectB.prop1).to.equal 'TEST'
3731
		restartSandbox()
3733
3734
3735
	test "A transform will be used both ways when .bothWays() is called after the .transform declaration", ()->
		dispatcher = 'value': 'test'
		objectA.prop = ''
3739
		SimplyBind('value').of(dispatcher)
			.to('prop').of(objectA)
				.transform (value)-> value.toUpperCase()
				.bothWays()
3744
		expect(dispatcher.value).to.equal 'test'
		expect(objectA.prop).to.equal 'TEST'
		
		dispatcher.value = 'from dispatcher'
		expect(dispatcher.value).to.equal 'from dispatcher'
		expect(objectA.prop).to.equal 'FROM DISPATCHER'
		
		objectA.prop = 'from objectA'
		expect(dispatcher.value).to.equal 'FROM OBJECTA'
		expect(objectA.prop).to.equal 'from objectA'
3755
		restartSandbox()
3757
3758
3759
	test "A transform will be used both ways when .bothWays() is called before the .transform declaration", ()->
		dispatcher = 'value': 'test'
		objectA.prop = ''
3763
		SimplyBind('value').of(dispatcher)
			.to('prop').of(objectA).bothWays()
				.transform (value)-> value.toUpperCase()
3767
		expect(dispatcher.value).to.equal 'test'
		expect(objectA.prop).to.equal 'TEST'
		
		dispatcher.value = 'from dispatcher'
		expect(dispatcher.value).to.equal 'from dispatcher'
		expect(objectA.prop).to.equal 'FROM DISPATCHER'
		
		objectA.prop = 'from objectA'
		expect(dispatcher.value).to.equal 'FROM OBJECTA'
		expect(objectA.prop).to.equal 'from objectA'
3778
		restartSandbox()
3780
3781
3782
	test "A different transform will be used backwards if a function is passed to .bothWays() as the first argument", ()->
		dispatcher = 'value': 'test'
		objectA.prop = ''
3786
		SimplyBind('value').of(dispatcher)
			.to('prop').of(objectA)
				.transform (value)-> value.toUpperCase()
				.bothWays (value)-> value.toLowerCase()
3791
		expect(dispatcher.value).to.equal 'test'
		expect(objectA.prop).to.equal 'TEST'
		
		dispatcher.value = 'From Dispatcher'
		expect(dispatcher.value).to.equal 'From Dispatcher'
		expect(objectA.prop).to.equal 'FROM DISPATCHER'
		
		objectA.prop = 'From ObjectA'
		expect(dispatcher.value).to.equal 'from objecta'
		expect(objectA.prop).to.equal 'From ObjectA'
3802
3803
3804
	test "No transform will be used backwards if a false value is passed to .bothWays() as the first argument", ()->
		dispatcher = 'value': 'test'
		objectA.prop = ''
3808
		SimplyBind('value').of(dispatcher)
			.to('prop').of(objectA)
				.transform (value)-> value.toUpperCase()
				.bothWays(false)
3813
		expect(dispatcher.value).to.equal 'test'
		expect(objectA.prop).to.equal 'TEST'
		
		dispatcher.value = 'From Dispatcher'
		expect(dispatcher.value).to.equal 'From Dispatcher'
		expect(objectA.prop).to.equal 'FROM DISPATCHER'
		
		objectA.prop = 'From ObjectA'
		expect(dispatcher.value).to.equal 'From ObjectA'
		expect(objectA.prop).to.equal 'From ObjectA'
3824
3825
3826
3827
3828
3829
3830
3831
3832
3833
3834
3835
3836
3837
3838
3839
3840
3841
suite ".transformAll()", ()->
	suiteSetup(restartSandbox)
	test "Behaves the same way as .transform() does, except it applies the transform to all of the declared dependents", ()->
		dispatcher = 'value': 'current'
3846
		objectA.prop = objectC.prop = objectC.prop = ''
3848
		SimplyBind('value').of(dispatcher)
			.to('prop').of(objectA)
			.and('prop').of(objectB)
			.and('prop').of(objectC)
				.transformAll (newValue, currentValue)-> newValue+'+'+currentValue
		
		for value in [objectA.prop, objectB.prop, objectC.prop]
			expect(value).to.equal 'current+current'
		
		
		dispatcher.value = 'new'
		for value in [objectA.prop, objectB.prop, objectC.prop]
			expect(value).to.equal 'new+current+current'
		
		
		dispatcher.value = 'new'
		for value in [objectA.prop, objectB.prop, objectC.prop]
			expect(value).to.equal 'new+current+current'
		
		
		dispatcher.value = 'newer'
		for value in [objectA.prop, objectB.prop, objectC.prop]
			expect(value).to.equal 'newer+new+current+current'
3872
		restartSandbox()
3874
3875
3876
	test "Will not allow additional binding dependents after being called", ()->
		expect(()->
			SimplyBind('prop1').of(objectA)
				.to('prop1').of(objectB)
				.and('prop2').of(objectB)
				.and('prop3').of(objectB)
					.transformAll (value)-> value
				.and('prop4').of(objectB)
		).to.throw()
3886
3887
3888
3889
3890
3891
3892
3893
3894
3895
3896
3897
3898
3899
3900
3901
3902
3903
3904
suite ".transformSelf()", ()->
	suiteSetup(restartSandbox)
3907
	suite "Will transform any received value", ()->
		test "ObjectProp", ()->
			object = 'prop':'value'
3911
			SimplyBind('prop').of(object)
				.transformSelf (value)-> value.toUpperCase()
3914
			expect(object.prop).to.equal 'VALUE'
3916
			object.prop = 'anotherValue'
			expect(object.prop).to.equal 'ANOTHERVALUE'
		

3921
		test "DOMText", ()-> if not isBrowser then @skip() else
			regA.textContent = 'value'
3924
			SimplyBind('textContent').of(regA)
				.transformSelf (value)-> value.toUpperCase()
3927
			expect(regA.textContent).to.equal 'VALUE'
3929
			SimplyBind('textContent').of(regA).update('anotherValue')
			expect(regA.textContent).to.equal 'ANOTHERVALUE'
3932
			restartSandbox()
		

3936
		test "DOMAttr", ()-> if not isBrowser then @skip() else
			regA.setAttribute 'someattr', 'value'
3939
			SimplyBind('attr:someattr').of(regA)
				.transformSelf (value)-> value.toUpperCase()
3942
			expect(regA.getAttribute 'someattr').to.equal 'VALUE'
3944
			SimplyBind('attr:someattr').of(regA).update('anotherValue')
			expect(regA.getAttribute 'someattr').to.equal 'ANOTHERVALUE'
3947
			restartSandbox()
		

3951
		test "DOMValue", ()-> if not isBrowser then @skip() else
			inputA.value = 'value'
3954
			SimplyBind('value').of(inputA)
				.transformSelf (value)-> value.toUpperCase()
3957
			expect(inputA.value).to.equal 'VALUE'
3959
			inputA.value = 'anotherValue'
			inputA.emit 'change'
			expect(inputA.value).to.equal 'ANOTHERVALUE'
3963
			restartSandbox()
		
3966
3967
		test "Array", ()->
			expect ()-> SimplyBind(arrayA).transformSelf (v)->v
				.to.throw()
3971
			restartSandbox()
3973
3974
3975
		test "Function", ()->
			dispatcher = 'prop':'value'
			receiver = 'prop':'value'
			fn = (value)-> value
3980
			SimplyBind(fn).transformSelf (value)-> value?.toUpperCase()
			SimplyBind('prop').of(dispatcher)
				.to(fn)
					.chainTo('prop').of(receiver)
3985
			expect(dispatcher.prop).to.equal 'value'
			expect(receiver.prop).to.equal 'VALUE'
3988
			dispatcher.prop = 'anotherValue'
			expect(dispatcher.prop).to.equal 'anotherValue'
			expect(receiver.prop).to.equal 'ANOTHERVALUE'
3992
3993
3994
		test "Event", ()->
			dispatcher = 'prop':eventEmitterA
			receiver = 'prop':'N/A'
			eventEmitterA.type = 'someEvent'
			eventEmitterB.type = 'someEvent'
4000
			SimplyBind(0).ofEvent('someEvent').of(eventEmitterA)
				.transformSelf (event)-> event?.type or event
			
			SimplyBind('prop').of(dispatcher)
				.toEvent('someEvent').of(eventEmitterA)
					.chainTo('prop').of(receiver)
4007
			expect(dispatcher.prop).to.equal eventEmitterA
			expect(receiver.prop).to.equal 'N/A'
4010
			receiver.prop = 'reset'
			dispatcher.prop = eventEmitterB
			expect(dispatcher.prop).to.equal eventEmitterB
			expect(receiver.prop).to.equal 'someEvent'
4015
4016
4017
4018
4019
4020
	suite "Will not transform value on bind if SimplyBind.options.updateOnBind is off", ()->
		suiteSetup ()-> SimplyBind.setOption 'updateOnBind', false
		suiteTeardown ()-> SimplyBind.setOption 'updateOnBind', true
		
		test "ObjectProp", ()->
			object = 'prop':'value'
4027
			SimplyBind('prop').of(object)
				.transformSelf (value)-> value.toUpperCase()
4030
			expect(object.prop).to.equal 'value'
4032
			object.prop = 'anotherValue'
			expect(object.prop).to.equal 'ANOTHERVALUE'
		

4037
		test "DOMText", ()-> if not isBrowser then @skip() else
			regA.textContent = 'value'
4040
			SimplyBind('textContent').of(regA)
				.transformSelf (value)-> value.toUpperCase()
4043
			expect(regA.textContent).to.equal 'value'
4045
			SimplyBind('textContent').of(regA).update('anotherValue')
			expect(regA.textContent).to.equal 'ANOTHERVALUE'
4048
			restartSandbox()
		

4052
		test "DOMAttr", ()-> if not isBrowser then @skip() else
			regA.setAttribute 'someattr', 'value'
4055
			SimplyBind('attr:someattr').of(regA)
				.transformSelf (value)-> value.toUpperCase()
4058
			expect(regA.getAttribute 'someattr').to.equal 'value'
4060
			SimplyBind('attr:someattr').of(regA).update('anotherValue')
			expect(regA.getAttribute 'someattr').to.equal 'ANOTHERVALUE'
4063
			restartSandbox()
		

4067
		test "DOMValue", ()-> if not isBrowser then @skip() else
			inputA.value = 'value'
4070
			SimplyBind('value').of(inputA)
				.transformSelf (value)-> value.toUpperCase()
4073
			expect(inputA.value).to.equal 'value'
4075
			inputA.value = 'anotherValue'
			inputA.emit 'change'
			expect(inputA.value).to.equal 'ANOTHERVALUE'
4079
			restartSandbox()
4081
4082
4083
		test "Function", ()->
			dispatcher = 'prop':'value'
			receiver = 'prop':'value'
			fn = (value)-> value
4088
			SimplyBind(fn).transformSelf (value)-> value?.toUpperCase()
			SimplyBind('prop').of(dispatcher)
				.to(fn)
				.chainTo('prop').of(receiver)
4093
			expect(dispatcher.prop).to.equal 'value'
			expect(receiver.prop).to.be.undefined
4096
			dispatcher.prop = 'anotherValue'
			expect(dispatcher.prop).to.equal 'anotherValue'
			expect(receiver.prop).to.equal 'ANOTHERVALUE'
			restartSandbox()
4101
4102
4103
		test "Event", ()->
			dispatcher = 'prop':eventEmitterA
			receiver = 'prop':'N/A'
			eventEmitterA.type = 'someEvent'
			eventEmitterB.type = 'someEvent'
4109
			SimplyBind(0).ofEvent('someEvent').of(eventEmitterA)
				.transformSelf (event)-> event?.type or event
			
			SimplyBind('prop').of(dispatcher)
				.toEvent('someEvent').of(eventEmitterA)
					.chainTo('prop').of(receiver)
4116
			expect(dispatcher.prop).to.equal eventEmitterA
			expect(receiver.prop).to.equal 'N/A'
4119
			receiver.prop = 'reset'
			dispatcher.prop = eventEmitterB
			expect(dispatcher.prop).to.equal eventEmitterB
			expect(receiver.prop).to.equal 'someEvent'
4124
4125
4126
4127
4128
4129
4130
4131
4132
4133
4134
4135
4136
4137
4138
4139
4140
4141
4142
4143
suite ".condition()", ()->
	suiteSetup(restartSandbox)
4146
	test "Will pass the value to the condition before updating the dependent and will update the dep only if the return value is truthy", ()->
		shouldAllowUpdate = false
		objectA.prop1 = objectB.prop1 = 0
4150
		SimplyBind('prop1').of(objectA)
			.to('prop1').of(objectB)
			.condition ()-> shouldAllowUpdate
4154
		objectA.prop1 = 1
		expect(objectB.prop1).to.equal 0
		
		objectA.prop1 = 2
		expect(objectB.prop1).to.equal 0
4160
		shouldAllowUpdate = true
		
		objectA.prop1 = 3
		expect(objectB.prop1).to.equal 3
4165
		restartSandbox()
4167
4168
4169
	test "Will update the dependent upon initial bind regardless of the condition unless SimplyBind.options.updateOnBind is on", ()->
		shouldAllowUpdate = false
		objectA.prop1 = objectA.prop2 = 1
		objectB.prop1 = objectB.prop2 = 0
4174
		SimplyBind('prop1').of(objectA)
			.to('prop1').of(objectB)
			.condition ()-> shouldAllowUpdate
4178
		expect(objectA.prop1).to.equal 1
		expect(objectB.prop1).to.equal 1
4181
		objectA.prop1 = 2
		expect(objectB.prop1).to.equal 1
4184
		
		
		SimplyBind.setOption 'updateOnBind', false
		
		SimplyBind('prop2').of(objectA)
			.to('prop2').of(objectB)
			.condition ()-> shouldAllowUpdate
		
		expect(objectA.prop2).to.equal 1
		expect(objectB.prop2).to.equal 0
		
		SimplyBind.setOption 'updateOnBind', true
		restartSandbox()
4198
4199
4200
	test "Condition will be added only to the last-proxied dependent", ()->
		shouldAllowUpdate = false
		objectA.prop1 = objectB.prop1 = objectC.prop1 = 0
4204
		SimplyBind('prop1').of(objectA)
			.to('prop1').of(objectB).condition ()-> shouldAllowUpdate
			.and('prop1').of(objectC)
4208
		objectA.prop1 = 1
		expect(objectB.prop1).to.equal 0
		expect(objectC.prop1).to.equal 1
		
		objectA.prop1 = 2
		expect(objectB.prop1).to.equal 0
		expect(objectC.prop1).to.equal 2
4216
		shouldAllowUpdate = true
		
		objectA.prop1 = 3
		expect(objectB.prop1).to.equal 3
		expect(objectC.prop1).to.equal 3
4222
		restartSandbox()
4224
4225
4226
	test "The condition will be added both ways if declared after the .bothWays() call", ()->
		shouldAllowUpdate = false
		objectA.prop1 = objectB.prop1 = 0
4230
		SimplyBind('prop1').of(objectA)
			.to('prop1').of(objectB).bothWays()
				.condition ()-> shouldAllowUpdate
4234
		objectA.prop1 = 1
		expect(objectA.prop1).to.equal 1
		expect(objectB.prop1).to.equal 0
		
		objectB.prop1 = 2
		expect(objectA.prop1).to.equal 1
		expect(objectB.prop1).to.equal 2
4242
		shouldAllowUpdate = true
		
		objectA.prop1 = 3
		expect(objectA.prop1).to.equal 3
		expect(objectB.prop1).to.equal 3
		
		objectB.prop1 = 4
		expect(objectA.prop1).to.equal 4
		expect(objectB.prop1).to.equal 4
4252
		restartSandbox()
4254
4255
4256
	test "The condition will be added both ways if declared before the .bothWays() call", ()->
		shouldAllowUpdate = false
		objectA.prop1 = objectB.prop1 = 0
4260
		SimplyBind('prop1').of(objectA)
			.to('prop1').of(objectB)
				.condition ()-> shouldAllowUpdate
				.bothWays()
4265
		objectA.prop1 = 1
		expect(objectA.prop1).to.equal 1
		expect(objectB.prop1).to.equal 0
		
		objectB.prop1 = 2
		expect(objectA.prop1).to.equal 1
		expect(objectB.prop1).to.equal 2
4273
		shouldAllowUpdate = true
		
		objectA.prop1 = 3
		expect(objectA.prop1).to.equal 3
		expect(objectB.prop1).to.equal 3
		
		objectB.prop1 = 4
		expect(objectA.prop1).to.equal 4
		expect(objectB.prop1).to.equal 4
4283
		restartSandbox()
4285
4286
4287
	test "If a the dependent has a transform and a condition, the new value will be run through the transform prior to testing the condition", ()->
		invokeCount = 0
		shouldAllowUpdate = true
4291
		SimplyBind('prop1').of(objectA)
			.to('prop1').of(objectB)
				.transform (val)-> invokeCount++; val
				.condition ()-> shouldAllowUpdate
4296
		expect(objectB.prop1).to.equal(objectA.prop1)
		expect(invokeCount).to.equal 1
4299
		objectA.prop1 = 2
		expect(objectB.prop1).to.equal(objectA.prop1)
		expect(invokeCount).to.equal 2
4303
		shouldAllowUpdate = false
		objectA.prop1 = 3
		expect(objectB.prop1).not.to.equal(objectA.prop1)
		expect(invokeCount).to.equal 3
		
		objectA.prop1 = 4
		expect(objectB.prop1).not.to.equal(objectA.prop1)
		expect(invokeCount).to.equal 4
4312
		restartSandbox()
4314
4315
4316
	test "If a binding has a placeholder, the condition will be used only for that placeholder", ()->
		dispatcher = 'prop':''
		receiver = 'prop':'This {{noun}} works'
		lastPassedNoun = null
		shouldAllowUpdate = true
4322
		SimplyBind('prop').of(dispatcher)
			.to('prop.noun').of(receiver)
			.condition (noun)-> lastPassedNoun=noun; return shouldAllowUpdate
4326
		dispatcher.prop = 'test1'
		expect(lastPassedNoun).to.equal 'test1'
		expect(receiver.prop).to.equal 'This test1 works'
		
		shouldAllowUpdate = false
		dispatcher.prop = 'test2'
		expect(lastPassedNoun).to.equal 'test2'
		expect(receiver.prop).to.equal 'This test1 works'
4335
4336
4337
4338
4339
4340
4341
4342
4343
4344
4345
4346
4347
4348
4349
4350
suite ".conditionAll()", ()->
	suiteSetup(restartSandbox)
4353
	test "Behaves the same way as .condition() does, except it applies the condition to all of the declared dependents", ()->
		shouldAllowUpdate = false
		dispatcher = 'prop':0
		objectA.prop1 = objectB.prop1 = objectC.prop1 = 0
4358
		SimplyBind('prop').of(dispatcher)
			.to('prop1').of(objectA)
			.and('prop1').of(objectB)
			.and('prop1').of(objectC)
			.conditionAll ()-> shouldAllowUpdate
4364
		dispatcher.prop = 1
		expect(objectA.prop1).to.equal 0
		expect(objectB.prop1).to.equal 0
		expect(objectC.prop1).to.equal 0
		
		dispatcher.prop = 2
		expect(objectA.prop1).to.equal 0
		expect(objectB.prop1).to.equal 0
		expect(objectC.prop1).to.equal 0
4374
		shouldAllowUpdate = true
		
		dispatcher.prop = 3
		expect(objectA.prop1).to.equal 3
		expect(objectB.prop1).to.equal 3
		expect(objectC.prop1).to.equal 3
4381
		restartSandbox()
4383
4384
4385
4386
4387
4388
4389
4390
4391
4392
4393
4394
4395
4396
4397
4398
4399
4400
4401
suite ".bothWays()", ()->
	suiteSetup(restartSandbox)
	test "Create two-way bindings", ()->
		# ==== Objects =================================================================================
		SimplyBind('prop').of(objectA).to('prop').of(objectB).bothWays()
		expect(objectA.prop).to.be.undefined
		
		objectA.prop = 'from objectA'
		expect(objectA.prop).to.equal 'from objectA'
		expect(objectB.prop).to.equal 'from objectA'
4412
		objectB.prop = 'from objectB'
		expect(objectA.prop).to.equal 'from objectB'
		expect(objectB.prop).to.equal 'from objectB'
4416
4417
		# ==== Arrays =================================================================================
		SimplyBind(arrayA).to(arrayB).bothWays()
		expect(arrayA.length).to.equal 10
		expect(arrayB.length).to.equal 10
		
		arrayA.push(1)
		arrayA.push(1)
		expect(arrayA.length).to.equal 12
		expect(arrayB.length).to.equal 10
		
		arrayB.push(1)
		arrayB.push(1)
		expect(arrayA.length).to.equal 12
		expect(arrayB.length).to.equal 12
4432
4433
		if isBrowser
			# ==== DOMAttr =================================================================================
			SimplyBind('attr:someattr').of(regA).to('attr:someattr').of(regB).bothWays()
			expect(regA.getAttribute('someattr')).to.equal null
			
			SimplyBind('attr:someattr').of(regA).set 'from regElementA'
			expect(regA.getAttribute('someattr')).to.equal 'from regElementA'
			expect(regB.getAttribute('someattr')).to.equal 'from regElementA'
4442
			SimplyBind('attr:someattr').of(regB).set 'from regElementB'
			expect(regA.getAttribute('someattr')).to.equal 'from regElementB'
			expect(regB.getAttribute('someattr')).to.equal 'from regElementB'
4446
4447
			# ==== DOMText =================================================================================
			regA.textContent = ''
			SimplyBind('textContent').of(regA).to('textContent').of(regB).bothWays()
			expect(regA.textContent).to.equal ''
			
			SimplyBind('textContent').of(regA).set 'from regElementA'
			expect(regA.textContent).to.equal 'from regElementA'
			expect(regB.textContent).to.equal 'from regElementA'
4456
			SimplyBind('textContent').of(regB).set 'from regElementB'
			expect(regA.textContent).to.equal 'from regElementB'
			expect(regB.textContent).to.equal 'from regElementB'
4460
4461
			# ==== DOMValue =================================================================================
			SimplyBind('value').of(inputA).to('value').of(inputB).bothWays()
			expect(inputA.value).to.equal ''
			
			inputA.value = 'from inputA'
			inputA.emit 'change'
			expect(inputA.value).to.equal 'from inputA'
			expect(inputB.value).to.equal 'from inputA'
4470
			inputB.value = 'from inputB'
			inputB.emit 'change'
			expect(inputA.value).to.equal 'from inputB'
			expect(inputB.value).to.equal 'from inputB'
4475
4476
			# ==== DOMCheckbox =================================================================================
			binding = SimplyBind('checked').of(checkboxFields).to('prop2').of(objectB).bothWays()
			expect(objectB.prop2).to.be.instanceOf Array
			expect(objectB.prop2.length).to.equal 0
			
			objectB.prop2 = 'changed from objectB'
			expect($checkboxFields.filter(':checked').length).to.equal 0
			expect(binding.value).to.be.instanceOf Array
			expect(binding.value.length).to.equal 0
			
			objectB.prop2 = 'checkboxB'
			expect($checkboxFields.filter(':checked').val()).to.equal 'checkboxB'
			expect(binding.value.length).to.equal 1
			
			objectB.prop2 = ['checkboxA', 'checkboxC']
			expect($checkboxFields.filter(':checked').length).to.equal 2
			expect(binding.value.length).to.equal 2
			
			$checkboxA.click()
			expect(objectB.prop2).to.be.instanceOf Array
			expect(objectB.prop2.length).to.equal 1
			expect(objectB.prop2[0]).to.equal 'checkboxC'
4499
			restartSandbox()
4501
4502
			# ==== DOMRadio =================================================================================
			SimplyBind('checked').of(radioFields).to('prop3').of(objectB).bothWays()
			
			objectB.prop3 = 'changed from objectB'
			expect($radioFields.filter(':checked').length).to.equal 0
			
			objectB.prop3 = 'radioB'
			expect($radioFields.filter(':checked').val()).to.equal 'radioB'
			
			$radioA.click()
			expect(objectB.prop3).to.equal 'radioA'
4514
			restartSandbox()
4516
4517
4518
		SimplyBind.setOption('updateOnBind', true)
		restartSandbox()
4521
4522
4523
	
4525
4526
4527
	test "Will apply the call only to the last proxied dependent", ()->
		restartSandbox()
		SimplyBind('prop1').of(objectA)
			.to('prop1').of(objectB).bothWays()
			.and('prop2').of(objectB)
			.and('prop3').of(objectB).bothWays()
			.and('prop4').of objectB
		
		objectA.prop1 = 'all at once'
		expect(objectB.prop1).to.equal 'all at once'
		expect(objectB.prop2).to.equal 'all at once'
		expect(objectB.prop3).to.equal 'all at once'
		expect(objectB.prop4).to.equal 'all at once'
		
		objectB.prop1 = 'almost all as well since objectA.prop1 gets updated and updates all of its decendents'
		expect(objectA.prop1).to.equal 'almost all as well since objectA.prop1 gets updated and updates all of its decendents'
		expect(objectB.prop2).to.equal 'almost all as well since objectA.prop1 gets updated and updates all of its decendents'
		expect(objectB.prop3).to.equal 'almost all as well since objectA.prop1 gets updated and updates all of its decendents'
		expect(objectB.prop4).to.equal 'almost all as well since objectA.prop1 gets updated and updates all of its decendents'
	
		objectB.prop3 = 'just a few'
		expect(objectA.prop1).to.equal 'just a few'
		expect(objectB.prop1).to.equal 'just a few'
		expect(objectB.prop2).to.equal 'just a few'
		expect(objectB.prop4).to.equal 'just a few'
4553
4554
4555
4556
4557
4558
	suite "DOMValue other than input", ()->
		suiteSetup ()-> if not isBrowser then @skip()
		test "Create two-way bindings between textarea fields", ()->
			SimplyBind('value').of(textarea).to('value').of(inputB).bothWays()
4563
			$textarea.val('changed from input1')[0].emit 'change'
			expect($inputB.val()).to.equal 'changed from input1'
4566
			$inputB.val('changed from input2')[0].emit 'change'
			expect($textarea.val()).to.equal 'changed from input2'
4569
4570
4571
4572
		test "Create two-way bindings between select fields", ()->
			SimplyBind('value').of($select).to('prop3').of(objectB).bothWays()
		
			objectB.prop3 = 'valid'
			expect($select.val()).to.equal 'valid'
		
			$select.val('valid2')[0].emit 'change'
			expect(objectB.prop3).to.equal 'valid2'
			restartSandbox()
4582
4583
4584
	# suite "DOMRadio", ()->
	# 	test "Create two-way bindings between radio fields", ()->
	# 		SimplyBind('value').of($('#radio').children()).to('prop3').of(objectB).bothWays()
			
	# 		objectB.prop3 = 'changed from objectB'
	# 		expect($('input:checked').length).to.equal 0
			
	# 		objectB.prop3 = 'radioB'
	# 		expect($('input:checked').val()).to.equal 'radioB'
			
	# 		$radioA.click()[0].emit 'change'
	# 		expect(objectB.prop3).to.equal 'radioA'
4597
	# 		restartSandbox()
4599
4600
4601
	# suite "DOMCheckbox", ()->
	# 	test "Create two-way bindings between checkbox fields", ()->
	# 		$checkboxA.prop 'checked', true
	# 		SimplyBind('value').of($('#checkbox')[0].children).to('prop3').of(objectB).bothWays()
			
	# 		objectB.prop3 = 'changed from objectB'
	# 		expect($('input:checked').length).to.equal 0
			
	# 		objectB.prop3 = 'checkboxB'
	# 		expect($('input:checked').val()).to.equal 'checkboxB'
			
	# 		$checkboxA.click()[0].emit 'change'
	# 		expect(objectB.prop3).to.equal 'checkboxA'
4615
	# 		restartSandbox()
4617
4618
4619
4620
4621
4622
4623
4624
4625
4626
4627
4628
4629
4630
4631
4632
4633
4634
suite ".unBind()", ()->
	suiteSetup(restartSandbox)
	suite "Will unbind from the all defined proxied dependents one-way", ()->
		test "ObjectProp", ()->
			binding = SimplyBind('prop1').of(objectA)
				.to('prop1').of(objectB).bothWays()
4641
			objectA.prop1 = 1
			expect(objectB.prop1).to.equal 1
			
			objectB.prop1 = 2
			expect(objectA.prop1).to.equal 2
4647
			binding.unBind()
4649
			objectA.prop1 = 3
			expect(objectB.prop1).to.equal 2
			
			objectB.prop1 = 4
			expect(objectA.prop1).to.equal 4
4655
			restartSandbox()
		

4659
		test "DOMText", ()-> if not isBrowser then @skip() else
			binding = SimplyBind('textContent').of(regA)
				.to('textContent').of(regB).bothWays()
4663
			SimplyBind('textContent').of(regA).set '1'
			expect(regB.textContent).to.equal '1'
			
			SimplyBind('textContent').of(regB).set '2'
			expect(regA.textContent).to.equal '2'
4669
			binding.unBind()
4671
			SimplyBind('textContent').of(regA).set '3'
			expect(regB.textContent).to.equal '2'
			
			SimplyBind('textContent').of(regB).set '4'
			expect(regA.textContent).to.equal '4'
4677
			restartSandbox()
		

4681
		test "DOMAttr", ()-> if not isBrowser then @skip() else
			binding = SimplyBind('attr:someattr').of(regA)
				.to('attr:someattr').of(regB).bothWays()
4685
			SimplyBind('attr:someattr').of(regA).set '1'
			expect(regB.getAttribute 'someattr').to.equal '1'
			
			SimplyBind('attr:someattr').of(regB).set '2'
			expect(regA.getAttribute 'someattr').to.equal '2'
4691
			binding.unBind()
4693
			SimplyBind('attr:someattr').of(regA).set '3'
			expect(regB.getAttribute 'someattr').to.equal '2'
			
			SimplyBind('attr:someattr').of(regB).set '4'
			expect(regA.getAttribute 'someattr').to.equal '4'
4699
			restartSandbox()
		

4703
		test "DOMValue", ()-> if not isBrowser then @skip() else
			binding = SimplyBind('value').of(inputA)
				.to('value').of(inputB).bothWays()
4707
			inputA.value = '1'
			inputA.emit 'change'
			expect(inputB.value).to.equal '1'
			
			inputB.value = '2'
			inputB.emit 'change'
			expect(inputA.value).to.equal '2'
4715
			binding.unBind()
4717
			inputA.value = '3'
			inputA.emit 'change'
			expect(inputB.value).to.equal '2'
			
			inputB.value = '4'
			inputB.emit 'change'
			expect(inputA.value).to.equal '4'
4725
			restartSandbox()
		
4728
4729
		test "Array", ()->
			binding = SimplyBind(arrayA, {'trackArrayChildren':true})
				.to('prop1').of(objectA)
4733
			expect(objectA.prop1).to.equal arrayA
4735
			objectA.prop1 = 'reset'
			arrayA.push(1)
			expect(objectA.prop1).to.equal arrayA
4739
			objectA.prop1 = 'reset'
			arrayA[5] = 19
			expect(objectA.prop1).to.equal arrayA
4743
4744
			objectA.prop1 = 'reset'
			binding.unBind()
			
			arrayA.push(1)
			arrayA[3] = 23
			expect(objectA.prop1).to.equal 'reset'
			
			restartSandbox()
4753
4754
4755
		test "Function", ()->
			passedValue = null
			valueToPass = 1
			takeFromReceiver = false
			fn = (fromReceiver)-> passedValue = if takeFromReceiver then fromReceiver else valueToPass
			invoker = 'prop':'value'
			receiver = 'prop':undefined
4763
			SimplyBind('prop').of(invoker).to(fn)
			binding = SimplyBind(fn).to('prop').of(receiver).bothWays()
4766
			expect(receiver.prop).to.equal 1
			expect(passedValue).to.equal 1
			
			valueToPass = 5
			invoker.prop = 'anotherValue'
			expect(receiver.prop).to.equal 5
			expect(passedValue).to.equal 5
			
			takeFromReceiver = true
			receiver.prop = 10
			takeFromReceiver = false
			expect(passedValue).to.equal 10
4779
			
			binding.unBind()
			valueToPass = 15
			invoker.prop = 'newValue'
			expect(receiver.prop).to.equal 10
			expect(passedValue).to.equal 15
4786
			takeFromReceiver = true
			receiver.prop = 20
			takeFromReceiver = false
			expect(passedValue).to.equal 20
4791
4792
4793
		test "Event", ()->
			eventInvokeCount = 0
			eventObject = null
			objectA.prop = objectB.prop = 'someValue'
			eventEmitterA.on 'someEvent', (event)-> eventObject = event or @
			
			binding = SimplyBind(0).ofEvent('someEvent').of(eventEmitterA).transformSelf ()-> eventObject
				.to('prop').of(objectA).bothWays()
				.and('prop').of(objectB).bothWays()
				.and ()-> eventInvokeCount++
			
4805
			eventEmitterA.emit 'someEvent'
			expect(objectA.prop).to.equal eventObject
			expect(objectB.prop).to.equal(objectA.prop)
			expect(eventInvokeCount).to.equal 1

			objectA.prop = 'different value'
			expect(objectA.prop).to.equal 'different value'
			# expect(objectB.prop).to.equal eventObject
			expect(eventInvokeCount).to.equal 2
			
			objectB.prop = 'different value2'
			expect(eventInvokeCount).to.equal 3
4818
4819
			binding.unBind()
			objectA.prop = 'different value'
			eventEmitterA.emit 'someEvent'
			eventEmitterA.on 'someEvent', ()-> eventInvokeCount++
4824
			expect(objectA.prop).to.equal 'different value'
			expect(objectB.prop).to.equal 'different value2'
			expect(eventInvokeCount).to.equal 3
			
4829
			objectA.prop = 'another value'
			expect(objectA.prop).to.equal 'another value'
			expect(objectB.prop).to.equal 'different value2'
			
			objectB.prop = 'another value2'
			expect(objectA.prop).to.equal 'another value'
			expect(objectB.prop).to.equal 'another value2'
			expect(eventInvokeCount).to.equal 5
			expect(binding._.deps.length).to.equal 0
			
			restartSandbox()
4841
4842
4843
	suite "Will unbind from the all defined proxied dependents both-ways", ()->
		test "ObjectProp", ()->
			binding = SimplyBind('prop1').of(objectA)
				.to('prop1').of(objectB).bothWays()
4848
			objectA.prop1 = 1
			expect(objectB.prop1).to.equal 1
			
			objectB.prop1 = 2
			expect(objectA.prop1).to.equal 2
4854
			binding.unBind(true)
4856
			objectA.prop1 = 3
			expect(objectB.prop1).to.equal 2
			
			objectB.prop1 = 4
			expect(objectA.prop1).to.equal 3
4862
			restartSandbox()
		

4866
		test "DOMText", ()-> if not isBrowser then @skip() else
			binding = SimplyBind('textContent').of(regA)
				.to('textContent').of(regB).bothWays()
4870
			SimplyBind('textContent').of(regA).set '1'
			expect(regB.textContent).to.equal '1'
			
			SimplyBind('textContent').of(regB).set '2'
			expect(regA.textContent).to.equal '2'
4876
			binding.unBind(true)
4878
			SimplyBind('textContent').of(regA).set '3'
			expect(regB.textContent).to.equal '2'
			
			SimplyBind('textContent').of(regB).set '4'
			expect(regA.textContent).to.equal '3'
4884
			restartSandbox()
		

4888
		test "DOMAttr", ()-> if not isBrowser then @skip() else
			binding = SimplyBind('attr:someattr').of(regA)
				.to('attr:someattr').of(regB).bothWays()
4892
			SimplyBind('attr:someattr').of(regA).set '1'
			expect(regB.getAttribute 'someattr').to.equal '1'
			
			SimplyBind('attr:someattr').of(regB).set '2'
			expect(regA.getAttribute 'someattr').to.equal '2'
4898
			binding.unBind(true)
4900
			SimplyBind('attr:someattr').of(regA).set '3'
			expect(regB.getAttribute 'someattr').to.equal '2'
			
			SimplyBind('attr:someattr').of(regB).set '4'
			expect(regA.getAttribute 'someattr').to.equal '3'
4906
			restartSandbox()
		

4910
		test "DOMValue", ()-> if not isBrowser then @skip() else
			binding = SimplyBind('value').of(inputA)
				.to('value').of(inputB).bothWays()
4914
			inputA.value = '1'
			inputA.emit 'change'
			expect(inputB.value).to.equal '1'
			
			inputB.value = '2'
			inputB.emit 'change'
			expect(inputA.value).to.equal '2'
4922
			binding.unBind(true)
4924
			inputA.value = '3'
			inputA.emit 'change'
			expect(inputB.value).to.equal '2'
			
			inputB.value = '4'
			inputB.emit 'change'
			expect(inputA.value).to.equal '3'
4932
			restartSandbox()
4934
4935
4936
		test "Function", ()->
			passedValue = null
			valueToPass = 1
			takeFromReceiver = false
			fn = (fromReceiver)-> passedValue = if takeFromReceiver then fromReceiver else valueToPass
			invoker = 'prop':'value'
			receiver = 'prop':undefined
4944
			SimplyBind('prop').of(invoker).to(fn)
			binding = SimplyBind(fn).to('prop').of(receiver).bothWays()
4947
			expect(receiver.prop).to.equal 1
			expect(passedValue).to.equal 1
			
			valueToPass = 5
			invoker.prop = 'anotherValue'
			expect(receiver.prop).to.equal 5
			expect(passedValue).to.equal 5
			
			takeFromReceiver = true
			receiver.prop = 10
			takeFromReceiver = false
			expect(passedValue).to.equal 10
4960
			
			binding.unBind(true)
			valueToPass = 15
			invoker.prop = 'newValue'
			expect(receiver.prop).to.equal 10
			expect(passedValue).to.equal 15
4967
			takeFromReceiver = true
			receiver.prop = 20
			takeFromReceiver = false
			expect(passedValue).to.equal 15
4972
4973
4974
		test "Event", ()->
			eventInvokeCount = 0
			eventObject = null
			objectA.prop = objectB.prop = 'someValue'
			eventEmitterA.on 'someEvent', (event)-> eventObject = event or @
			
			binding = SimplyBind(0).ofEvent('someEvent').of(eventEmitterA).transformSelf ()-> eventObject
				.to('prop').of(objectA).bothWays()
				.and('prop').of(objectB).bothWays()
				.and ()-> eventInvokeCount++
			
4986
			eventEmitterA.emit 'someEvent'
			expect(objectA.prop).to.equal eventObject
			expect(objectB.prop).to.equal(objectA.prop)
			expect(eventInvokeCount).to.equal 1

4992
			objectA.prop = 'different value'
			expect(objectA.prop).to.equal 'different value'
			# expect(objectB.prop).to.equal eventObject
			expect(eventInvokeCount).to.equal 2
			
			objectB.prop = 'different value2'
			expect(eventInvokeCount).to.equal 3
5000
5001
			binding.unBind(true)
			objectA.prop = 'different value'
			eventEmitterA.emit 'someEvent'
			eventEmitterA.on 'someEvent', ()-> eventInvokeCount++
5006
			expect(objectA.prop).to.equal 'different value'
			expect(objectB.prop).to.equal 'different value2'
			expect(eventInvokeCount).to.equal 3
			
5011
			objectA.prop = 'another value'
			expect(objectA.prop).to.equal 'another value'
			expect(objectB.prop).to.equal 'different value2'
			
			objectB.prop = 'another value2'
			expect(objectA.prop).to.equal 'another value'
			expect(objectB.prop).to.equal 'another value2'
			expect(eventInvokeCount).to.equal 3
			expect(binding._.deps.length).to.equal 0
			
			restartSandbox()
5023
5024
5025
5026
5027
5028
5029
5030
5031
5032
5033
5034
5035
5036
5037
5038
5039
5040
5041
5042
5043
5044
5045
suite ".pollEvery() + .stopPolling()", ()->
	suiteSetup(restartSandbox)
	test 'Will cause the value to be manually polled from the subject at a given interval', (done)->
		shouldFinish = false
		lastValue = undefined
		binding = undefined
		arr = []
5053
		fn = (length)->
			if shouldFinish
				expect(length).to.equal 2
				binding.stopPolling()
				done()
			else
				lastValue = length
5061
5062
5063
		binding = SimplyBind('length').of(arr).to(fn)
		expect(lastValue).to.equal 0
		arr.push 'some value'
		arr.push 'and another'
		expect(lastValue).to.equal 0
		arr = []
		binding = SimplyBind('length').of(arr).to(fn).pollEvery(5)
		
		setTimeout ()->
			shouldFinish = true
			expect(lastValue).to.equal 0
			arr.push 'some value'
			arr.push 'and another'
			expect(lastValue).to.equal 0
		, 8
5079
5080
5081
	test 'Will invoke a function upon poll', (done)->
		invokeCountA = 0
		invokeCountB = 0
5085
		binding = SimplyBind(()-> ++invokeCountA).to(()-> ++invokeCountB).pollEvery(5)
		setTimeout ()->
			expect(invokeCountA).to.be.gt(1)
			expect(invokeCountB).to.be.gt(1)
			binding.stopPolling()
			done()
		, 15
5093
5094
5095
	test "Will re-create the interval poll if called .pollEvery() twice with different values", (done)->
		invokeCount = 0
		objectA.prop = 200
		
		expect ()-> SimplyBind('prop', {'updateEvenIfSame':true}).of(objectA).to(()->invokeCount++).pollEvery(50).pollEvery(5)
			.not.to.throw()
5102
		setTimeout ()->
			expect(invokeCount).to.be.gte(3)
			done()
			restartSandbox()
		, 50
5108
5109
5110
	test "Will not throw errors when calling .stopPolling() on a binding with no pre-set interval", ()->
		expect ()-> SimplyBind('prop').of(objectA).to('prop').of(objectB).stopPolling()
			.not.to.throw()
5114
		restartSandbox()
5116
5117
5118
5119
5120
5121
5122
5123
5124
5125
5126
5127
5128
5129
5130
5131
5132
5133
5134
suite ".updateDepsOnEvent() + .removeEvent()", ()->
	suiteSetup(restartSandbox)
	test "Will listen for events on the target and upon emit will poll (and update if changed) the binding's value", ()->
		binding = SimplyBind('inheritedProp').of(eventEmitterA).to('prop1').of(objectA).updateDepsOnEvent('click')
5139
		binding.set 'one'
		expect(objectA.prop1).to.equal 'one'
5142
		eventEmitterA.inheritedProp = 'two'
		expect(objectA.prop1).to.equal 'one'
5145
		eventEmitterA.emit 'click'
		expect(objectA.prop1).to.equal 'two'
5148
		binding.removeEvent 'click'
		eventEmitterA.inheritedProp = 'three'
		expect(objectA.prop1).to.equal 'two'
5152
		eventEmitterA.emit 'click'
		expect(objectA.prop1).to.equal 'two'
		restartSandbox()
5156
5157
5158
	test "Can use custom supplied methods to apply/remove event listerners", ()->
		eventEmitterA.customAdd = ()-> eventEmitterA.on.apply eventEmitterA, arguments
		eventEmitterA.customRemove = ()-> eventEmitterA.removeListener.apply eventEmitterA, arguments
5162
		binding = SimplyBind('inheritedProp').of(eventEmitterA)
			.to('prop1').of(objectA)
				.updateDepsOnEvent('click', 'customAdd')
		
		binding.set 'one'
		expect(objectA.prop1).to.equal 'one'
		
		eventEmitterA.inheritedProp = 'two'
		expect(objectA.prop1).to.equal 'one'
		
		eventEmitterA.emit 'click'
		expect(objectA.prop1).to.equal 'two'
		
		binding.removeEvent 'click', 'customRemove'
		eventEmitterA.inheritedProp = 'three'
		expect(objectA.prop1).to.equal 'two'
		
		eventEmitterA.emit 'click'
		expect(objectA.prop1).to.equal 'two'
5182
		restartSandbox()
5184
5185
5186
	test "Will do nothing when trying to remove an event that wasn't registered or when trying to add an event that was already registered", ()->
		binding = SimplyBind('inheritedProp').of(eventEmitterB).to('prop1').of(objectA).updateDepsOnEvent('click')
		atEvs = binding._.attachedEvents or binding._.atEV;
		expect(atEvs.length).to.equal 1
		
		binding = SimplyBind('inheritedProp').of(eventEmitterB).to('prop1').of(objectA).updateDepsOnEvent('click')
		binding = SimplyBind('inheritedProp').of(eventEmitterB).to('prop1').of(objectA).updateDepsOnEvent('change')
		expect(atEvs.length).to.equal 2
		
		binding.removeEvent 'clicker'
		expect(atEvs.length).to.equal 2
		
		binding.removeEvent 'click'
		expect(atEvs.length).to.equal 1
		
		binding.removeEvent 'change'
		expect(atEvs.length).to.equal 0
5204
		restartSandbox()
5206
5207
5208
	test "Will use the default event methods if the supplied custom methods don't exist", ()->
		binding = SimplyBind('inheritedProp').of(eventEmitterA).to('prop1').of(objectA).updateDepsOnEvent('click', 'customAdd')
		
		binding.set 'one'
		expect(objectA.prop1).to.equal 'one'
		
		eventEmitterA.inheritedProp = 'two'
		expect(objectA.prop1).to.equal 'one'
		
		eventEmitterA.emit 'click'
		expect(objectA.prop1).to.equal 'two'
		
		binding.removeEvent 'click', 'customRemove'
		eventEmitterA.inheritedProp = 'three'
		expect(objectA.prop1).to.equal 'two'
		
		eventEmitterA.emit 'click'
		expect(objectA.prop1).to.equal 'two'
		restartSandbox()
5228
5229
5230
	test "Can use jQuery's .on and .off methods on DOM elements", ()-> if not isBrowser then @skip() else
		$h1 = $regAH1
		binding = SimplyBind('attr:data-attr').of($h1).to('prop1').of(objectA).updateDepsOnEvent('customevent', 'on')
5234
		binding.set 'one'
		expect(objectA.prop1).to.equal 'one'
5237
		$h1.attr 'data-attr', 'two'
		expect(objectA.prop1).to.equal 'one'
5240
		$h1.trigger 'customevent'
		expect(objectA.prop1).to.equal 'two'
		binding.removeEvent 'customevent', 'off'
5244
		$h1.attr 'data-attr', 'three'
		expect(objectA.prop1).to.equal 'two'
5247
		$h1.trigger 'customevent'
		expect(objectA.prop1).to.equal 'two'
5250
5251
5252
5253
5254
5255
5256
5257
5258
5259
5260
5261
5262
5263
5264
5265
5266
5267
5268
suite ".throttle()", ()->
	suiteSetup(restartSandbox)
	test "Will throttle the dep update frequency to once in a given timeframe", (done)->
		invokeCount = 0
		lastValue = null
		dispatcher = 'prop':1
5275
		SimplyBind('prop').of(dispatcher)
			.to (v)-> lastValue=v; invokeCount++
			.throttle(15)
5279
		expect(invokeCount).to.equal(1)
		expect(lastValue).to.equal(1)
5282
		dispatcher.prop = 2
		dispatcher.prop = 3
		dispatcher.prop = 4
		dispatcher.prop = 5
		expect(invokeCount).to.equal(2)
		expect(lastValue).to.equal(2)
5289
		setTimeout ()->
			expect(invokeCount).to.equal(3)
			expect(lastValue).to.equal(5)
			done()
		, 25
	
5296
	test "Will remove existing throttles if passed boolean false", ()->
		invokeCount = 0
		lastValue = null
		dispatcher = 'prop':1
5301
		binding = SimplyBind('prop').of(dispatcher)
			.to (v)-> lastValue=v; invokeCount++
			.throttle(15)
5305
		expect(invokeCount).to.equal(1)
		expect(lastValue).to.equal(1)
5308
		binding.throttle(false)
		dispatcher.prop = 2
		dispatcher.prop = 3
		dispatcher.prop = 4
		dispatcher.prop = 5
		expect(invokeCount).to.equal(5)
		expect(lastValue).to.equal(5)
5316
5317
5318
5319
5320
5321
5322
5323
5324
5325
5326
5327
5328
5329
5330
5331
5332
5333
5334
5335
5336
5337
5338
5339
5340
5341
5342
5343
5344
5345
suite "SimplyBind.unBindAll", ()->
suite "Will unBind all bindings, but only in one direction", ()->
	suiteSetup(restartSandbox)
5349
	test "ObjectProp", ()->
		SimplyBind('prop1').of(objectA)
			.to('prop1').of(objectB).bothWays()
		
		SimplyBind('prop2').of(objectA)
			.to('prop2').of(objectB).bothWays()
5356
		objectA.prop1 = 'objectA.prop1'
		expect(objectA.prop1).to.equal 'objectA.prop1'
		expect(objectB.prop1).to.equal 'objectA.prop1'
		
		objectB.prop2 = 'objectB.prop2'
		expect(objectA.prop2).to.equal 'objectB.prop2'
		expect(objectB.prop2).to.equal 'objectB.prop2'
		
		objectB.prop1 = 'reset'
		objectB.prop2 = 'reset'
		SimplyBind.unBindAll(objectA)
5368
		objectA.prop1 = 'objectA.prop1'
		expect(objectA.prop1).to.equal 'objectA.prop1'
		expect(objectB.prop1).to.equal 'reset'
		
		objectA.prop2 = 'objectA.prop2'
		expect(objectA.prop2).to.equal 'objectA.prop2'
		expect(objectB.prop2).to.equal 'reset'
		
		objectB.prop2 = 'objectB.prop2'
		expect(objectA.prop2).to.equal 'objectB.prop2'
		expect(objectB.prop2).to.equal 'objectB.prop2'
5380
		restartSandbox()
5382
5383
5384
	test "DOMText", ()-> if not isBrowser then @skip() else
		SimplyBind('textContent').of(regA)
			.to('textContent').of(regB).bothWays()
		
		SimplyBind('textContent').of(regA).set 'regA.textContent'
		expect(regA.textContent).to.equal 'regA.textContent'
		expect(regB.textContent).to.equal 'regA.textContent'
						
		SimplyBind('textContent').of(regB).set 'reset'
		SimplyBind.unBindAll(regA)
5395
		SimplyBind('textContent').of(regA).set 'regA.textContent'
		expect(regA.textContent).to.equal 'regA.textContent'
		expect(regB.textContent).to.equal 'reset'
						
		SimplyBind('textContent').of(regB).set 'regB.textContent'
		expect(regA.textContent).to.equal 'regB.textContent'
		expect(regB.textContent).to.equal 'regB.textContent'
5403
		restartSandbox()
5405
5406
5407
	test "DOMValue", ()-> if not isBrowser then @skip() else
		SimplyBind('value').of(inputA)
			.to('value').of(inputB).bothWays()
		
		inputA.value = 'inputA.value'
		inputA.emit 'change'
		expect(inputA.value).to.equal 'inputA.value'
		expect(inputB.value).to.equal 'inputA.value'
		
5417
		inputB.value = 'reset'
		SimplyBind.unBindAll($inputA)
5420
		inputA.value = 'inputA.value'
		inputA.emit 'change'
		expect(inputA.value).to.equal 'inputA.value'
		expect(inputB.value).to.equal 'reset'
5425
		inputB.value = 'inputB.value'
		inputB.emit 'change'
		expect(inputA.value).to.equal 'inputB.value'
		expect(inputB.value).to.equal 'inputB.value'
5430
		restartSandbox()
5432
5433
5434
	test "Array", ()->
		SimplyBind(arrayA, {'trackArrayChildren':true})
			.to('prop1').of(objectA)
			.and('prop1').of(objectB)
5439
		expect(objectA.prop1).to.equal arrayA
		expect(objectB.prop1).to.equal arrayA
5442
		objectA.prop1 = 'reset'
		objectB.prop1 = 'reset'
		arrayA.push(1)
		expect(objectA.prop1).to.equal arrayA
		expect(objectB.prop1).to.equal arrayA
5448
		objectA.prop1 = 'reset'
		objectB.prop1 = 'reset'
		arrayA[5] = 19
		expect(objectA.prop1).to.equal arrayA
		expect(objectB.prop1).to.equal arrayA
5454
5455
5456
		objectA.prop1 = 'reset'
		objectB.prop1 = 'reset'
		
		SimplyBind.unBindAll(arrayA)
		arrayA.push(1)
		arrayA[3] = 23
		expect(objectA.prop1).to.equal 'reset'
		expect(objectB.prop1).to.equal 'reset'
		restartSandbox()
5466
5467
5468
	test "Function", ()->
		passedValue = null
		valueToPass = 1
		takeFromReceiver = false
		fn = (fromReceiver)-> passedValue = if takeFromReceiver then fromReceiver else valueToPass
		invoker = 'prop':'value'
		receiver = 'prop':undefined
5476
		SimplyBind('prop').of(invoker).to(fn)
		SimplyBind(fn).to('prop').of(receiver).bothWays()
5479
		expect(receiver.prop).to.equal 1
		expect(passedValue).to.equal 1
		
		valueToPass = 5
		invoker.prop = 'anotherValue'
		expect(receiver.prop).to.equal 5
		expect(passedValue).to.equal 5
		
		takeFromReceiver = true
		receiver.prop = 10
		takeFromReceiver = false
		expect(passedValue).to.equal 10
5492
		
		SimplyBind.unBindAll(fn)
		valueToPass = 15
		invoker.prop = 'newValue'
		expect(receiver.prop).to.equal 10
		expect(passedValue).to.equal 15
5499
		takeFromReceiver = true
		receiver.prop = 20
		takeFromReceiver = false
		expect(passedValue).to.equal 20
		
5505
5506
	test "Event", ()->
		eventInvokeCount = 0
		eventObject = null
		objectA.prop = objectB.prop = 'someValue'
		eventEmitterA.on 'someEvent', (event)-> eventObject = event or @
		
		binding = SimplyBind(0).ofEvent('someEvent').of(eventEmitterA).transformSelf ()-> eventObject
			.to('prop').of(objectA).bothWays()
			.and('prop').of(objectB).bothWays()
			.and ()-> eventInvokeCount++
		
5518
		eventEmitterA.emit 'someEvent'
		expect(objectA.prop).to.equal eventObject
		expect(objectB.prop).to.equal(objectA.prop)
		expect(eventInvokeCount).to.equal 1

5524
		objectA.prop = 'different value'
		expect(objectA.prop).to.equal 'different value'
		# expect(objectB.prop).to.equal eventObject
		expect(eventInvokeCount).to.equal 2
		
		objectB.prop = 'different value2'
		expect(eventInvokeCount).to.equal 3
5532
5533
		SimplyBind.unBindAll(eventEmitterA)
		objectA.prop = 'different value'
		eventEmitterA.emit 'someEvent'
		eventEmitterA.on 'someEvent', ()-> eventInvokeCount++
5538
		expect(objectA.prop).to.equal 'different value'
		expect(objectB.prop).to.equal 'different value2'
		expect(eventInvokeCount).to.equal 3
		
5543
		objectA.prop = 'another value'
		expect(objectA.prop).to.equal 'another value'
		expect(objectB.prop).to.equal 'different value2'
		
		objectB.prop = 'another value2'
		expect(objectA.prop).to.equal 'another value'
		expect(objectB.prop).to.equal 'another value2'
		expect(eventInvokeCount).to.equal 5
		expect(binding._.deps.length).to.equal 0
		
		restartSandbox()
5555
5556
5557
5558
5559
suite "Will unBind all bindings in both directions if passed true as the second argument", ()->
	suiteSetup(restartSandbox)
5562
	test "ObjectProp", ()->
		SimplyBind('prop1').of(objectA)
			.to('prop1').of(objectB).bothWays()
		
		SimplyBind('prop2').of(objectA)
			.to('prop2').of(objectB).bothWays()
5569
		objectA.prop1 = 'objectA.prop1'
		expect(objectA.prop1).to.equal 'objectA.prop1'
		expect(objectB.prop1).to.equal 'objectA.prop1'
		
		objectB.prop2 = 'objectB.prop2'
		expect(objectA.prop2).to.equal 'objectB.prop2'
		expect(objectB.prop2).to.equal 'objectB.prop2'
		
		objectB.prop1 = 'reset'
		objectB.prop2 = 'reset'
		SimplyBind.unBindAll(objectA, true)
5581
		objectA.prop1 = 'objectA.prop1'
		expect(objectA.prop1).to.equal 'objectA.prop1'
		expect(objectB.prop1).to.equal 'reset'
		
		objectA.prop2 = 'objectA.prop2'
		expect(objectA.prop2).to.equal 'objectA.prop2'
		expect(objectB.prop2).to.equal 'reset'
		
		objectB.prop2 = 'objectB.prop2'
		expect(objectA.prop2).to.equal 'objectA.prop2'
		expect(objectB.prop2).to.equal 'objectB.prop2'
5593
		restartSandbox()
5595
5596
5597
	test "DOMText", ()-> if not isBrowser then @skip() else
		SimplyBind('textContent').of(regA)
			.to('textContent').of(regB).bothWays()
		
		SimplyBind('textContent').of(regA).set 'regA.textContent'
		expect(regA.textContent).to.equal 'regA.textContent'
		expect(regB.textContent).to.equal 'regA.textContent'
						
		SimplyBind('textContent').of(regB).set 'reset'
		SimplyBind.unBindAll(regA, true)
5608
		SimplyBind('textContent').of(regA).set 'regA.textContent'
		expect(regA.textContent).to.equal 'regA.textContent'
		expect(regB.textContent).to.equal 'reset'
						
		SimplyBind('textContent').of(regB).set 'regB.textContent'
		expect(regA.textContent).to.equal 'regA.textContent'
		expect(regB.textContent).to.equal 'regB.textContent'
5616
		restartSandbox()
5618
5619
5620
	test "DOMValue", ()-> if not isBrowser then @skip() else
		SimplyBind('value').of(inputA)
			.to('value').of(inputB).bothWays()
		
		inputA.value = 'inputA.value'
		inputA.emit 'change'
		expect(inputA.value).to.equal 'inputA.value'
		expect(inputB.value).to.equal 'inputA.value'
		
5630
		inputB.value = 'reset'
		SimplyBind.unBindAll(inputA, true)
5633
		inputA.value = 'inputA.value'
		inputA.emit 'change'
		expect(inputA.value).to.equal 'inputA.value'
		expect(inputB.value).to.equal 'reset'
5638
		inputB.value = 'inputB.value'
		inputB.emit 'change'
		expect(inputA.value).to.equal 'inputA.value'
		expect(inputB.value).to.equal 'inputB.value'
5643
		restartSandbox()
5645
5646
5647
	test "Function", ()->
		passedValue = null
		valueToPass = 1
		takeFromReceiver = false
		fn = (fromReceiver)-> passedValue = if takeFromReceiver then fromReceiver else valueToPass
		invoker = 'prop':'value'
		receiver = 'prop':undefined
5655
		SimplyBind('prop').of(invoker).to(fn)
		SimplyBind(fn).to('prop').of(receiver).bothWays()
5658
		expect(receiver.prop).to.equal 1
		expect(passedValue).to.equal 1
		
		valueToPass = 5
		invoker.prop = 'anotherValue'
		expect(receiver.prop).to.equal 5
		expect(passedValue).to.equal 5
		
		takeFromReceiver = true
		receiver.prop = 10
		takeFromReceiver = false
		expect(passedValue).to.equal 10
5671
		
		SimplyBind.unBindAll(fn, true)
		valueToPass = 15
		invoker.prop = 'newValue'
		expect(receiver.prop).to.equal 10
		expect(passedValue).to.equal 15
5678
		takeFromReceiver = true
		receiver.prop = 20
		takeFromReceiver = false
		expect(passedValue).to.equal 15
		
5684
5685
	test "Event", ()->
		eventInvokeCount = 0
		eventObject = null
		objectA.prop = objectB.prop = 'someValue'
		eventEmitterA.on 'someEvent', (event)-> eventObject = event or @
		
		binding = SimplyBind(0).ofEvent('someEvent').of(eventEmitterA).transformSelf ()-> eventObject
			.to('prop').of(objectA).bothWays()
			.and('prop').of(objectB).bothWays()
			.and ()-> eventInvokeCount++
		
5697
		eventEmitterA.emit 'someEvent'
		expect(objectA.prop).to.equal eventObject
		expect(objectB.prop).to.equal(objectA.prop)
		expect(eventInvokeCount).to.equal 1

5703
		objectA.prop = 'different value'
		expect(objectA.prop).to.equal 'different value'
		# expect(objectB.prop).to.equal eventObject
		expect(eventInvokeCount).to.equal 2
		
		objectB.prop = 'different value2'
		expect(eventInvokeCount).to.equal 3
5711
5712
		SimplyBind.unBindAll(eventEmitterA, true)
		objectA.prop = 'different value'
		eventEmitterA.emit 'someEvent'
		eventEmitterA.on 'someEvent', ()-> eventInvokeCount++
5717
		expect(objectA.prop).to.equal 'different value'
		expect(objectB.prop).to.equal 'different value2'
		expect(eventInvokeCount).to.equal 3
		
5722
		objectA.prop = 'another value'
		expect(objectA.prop).to.equal 'another value'
		expect(objectB.prop).to.equal 'different value2'
		
		objectB.prop = 'another value2'
		expect(objectA.prop).to.equal 'another value'
		expect(objectB.prop).to.equal 'another value2'
		expect(eventInvokeCount).to.equal 3
		expect(binding._.deps.length).to.equal 0
		
		restartSandbox()
		
5735

5737
5738
5739
5740
5741
5742
test "Passing objects that were never bound to anything should have no effects and shouldn't trigger any errors", ()->
	expect(()->
		SimplyBind.unBindAll 'nonbinded': 'object'
		SimplyBind.unBindAll 'string'
		SimplyBind('prop1').of(objectA).to ()->
		SimplyBind.unBindAll objectA
		SimplyBind.unBindAll objectA
	).not.to.throw()
5751
5752
5753
5754
5755
5756
5757
5758
5759
5760
5761
5762
5763
5764
5765
5766
5767
5768
5769
5770
5771
5772
5773
5774
5775
5776
5777
1	`if mocha? and window?`
2	`isBrowser = true`
3	`mocha.setup('tdd')`
4	`mocha.bail() unless @isSauceLabsTest or location.hostname`
5	`else`
6	`isBrowser = false`
7	`global.window = global`
8	`chai = require 'chai'`
9	`chaiSpies = require 'chai-spies'`
10	`SimplyBind = require '../dist/simplybind.node.js'`
11	`startSandbox = require('./spec-helper.js').startSandbox`
12	`restartSandbox = require('./spec-helper.js').restartSandbox`
13	`chai.use chaiSpies`
14
15	`expect = chai.expect`
16	`should = chai.should()`
17
18
19
20	`suite "SimplyBind", ()->`
21	`suiteSetup(startSandbox)`
22
23	`suite "Options", ()->`
24	`test "SimplyBind.options should contain the global options list", ()->`
25	`options = SimplyBind.options`
26	`expect(options.silent).not.to.be.undefined`
27	`expect(options.liveProps).not.to.be.undefined`
28	`expect(options.dispatchEvents).not.to.be.undefined`
29	`expect(options.updateEvenIfSame).not.to.be.undefined`
30	`expect(options.updateOnBind).not.to.be.undefined`
31	`expect(options.mutateInherited).not.to.be.undefined`
32	`expect(options.trackArrayChildren).not.to.be.undefined`
33	`expect(options.simpleSelector).not.to.be.undefined`
34	`expect(options.promiseTransforms).not.to.be.undefined`
35	`expect(options.placeholder).not.to.be.undefined`
36
37
38
39	`test "SimplyBind.options should return a non-editable copy of the global options list", ()->`
40	`expect(SimplyBind.options.dispatchEvents).to.be.false`