ballonizer 0.1.0 → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (38) hide show
  1. checksums.yaml +4 -4
  2. data/examples/ballonizer_app/config.ru +59 -0
  3. data/examples/ballonizer_app/index.html +159 -0
  4. data/examples/ballonizer_js_module/index.html +196 -0
  5. data/lib/assets/javascripts/ballonizer.js +482 -0
  6. data/lib/assets/stylesheets/ballonizer.css +78 -0
  7. data/lib/ballonizer.rb +201 -36
  8. data/spec/ballonizer_spec.rb +153 -2
  9. data/spec/javascripts/ballonizer_spec.js +568 -0
  10. data/spec/javascripts/fixtures/ballonized-xkcd-with-anchor-in-image.html +163 -0
  11. data/spec/javascripts/fixtures/ballonized-xkcd-with-ballons.html +163 -0
  12. data/spec/javascripts/fixtures/ballonized-xkcd-without-ballons.html +163 -0
  13. data/spec/javascripts/fixtures/xkcd.css +191 -0
  14. data/spec/javascripts/helpers/jasmine-jquery.js +660 -0
  15. data/spec/javascripts/helpers/jquery.simulate-ext.js +32 -0
  16. data/spec/javascripts/helpers/jquery.simulate.drag-n-drop.js +583 -0
  17. data/spec/javascripts/helpers/jquery.simulate.js +328 -0
  18. data/spec/javascripts/support/jasmine.yml +99 -0
  19. data/vendor/assets/javascripts/jquery-2.0.1.js +8837 -0
  20. data/vendor/assets/javascripts/jquery-ui-1.10.3.custom.min.js +6 -0
  21. data/vendor/assets/javascripts/jquery.json-2.4.min.js +24 -0
  22. data/vendor/assets/stylesheets/ui-lightness/images/animated-overlay.gif +0 -0
  23. data/vendor/assets/stylesheets/ui-lightness/images/ui-bg_diagonals-thick_18_b81900_40x40.png +0 -0
  24. data/vendor/assets/stylesheets/ui-lightness/images/ui-bg_diagonals-thick_20_666666_40x40.png +0 -0
  25. data/vendor/assets/stylesheets/ui-lightness/images/ui-bg_flat_10_000000_40x100.png +0 -0
  26. data/vendor/assets/stylesheets/ui-lightness/images/ui-bg_glass_100_f6f6f6_1x400.png +0 -0
  27. data/vendor/assets/stylesheets/ui-lightness/images/ui-bg_glass_100_fdf5ce_1x400.png +0 -0
  28. data/vendor/assets/stylesheets/ui-lightness/images/ui-bg_glass_65_ffffff_1x400.png +0 -0
  29. data/vendor/assets/stylesheets/ui-lightness/images/ui-bg_gloss-wave_35_f6a828_500x100.png +0 -0
  30. data/vendor/assets/stylesheets/ui-lightness/images/ui-bg_highlight-soft_100_eeeeee_1x100.png +0 -0
  31. data/vendor/assets/stylesheets/ui-lightness/images/ui-bg_highlight-soft_75_ffe45c_1x100.png +0 -0
  32. data/vendor/assets/stylesheets/ui-lightness/images/ui-icons_222222_256x240.png +0 -0
  33. data/vendor/assets/stylesheets/ui-lightness/images/ui-icons_228ef1_256x240.png +0 -0
  34. data/vendor/assets/stylesheets/ui-lightness/images/ui-icons_ef8c08_256x240.png +0 -0
  35. data/vendor/assets/stylesheets/ui-lightness/images/ui-icons_ffd27a_256x240.png +0 -0
  36. data/vendor/assets/stylesheets/ui-lightness/images/ui-icons_ffffff_256x240.png +0 -0
  37. data/vendor/assets/stylesheets/ui-lightness/jquery-ui-1.10.3.custom.min.css +5 -0
  38. metadata +51 -3
@@ -0,0 +1,660 @@
1
+ /*!
2
+ Jasmine-jQuery: a set of jQuery helpers for Jasmine tests.
3
+
4
+ Version 1.5.2
5
+
6
+ https://github.com/velesin/jasmine-jquery
7
+
8
+ Copyright (c) 2010-2013 Wojciech Zawistowski, Travis Jeffery
9
+
10
+ Permission is hereby granted, free of charge, to any person obtaining
11
+ a copy of this software and associated documentation files (the
12
+ "Software"), to deal in the Software without restriction, including
13
+ without limitation the rights to use, copy, modify, merge, publish,
14
+ distribute, sublicense, and/or sell copies of the Software, and to
15
+ permit persons to whom the Software is furnished to do so, subject to
16
+ the following conditions:
17
+
18
+ The above copyright notice and this permission notice shall be
19
+ included in all copies or substantial portions of the Software.
20
+
21
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
22
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
23
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
24
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
25
+ LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
26
+ OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
27
+ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
28
+ */
29
+ var readFixtures = function() {
30
+ return jasmine.getFixtures().proxyCallTo_('read', arguments)
31
+ }
32
+
33
+ var preloadFixtures = function() {
34
+ jasmine.getFixtures().proxyCallTo_('preload', arguments)
35
+ }
36
+
37
+ var loadFixtures = function() {
38
+ jasmine.getFixtures().proxyCallTo_('load', arguments)
39
+ }
40
+
41
+ var appendLoadFixtures = function() {
42
+ jasmine.getFixtures().proxyCallTo_('appendLoad', arguments)
43
+ }
44
+
45
+ var setFixtures = function(html) {
46
+ jasmine.getFixtures().proxyCallTo_('set', arguments)
47
+ }
48
+
49
+ var appendSetFixtures = function() {
50
+ jasmine.getFixtures().proxyCallTo_('appendSet', arguments)
51
+ }
52
+
53
+ var sandbox = function(attributes) {
54
+ return jasmine.getFixtures().sandbox(attributes)
55
+ }
56
+
57
+ var spyOnEvent = function(selector, eventName) {
58
+ return jasmine.JQuery.events.spyOn(selector, eventName)
59
+ }
60
+
61
+ var preloadStyleFixtures = function() {
62
+ jasmine.getStyleFixtures().proxyCallTo_('preload', arguments)
63
+ }
64
+
65
+ var loadStyleFixtures = function() {
66
+ jasmine.getStyleFixtures().proxyCallTo_('load', arguments)
67
+ }
68
+
69
+ var appendLoadStyleFixtures = function() {
70
+ jasmine.getStyleFixtures().proxyCallTo_('appendLoad', arguments)
71
+ }
72
+
73
+ var setStyleFixtures = function(html) {
74
+ jasmine.getStyleFixtures().proxyCallTo_('set', arguments)
75
+ }
76
+
77
+ var appendSetStyleFixtures = function(html) {
78
+ jasmine.getStyleFixtures().proxyCallTo_('appendSet', arguments)
79
+ }
80
+
81
+ var loadJSONFixtures = function() {
82
+ return jasmine.getJSONFixtures().proxyCallTo_('load', arguments)
83
+ }
84
+
85
+ var getJSONFixture = function(url) {
86
+ return jasmine.getJSONFixtures().proxyCallTo_('read', arguments)[url]
87
+ }
88
+
89
+ jasmine.spiedEventsKey = function (selector, eventName) {
90
+ return [$(selector).selector, eventName].toString()
91
+ }
92
+
93
+ jasmine.getFixtures = function() {
94
+ return jasmine.currentFixtures_ = jasmine.currentFixtures_ || new jasmine.Fixtures()
95
+ }
96
+
97
+ jasmine.getStyleFixtures = function() {
98
+ return jasmine.currentStyleFixtures_ = jasmine.currentStyleFixtures_ || new jasmine.StyleFixtures()
99
+ }
100
+
101
+ jasmine.Fixtures = function() {
102
+ this.containerId = 'jasmine-fixtures'
103
+ this.fixturesCache_ = {}
104
+ this.fixturesPath = 'spec/javascripts/fixtures'
105
+ }
106
+
107
+ jasmine.Fixtures.prototype.set = function(html) {
108
+ this.cleanUp()
109
+ this.createContainer_(html)
110
+ }
111
+
112
+ jasmine.Fixtures.prototype.appendSet= function(html) {
113
+ this.addToContainer_(html)
114
+ }
115
+
116
+ jasmine.Fixtures.prototype.preload = function() {
117
+ this.read.apply(this, arguments)
118
+ }
119
+
120
+ jasmine.Fixtures.prototype.load = function() {
121
+ this.cleanUp()
122
+ this.createContainer_(this.read.apply(this, arguments))
123
+ }
124
+
125
+ jasmine.Fixtures.prototype.appendLoad = function() {
126
+ this.addToContainer_(this.read.apply(this, arguments))
127
+ }
128
+
129
+ jasmine.Fixtures.prototype.read = function() {
130
+ var htmlChunks = []
131
+
132
+ var fixtureUrls = arguments
133
+ for(var urlCount = fixtureUrls.length, urlIndex = 0; urlIndex < urlCount; urlIndex++) {
134
+ htmlChunks.push(this.getFixtureHtml_(fixtureUrls[urlIndex]))
135
+ }
136
+
137
+ return htmlChunks.join('')
138
+ }
139
+
140
+ jasmine.Fixtures.prototype.clearCache = function() {
141
+ this.fixturesCache_ = {}
142
+ }
143
+
144
+ jasmine.Fixtures.prototype.cleanUp = function() {
145
+ $('#' + this.containerId).remove()
146
+ }
147
+
148
+ jasmine.Fixtures.prototype.sandbox = function(attributes) {
149
+ var attributesToSet = attributes || {}
150
+ return $('<div id="sandbox" />').attr(attributesToSet)
151
+ }
152
+
153
+ jasmine.Fixtures.prototype.createContainer_ = function(html) {
154
+ var container
155
+ if(html instanceof $) {
156
+ container = $('<div id="' + this.containerId + '" />')
157
+ container.html(html)
158
+ } else {
159
+ container = '<div id="' + this.containerId + '">' + html + '</div>'
160
+ }
161
+ $(document.body).append(container)
162
+ }
163
+
164
+ jasmine.Fixtures.prototype.addToContainer_ = function(html){
165
+ var container = $(document.body).find('#'+this.containerId).append(html)
166
+ if(!container.length){
167
+ this.createContainer_(html)
168
+ }
169
+ }
170
+
171
+ jasmine.Fixtures.prototype.getFixtureHtml_ = function(url) {
172
+ if (typeof this.fixturesCache_[url] === 'undefined') {
173
+ this.loadFixtureIntoCache_(url)
174
+ }
175
+ return this.fixturesCache_[url]
176
+ }
177
+
178
+ jasmine.Fixtures.prototype.loadFixtureIntoCache_ = function(relativeUrl) {
179
+ var url = this.makeFixtureUrl_(relativeUrl)
180
+ var request = $.ajax({
181
+ type: "GET",
182
+ url: url + "?" + new Date().getTime(),
183
+ async: false
184
+ })
185
+ this.fixturesCache_[relativeUrl] = request.responseText
186
+ }
187
+
188
+ jasmine.Fixtures.prototype.makeFixtureUrl_ = function(relativeUrl){
189
+ return this.fixturesPath.match('/$') ? this.fixturesPath + relativeUrl : this.fixturesPath + '/' + relativeUrl
190
+ }
191
+
192
+ jasmine.Fixtures.prototype.proxyCallTo_ = function(methodName, passedArguments) {
193
+ return this[methodName].apply(this, passedArguments)
194
+ }
195
+
196
+
197
+ jasmine.StyleFixtures = function() {
198
+ this.fixturesCache_ = {}
199
+ this.fixturesNodes_ = []
200
+ this.fixturesPath = 'spec/javascripts/fixtures'
201
+ }
202
+
203
+ jasmine.StyleFixtures.prototype.set = function(css) {
204
+ this.cleanUp()
205
+ this.createStyle_(css)
206
+ }
207
+
208
+ jasmine.StyleFixtures.prototype.appendSet = function(css) {
209
+ this.createStyle_(css)
210
+ }
211
+
212
+ jasmine.StyleFixtures.prototype.preload = function() {
213
+ this.read_.apply(this, arguments)
214
+ }
215
+
216
+ jasmine.StyleFixtures.prototype.load = function() {
217
+ this.cleanUp()
218
+ this.createStyle_(this.read_.apply(this, arguments))
219
+ }
220
+
221
+ jasmine.StyleFixtures.prototype.appendLoad = function() {
222
+ this.createStyle_(this.read_.apply(this, arguments))
223
+ }
224
+
225
+ jasmine.StyleFixtures.prototype.cleanUp = function() {
226
+ while(this.fixturesNodes_.length) {
227
+ this.fixturesNodes_.pop().remove()
228
+ }
229
+ }
230
+
231
+ jasmine.StyleFixtures.prototype.createStyle_ = function(html) {
232
+ var styleText = $('<div></div>').html(html).text(),
233
+ style = $('<style>' + styleText + '</style>')
234
+
235
+ this.fixturesNodes_.push(style)
236
+
237
+ $('head').append(style)
238
+ }
239
+
240
+ jasmine.StyleFixtures.prototype.clearCache = jasmine.Fixtures.prototype.clearCache
241
+
242
+ jasmine.StyleFixtures.prototype.read_ = jasmine.Fixtures.prototype.read
243
+
244
+ jasmine.StyleFixtures.prototype.getFixtureHtml_ = jasmine.Fixtures.prototype.getFixtureHtml_
245
+
246
+ jasmine.StyleFixtures.prototype.loadFixtureIntoCache_ = jasmine.Fixtures.prototype.loadFixtureIntoCache_
247
+
248
+ jasmine.StyleFixtures.prototype.makeFixtureUrl_ = jasmine.Fixtures.prototype.makeFixtureUrl_
249
+
250
+ jasmine.StyleFixtures.prototype.proxyCallTo_ = jasmine.Fixtures.prototype.proxyCallTo_
251
+
252
+ jasmine.getJSONFixtures = function() {
253
+ return jasmine.currentJSONFixtures_ = jasmine.currentJSONFixtures_ || new jasmine.JSONFixtures()
254
+ }
255
+
256
+ jasmine.JSONFixtures = function() {
257
+ this.fixturesCache_ = {}
258
+ this.fixturesPath = 'spec/javascripts/fixtures/json'
259
+ }
260
+
261
+ jasmine.JSONFixtures.prototype.load = function() {
262
+ this.read.apply(this, arguments)
263
+ return this.fixturesCache_
264
+ }
265
+
266
+ jasmine.JSONFixtures.prototype.read = function() {
267
+ var fixtureUrls = arguments
268
+ for(var urlCount = fixtureUrls.length, urlIndex = 0; urlIndex < urlCount; urlIndex++) {
269
+ this.getFixtureData_(fixtureUrls[urlIndex])
270
+ }
271
+ return this.fixturesCache_
272
+ }
273
+
274
+ jasmine.JSONFixtures.prototype.clearCache = function() {
275
+ this.fixturesCache_ = {}
276
+ }
277
+
278
+ jasmine.JSONFixtures.prototype.getFixtureData_ = function(url) {
279
+ this.loadFixtureIntoCache_(url)
280
+ return this.fixturesCache_[url]
281
+ }
282
+
283
+ jasmine.JSONFixtures.prototype.loadFixtureIntoCache_ = function(relativeUrl) {
284
+ var self = this
285
+ var url = this.fixturesPath.match('/$') ? this.fixturesPath + relativeUrl : this.fixturesPath + '/' + relativeUrl
286
+ $.ajax({
287
+ async: false, // must be synchronous to guarantee that no tests are run before fixture is loaded
288
+ cache: false,
289
+ dataType: 'json',
290
+ url: url,
291
+ success: function(data) {
292
+ self.fixturesCache_[relativeUrl] = data
293
+ },
294
+ error: function(jqXHR, status, errorThrown) {
295
+ throw Error('JSONFixture could not be loaded: ' + url + ' (status: ' + status + ', message: ' + errorThrown.message + ')')
296
+ }
297
+ })
298
+ }
299
+
300
+ jasmine.JSONFixtures.prototype.proxyCallTo_ = function(methodName, passedArguments) {
301
+ return this[methodName].apply(this, passedArguments)
302
+ }
303
+
304
+ jasmine.JQuery = function() {}
305
+
306
+ jasmine.JQuery.browserTagCaseIndependentHtml = function(html) {
307
+ return $('<div/>').append(html).html()
308
+ }
309
+
310
+ jasmine.JQuery.elementToString = function(element) {
311
+ var domEl = $(element).get(0)
312
+ if (domEl == undefined || domEl.cloneNode)
313
+ return $('<div />').append($(element).clone()).html()
314
+ else
315
+ return element.toString()
316
+ }
317
+
318
+ jasmine.JQuery.matchersClass = {}
319
+
320
+ !function(namespace) {
321
+ var data = {
322
+ spiedEvents: {},
323
+ handlers: []
324
+ }
325
+
326
+ namespace.events = {
327
+ spyOn: function(selector, eventName) {
328
+ var handler = function(e) {
329
+ data.spiedEvents[jasmine.spiedEventsKey(selector, eventName)] = jasmine.util.argsToArray(arguments)
330
+ }
331
+ $(selector).on(eventName, handler)
332
+ data.handlers.push(handler)
333
+ return {
334
+ selector: selector,
335
+ eventName: eventName,
336
+ handler: handler,
337
+ reset: function(){
338
+ delete data.spiedEvents[jasmine.spiedEventsKey(selector, eventName)]
339
+ }
340
+ }
341
+ },
342
+
343
+ args: function(selector, eventName) {
344
+ var actualArgs = data.spiedEvents[jasmine.spiedEventsKey(selector, eventName)];
345
+
346
+ if (!actualArgs) {
347
+ throw "There is no spy for " + eventName + " on " + selector.toString() + ". Make sure to create a spy using spyOnEvent.";
348
+ }
349
+
350
+ return actualArgs;
351
+ },
352
+
353
+ wasTriggered: function(selector, eventName) {
354
+ return !!(data.spiedEvents[jasmine.spiedEventsKey(selector, eventName)])
355
+ },
356
+
357
+ wasTriggeredWith: function(selector, eventName, expectedArgs, env) {
358
+ var actualArgs = jasmine.JQuery.events.args(selector, eventName).slice(1);
359
+ if (Object.prototype.toString.call(expectedArgs) !== '[object Array]') {
360
+ actualArgs = actualArgs[0];
361
+ }
362
+ return env.equals_(expectedArgs, actualArgs);
363
+ },
364
+
365
+ wasPrevented: function(selector, eventName) {
366
+ var args = data.spiedEvents[jasmine.spiedEventsKey(selector, eventName)],
367
+ e = args ? args[0] : undefined;
368
+ return e && e.isDefaultPrevented()
369
+ },
370
+
371
+ wasStopped: function(selector, eventName) {
372
+ var args = data.spiedEvents[jasmine.spiedEventsKey(selector, eventName)],
373
+ e = args ? args[0] : undefined;
374
+ return e && e.isPropagationStopped()
375
+ },
376
+
377
+ cleanUp: function() {
378
+ data.spiedEvents = {}
379
+ data.handlers = []
380
+ }
381
+ }
382
+ }(jasmine.JQuery)
383
+
384
+ !function(){
385
+ var jQueryMatchers = {
386
+ toHaveClass: function(className) {
387
+ return this.actual.hasClass(className)
388
+ },
389
+
390
+ toHaveCss: function(css){
391
+ for (var prop in css){
392
+ if (this.actual.css(prop) !== css[prop]) return false
393
+ }
394
+ return true
395
+ },
396
+
397
+ toBeVisible: function() {
398
+ return this.actual.is(':visible')
399
+ },
400
+
401
+ toBeHidden: function() {
402
+ return this.actual.is(':hidden')
403
+ },
404
+
405
+ toBeSelected: function() {
406
+ return this.actual.is(':selected')
407
+ },
408
+
409
+ toBeChecked: function() {
410
+ return this.actual.is(':checked')
411
+ },
412
+
413
+ toBeEmpty: function() {
414
+ return this.actual.is(':empty')
415
+ },
416
+
417
+ toExist: function() {
418
+ return $(document).find(this.actual).length
419
+ },
420
+
421
+ toHaveLength: function(length) {
422
+ return this.actual.length === length
423
+ },
424
+
425
+ toHaveAttr: function(attributeName, expectedAttributeValue) {
426
+ return hasProperty(this.actual.attr(attributeName), expectedAttributeValue)
427
+ },
428
+
429
+ toHaveProp: function(propertyName, expectedPropertyValue) {
430
+ return hasProperty(this.actual.prop(propertyName), expectedPropertyValue)
431
+ },
432
+
433
+ toHaveId: function(id) {
434
+ return this.actual.attr('id') == id
435
+ },
436
+
437
+ toHaveHtml: function(html) {
438
+ return this.actual.html() == jasmine.JQuery.browserTagCaseIndependentHtml(html)
439
+ },
440
+
441
+ toContainHtml: function(html){
442
+ var actualHtml = this.actual.html()
443
+ var expectedHtml = jasmine.JQuery.browserTagCaseIndependentHtml(html)
444
+ return (actualHtml.indexOf(expectedHtml) >= 0)
445
+ },
446
+
447
+ toHaveText: function(text) {
448
+ var trimmedText = $.trim(this.actual.text())
449
+ if (text && $.isFunction(text.test)) {
450
+ return text.test(trimmedText)
451
+ } else {
452
+ return trimmedText == text
453
+ }
454
+ },
455
+
456
+ toContainText: function(text) {
457
+ var trimmedText = $.trim(this.actual.text())
458
+ if (text && $.isFunction(text.test)) {
459
+ return text.test(trimmedText)
460
+ } else {
461
+ return trimmedText.indexOf(text) != -1;
462
+ }
463
+ },
464
+
465
+ toHaveValue: function(value) {
466
+ return this.actual.val() === value
467
+ },
468
+
469
+ toHaveData: function(key, expectedValue) {
470
+ return hasProperty(this.actual.data(key), expectedValue)
471
+ },
472
+
473
+ toBe: function(selector) {
474
+ return this.actual.is(selector)
475
+ },
476
+
477
+ toContain: function(selector) {
478
+ return this.actual.find(selector).length
479
+ },
480
+
481
+ toBeDisabled: function(selector){
482
+ return this.actual.is(':disabled')
483
+ },
484
+
485
+ toBeFocused: function(selector) {
486
+ return this.actual[0] === this.actual[0].ownerDocument.activeElement
487
+ },
488
+
489
+ toHandle: function(event) {
490
+
491
+ var events = $._data(this.actual.get(0), "events")
492
+
493
+ if(!events || !event || typeof event !== "string") {
494
+ return false
495
+ }
496
+
497
+ var namespaces = event.split(".")
498
+ var eventType = namespaces.shift()
499
+ var sortedNamespaces = namespaces.slice(0).sort()
500
+ var namespaceRegExp = new RegExp("(^|\\.)" + sortedNamespaces.join("\\.(?:.*\\.)?") + "(\\.|$)")
501
+
502
+ if(events[eventType] && namespaces.length) {
503
+ for(var i = 0; i < events[eventType].length; i++) {
504
+ var namespace = events[eventType][i].namespace
505
+ if(namespaceRegExp.test(namespace)) {
506
+ return true
507
+ }
508
+ }
509
+ } else {
510
+ return events[eventType] && events[eventType].length > 0
511
+ }
512
+ },
513
+
514
+ // tests the existence of a specific event binding + handler
515
+ toHandleWith: function(eventName, eventHandler) {
516
+ var stack = $._data(this.actual.get(0), "events")[eventName]
517
+ for (var i = 0; i < stack.length; i++) {
518
+ if (stack[i].handler == eventHandler) return true
519
+ }
520
+ return false
521
+ }
522
+ }
523
+
524
+ var hasProperty = function(actualValue, expectedValue) {
525
+ if (expectedValue === undefined) return actualValue !== undefined
526
+ return actualValue == expectedValue
527
+ }
528
+
529
+ var bindMatcher = function(methodName) {
530
+ var builtInMatcher = jasmine.Matchers.prototype[methodName]
531
+
532
+ jasmine.JQuery.matchersClass[methodName] = function() {
533
+ if (this.actual
534
+ && (this.actual instanceof $
535
+ || jasmine.isDomNode(this.actual))) {
536
+ this.actual = $(this.actual)
537
+ var result = jQueryMatchers[methodName].apply(this, arguments)
538
+ var element
539
+ if (this.actual.get && (element = this.actual.get()[0]) && !$.isWindow(element) && element.tagName !== "HTML")
540
+ this.actual = jasmine.JQuery.elementToString(this.actual)
541
+ return result
542
+ }
543
+
544
+ if (builtInMatcher) {
545
+ return builtInMatcher.apply(this, arguments)
546
+ }
547
+
548
+ return false
549
+ }
550
+ }
551
+
552
+ for(var methodName in jQueryMatchers) {
553
+ bindMatcher(methodName)
554
+ }
555
+ }()
556
+
557
+ beforeEach(function() {
558
+ this.addMatchers(jasmine.JQuery.matchersClass)
559
+ this.addMatchers({
560
+ toHaveBeenTriggeredOn: function(selector) {
561
+ this.message = function() {
562
+ return [
563
+ "Expected event " + this.actual + " to have been triggered on " + selector,
564
+ "Expected event " + this.actual + " not to have been triggered on " + selector
565
+ ]
566
+ }
567
+ return jasmine.JQuery.events.wasTriggered(selector, this.actual)
568
+ }
569
+ })
570
+ this.addMatchers({
571
+ toHaveBeenTriggered: function(){
572
+ var eventName = this.actual.eventName,
573
+ selector = this.actual.selector
574
+ this.message = function() {
575
+ return [
576
+ "Expected event " + eventName + " to have been triggered on " + selector,
577
+ "Expected event " + eventName + " not to have been triggered on " + selector
578
+ ]
579
+ }
580
+ return jasmine.JQuery.events.wasTriggered(selector, eventName)
581
+ }
582
+ })
583
+ this.addMatchers({
584
+ toHaveBeenTriggeredOnAndWith: function() {
585
+ var selector = arguments[0],
586
+ expectedArgs = arguments[1],
587
+ wasTriggered = jasmine.JQuery.events.wasTriggered(selector, this.actual);
588
+ this.message = function() {
589
+ if (wasTriggered) {
590
+ var actualArgs = jasmine.JQuery.events.args(selector, this.actual, expectedArgs)[1];
591
+ return [
592
+ "Expected event " + this.actual + " to have been triggered with " + jasmine.pp(expectedArgs) + " but it was triggered with " + jasmine.pp(actualArgs),
593
+ "Expected event " + this.actual + " not to have been triggered with " + jasmine.pp(expectedArgs) + " but it was triggered with " + jasmine.pp(actualArgs)
594
+ ]
595
+ } else {
596
+ return [
597
+ "Expected event " + this.actual + " to have been triggered on " + selector,
598
+ "Expected event " + this.actual + " not to have been triggered on " + selector
599
+ ]
600
+ }
601
+ }
602
+ return wasTriggered && jasmine.JQuery.events.wasTriggeredWith(selector, this.actual, expectedArgs, this.env);
603
+ }
604
+ })
605
+ this.addMatchers({
606
+ toHaveBeenPreventedOn: function(selector) {
607
+ this.message = function() {
608
+ return [
609
+ "Expected event " + this.actual + " to have been prevented on " + selector,
610
+ "Expected event " + this.actual + " not to have been prevented on " + selector
611
+ ]
612
+ }
613
+ return jasmine.JQuery.events.wasPrevented(selector, this.actual)
614
+ }
615
+ })
616
+ this.addMatchers({
617
+ toHaveBeenPrevented: function() {
618
+ var eventName = this.actual.eventName,
619
+ selector = this.actual.selector
620
+ this.message = function() {
621
+ return [
622
+ "Expected event " + eventName + " to have been prevented on " + selector,
623
+ "Expected event " + eventName + " not to have been prevented on " + selector
624
+ ]
625
+ }
626
+ return jasmine.JQuery.events.wasPrevented(selector, eventName)
627
+ }
628
+ })
629
+ this.addMatchers({
630
+ toHaveBeenStoppedOn: function(selector) {
631
+ this.message = function() {
632
+ return [
633
+ "Expected event " + this.actual + " to have been stopped on " + selector,
634
+ "Expected event " + this.actual + " not to have been stopped on " + selector
635
+ ]
636
+ }
637
+ return jasmine.JQuery.events.wasStopped(selector, this.actual)
638
+ }
639
+ })
640
+ this.addMatchers({
641
+ toHaveBeenStopped: function() {
642
+ var eventName = this.actual.eventName,
643
+ selector = this.actual.selector
644
+ this.message = function() {
645
+ return [
646
+ "Expected event " + eventName + " to have been stopped on " + selector,
647
+ "Expected event " + eventName + " not to have been stopped on " + selector
648
+ ]
649
+ }
650
+ return jasmine.JQuery.events.wasStopped(selector, eventName)
651
+ }
652
+ })
653
+ })
654
+
655
+ afterEach(function() {
656
+ jasmine.getFixtures().cleanUp()
657
+ jasmine.getStyleFixtures().cleanUp()
658
+ jasmine.JQuery.events.cleanUp()
659
+ })
660
+
@@ -0,0 +1,32 @@
1
+
2
+ /*jshint camelcase:true, plusplus:true, forin:true, noarg:true, noempty:true, eqeqeq:true, bitwise:true, strict:true, undef:true, unused:true, curly:true, browser:true, devel:true, maxerr:100, white:false, onevar:false */
3
+ /*jslint white: true vars: true browser: true todo: true */
4
+ /*global jQuery:true $:true */
5
+
6
+ /* jQuery Simulate Extended Plugin 1.1.5
7
+ * http://github.com/j-ulrich/jquery-simulate-ext
8
+ *
9
+ * Copyright (c) 2013 Jochen Ulrich
10
+ * Licensed under the MIT license (MIT-LICENSE.txt).
11
+ */
12
+
13
+ ;(function( $ ) {
14
+ "use strict";
15
+
16
+ /* Overwrite the $.simulate.prototype.mouseEvent function
17
+ * to convert pageX/Y to clientX/Y
18
+ */
19
+ var originalMouseEvent = $.simulate.prototype.mouseEvent,
20
+ rdocument = /\[object (?:HTML)?Document\]/;
21
+
22
+ $.simulate.prototype.mouseEvent = function(type, options) {
23
+ if (options.pageX || options.pageY) {
24
+ var doc = rdocument.test(Object.prototype.toString.call(this.target))? this.target : (this.target.ownerDocument || document);
25
+ options.clientX = (options.pageX || 0) - $(doc).scrollLeft();
26
+ options.clientY = (options.pageY || 0) - $(doc).scrollTop();
27
+ }
28
+ return originalMouseEvent.apply(this, [type, options]);
29
+ };
30
+
31
+
32
+ })( jQuery );