├── .eslintrc
├── .gitignore
├── .travis.yml
├── CONTRIBUTING.md
├── Gemfile
├── Gemfile.lock
├── LICENSE
├── README.md
├── bower.json
├── jquery.pjax.js
├── package.json
├── script
    ├── bootstrap
    ├── server
    └── test
├── test
    ├── app.rb
    ├── evaled.js
    ├── favicon.ico
    ├── run-qunit.js
    ├── unit
    │   ├── fn_pjax.js
    │   ├── helpers.js
    │   ├── pjax.js
    │   └── pjax_fallback.js
    └── views
    │   ├── aliens.erb
    │   ├── anchor.erb
    │   ├── boom.erb
    │   ├── boom_sans_pjax.erb
    │   ├── dinosaurs.erb
    │   ├── double_title.erb
    │   ├── empty.erb
    │   ├── env.erb
    │   ├── fragment.erb
    │   ├── hello.erb
    │   ├── home.erb
    │   ├── layout.erb
    │   ├── long.erb
    │   ├── nested_title.erb
    │   ├── qunit.erb
    │   ├── referer.erb
    │   ├── scripts.erb
    │   └── timeout.erb
└── vendor
    ├── jquery-1.12.js
    ├── jquery-2.2.js
    ├── jquery-3.2.js
    ├── qunit.css
    └── qunit.js


/.eslintrc:
--------------------------------------------------------------------------------
 1 | { "extends": "eslint:recommended",
 2 |   "env": {
 3 |     "browser": true,
 4 |     "jquery": true
 5 |   },
 6 |   "rules": {
 7 |     "eqeqeq": "warn",
 8 |     "no-eval": "error",
 9 |     "no-extra-parens": "error",
10 |     "no-implicit-globals": "error",
11 |     "no-trailing-spaces": "error",
12 |     "no-unused-expressions": "error",
13 |     "semi": ["error", "never"]
14 |   }
15 | }
16 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules/
2 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | sudo: false
 2 | language: node_js
 3 | node_js: "6"
 4 | before_script: script/bootstrap
 5 | 
 6 | notifications:
 7 |   email: false
 8 | deploy:
 9 |   provider: npm
10 |   email: mislav.marohnic@gmail.com
11 |   api_key:
12 |     secure: nstPtsdxAHGPkKl2wOnMW4FXHg1nKxG/yCYQYqiC61JqhbfSaZFVjIQrdH+9GSel7F/K7VLwGZwSVgfiWUymWeEsNw8R/cyI9xCXf5iNF6WHIwuX6Q3Tnvb3Cx/bkeoc8+4v7qR172FtzwKWJq2iKXawd58/4zf2sduOwld1PMw=
13 |   on:
14 |     tags: true
15 |     repo: defunkt/jquery-pjax
16 | 


--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
 1 | # Contributing
 2 | 
 3 | For running the tests, you will need:
 4 | 
 5 | * Ruby 1.9.3+ with Bundler
 6 | * PhantomJS (for headless testing)
 7 | 
 8 | First run bootstrap to ensure necessary dependencies:
 9 | 
10 | ```
11 | $ script/bootstrap
12 | ```
13 | 
14 | Then run headless tests in the console:
15 | 
16 | ```
17 | $ script/test [<test-file>]
18 | ```
19 | 
20 | To run tests in other browsers, start a server:
21 | 
22 | ```
23 | $ script/server
24 | # now open http://localhost:4567/
25 | ```
26 | 
27 | ## Test structure
28 | 
29 | There are 3 main test modules:
30 | 
31 | * `test/unit/fn_pjax.js` - Primarily tests the `$.fn.pjax` method and its options
32 | * `test/unit/pjax.js` - Main comprehensive pjax functionality tests
33 | * `test/unit/pjax_fallback.js` - Tests that verify same result after navigation
34 |   even if pjax is disabled (like for browsers that don't support pushState).
35 | 
36 | Each test drives a hidden test page in an `<iframe>`. See other tests to see how
37 | they trigger pjax by using the `frame` reference and remember to do so as well.
38 | 


--------------------------------------------------------------------------------
/Gemfile:
--------------------------------------------------------------------------------
1 | source 'https://rubygems.org'
2 | 
3 | gem 'sinatra'
4 | 


--------------------------------------------------------------------------------
/Gemfile.lock:
--------------------------------------------------------------------------------
 1 | GEM
 2 |   remote: https://rubygems.org/
 3 |   specs:
 4 |     rack (1.5.2)
 5 |     rack-protection (1.5.3)
 6 |       rack
 7 |     sinatra (1.4.5)
 8 |       rack (~> 1.4)
 9 |       rack-protection (~> 1.4)
10 |       tilt (~> 1.3, >= 1.3.4)
11 |     tilt (1.4.1)
12 | 
13 | PLATFORMS
14 |   ruby
15 | 
16 | DEPENDENCIES
17 |   sinatra
18 | 
19 | BUNDLED WITH
20 |    1.14.6
21 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) Chris Wanstrath
 2 | 
 3 | Permission is hereby granted, free of charge, to any person obtaining
 4 | a copy of this software and associated documentation files (the
 5 | Software), to deal in the Software without restriction, including
 6 | without limitation the rights to use, copy, modify, merge, publish,
 7 | distribute, sublicense, and/or sell copies of the Software, and to
 8 | permit persons to whom the Software is furnished to do so, subject to
 9 | the following conditions:
10 | 
11 | The above copyright notice and this permission notice shall be
12 | included in all copies or substantial portions of the Software.
13 | 
14 | THE SOFTWARE IS PROVIDED AS IS, WITHOUT WARRANTY OF ANY KIND,
15 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
16 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
17 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
18 | LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
19 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
20 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # pjax = pushState + ajax
  2 | 
  3 | pjax is a jQuery plugin that uses ajax and pushState to deliver a fast browsing experience with real permalinks, page titles, and a working back button.
  4 | 
  5 | pjax works by fetching HTML from your server via ajax and replacing the content
  6 | of a container element on your page with the loaded HTML. It then updates the
  7 | current URL in the browser using pushState. This results in faster page
  8 | navigation for two reasons:
  9 | 
 10 | * No page resources (JS, CSS) get re-executed or re-applied;
 11 | * If the server is configured for pjax, it can render only partial page
 12 |   contents and thus avoid the potentially costly full layout render.
 13 | 
 14 | ### Status of this project
 15 | 
 16 | jquery-pjax is **largely unmaintained** at this point. It might continue to
 17 | receive important bug fixes, but _its feature set is frozen_ and it's unlikely
 18 | that it will get new features or enhancements.
 19 | 
 20 | ## Installation
 21 | 
 22 | pjax depends on jQuery 1.8 or higher.
 23 | 
 24 | ### npm
 25 | 
 26 | ```
 27 | $ npm install jquery-pjax
 28 | ```
 29 | 
 30 | ### standalone script
 31 | 
 32 | Download and include `jquery.pjax.js` in your web page:
 33 | 
 34 | ```
 35 | curl -LO https://raw.github.com/defunkt/jquery-pjax/master/jquery.pjax.js
 36 | ```
 37 | 
 38 | ## Usage
 39 | 
 40 | ### `$.fn.pjax`
 41 | 
 42 | The simplest and most common use of pjax looks like this:
 43 | 
 44 | ``` javascript
 45 | $(document).pjax('a', '#pjax-container')
 46 | ```
 47 | 
 48 | This will enable pjax on all links on the page and designate the container as `#pjax-container`.
 49 | 
 50 | If you are migrating an existing site, you probably don't want to enable pjax
 51 | everywhere just yet. Instead of using a global selector like `a`, try annotating
 52 | pjaxable links with `data-pjax`, then use `'a[data-pjax]'` as your selector. Or,
 53 | try this selector that matches any `<a data-pjax href=>` links inside a `<div
 54 | data-pjax>` container:
 55 | 
 56 | ``` javascript
 57 | $(document).pjax('[data-pjax] a, a[data-pjax]', '#pjax-container')
 58 | ```
 59 | 
 60 | #### Server-side configuration
 61 | 
 62 | Ideally, your server should detect pjax requests by looking at the special
 63 | `X-PJAX` HTTP header, and render only the HTML meant to replace the contents of
 64 | the container element (`#pjax-container` in our example) without the rest of
 65 | the page layout. Here is an example of how this might be done in Ruby on Rails:
 66 | 
 67 | ``` ruby
 68 | def index
 69 |   if request.headers['X-PJAX']
 70 |     render :layout => false
 71 |   end
 72 | end
 73 | ```
 74 | 
 75 | If you'd like a more automatic solution than pjax for Rails check out [Turbolinks][].
 76 | 
 77 | [Check if there is a pjax plugin][plugins] for your favorite server framework.
 78 | 
 79 | Also check out [RailsCasts #294: Playing with PJAX][railscasts].
 80 | 
 81 | #### Arguments
 82 | 
 83 | The synopsis for the `$.fn.pjax` function is:
 84 | 
 85 | ``` javascript
 86 | $(document).pjax(selector, [container], options)
 87 | ```
 88 | 
 89 | 1. `selector` is a string to be used for click [event delegation][$.fn.on].
 90 | 2. `container` is a string selector that uniquely identifies the pjax container.
 91 | 3. `options` is an object with keys described below.
 92 | 
 93 | ##### pjax options
 94 | 
 95 | key | default | description
 96 | ----|---------|------------
 97 | `timeout` | 650 | ajax timeout in milliseconds after which a full refresh is forced
 98 | `push` | true | use [pushState][] to add a browser history entry upon navigation
 99 | `replace` | false | replace URL without adding browser history entry
100 | `maxCacheLength` | 20 | maximum cache size for previous container contents
101 | `version` | | a string or function returning the current pjax version
102 | `scrollTo` | 0 | vertical position to scroll to after navigation. To avoid changing scroll position, pass `false`.
103 | `type` | `"GET"` | see [$.ajax][]
104 | `dataType` | `"html"` | see [$.ajax][]
105 | `container` | | CSS selector for the element where content should be replaced
106 | `url` | link.href | a string or function that returns the URL for the ajax request
107 | `target` | link | eventually the `relatedTarget` value for [pjax events](#events)
108 | `fragment` | | CSS selector for the fragment to extract from ajax response
109 | 
110 | You can change the defaults globally by writing to the `$.pjax.defaults` object:
111 | 
112 | ``` javascript
113 | $.pjax.defaults.timeout = 1200
114 | ```
115 | 
116 | ### `$.pjax.click`
117 | 
118 | This is a lower level function used by `$.fn.pjax` itself. It allows you to get a little more control over the pjax event handling.
119 | 
120 | This example uses the current click context to set an ancestor element as the container:
121 | 
122 | ``` javascript
123 | if ($.support.pjax) {
124 |   $(document).on('click', 'a[data-pjax]', function(event) {
125 |     var container = $(this).closest('[data-pjax-container]')
126 |     var containerSelector = '#' + container.id
127 |     $.pjax.click(event, {container: containerSelector})
128 |   })
129 | }
130 | ```
131 | 
132 | **NOTE** Use the explicit `$.support.pjax` guard. We aren't using `$.fn.pjax` so we should avoid binding this event handler unless the browser is actually going to use pjax.
133 | 
134 | ### `$.pjax.submit`
135 | 
136 | Submits a form via pjax.
137 | 
138 | ``` javascript
139 | $(document).on('submit', 'form[data-pjax]', function(event) {
140 |   $.pjax.submit(event, '#pjax-container')
141 | })
142 | ```
143 | 
144 | ### `$.pjax.reload`
145 | 
146 | Initiates a request for the current URL to the server using pjax mechanism and replaces the container with the response. Does not add a browser history entry.
147 | 
148 | ``` javascript
149 | $.pjax.reload('#pjax-container', options)
150 | ```
151 | 
152 | ### `$.pjax`
153 | 
154 | Manual pjax invocation. Used mainly when you want to start a pjax request in a handler that didn't originate from a click. If you can get access to a click `event`, consider `$.pjax.click(event)` instead.
155 | 
156 | ``` javascript
157 | function applyFilters() {
158 |   var url = urlForFilters()
159 |   $.pjax({url: url, container: '#pjax-container'})
160 | }
161 | ```
162 | 
163 | ## Events
164 | 
165 | All pjax events except `pjax:click` & `pjax:clicked` are fired from the pjax
166 | container element.
167 | 
168 | <table>
169 | <tr>
170 |   <th>event</th>
171 |   <th>cancel</th>
172 |   <th>arguments</th>
173 |   <th>notes</th>
174 | </tr>
175 | <tr>
176 |   <th colspan=4>event lifecycle upon following a pjaxed link</th>
177 | </tr>
178 | <tr>
179 |   <td><code>pjax:click</code></td>
180 |   <td>✔︎</td>
181 |   <td><code>options</code></td>
182 |   <td>fires from a link that got activated; cancel to prevent pjax</td>
183 | </tr>
184 | <tr>
185 |   <td><code>pjax:beforeSend</code></td>
186 |   <td>✔︎</td>
187 |   <td><code>xhr, options</code></td>
188 |   <td>can set XHR headers</td>
189 | </tr>
190 | <tr>
191 |   <td><code>pjax:start</code></td>
192 |   <td></td>
193 |   <td><code>xhr, options</code></td>
194 |   <td></td>
195 | </tr>
196 | <tr>
197 |   <td><code>pjax:send</code></td>
198 |   <td></td>
199 |   <td><code>xhr, options</code></td>
200 |   <td></td>
201 | </tr>
202 | <tr>
203 |   <td><code>pjax:clicked</code></td>
204 |   <td></td>
205 |   <td><code>options</code></td>
206 |   <td>fires after pjax has started from a link that got clicked</td>
207 | </tr>
208 | <tr>
209 |   <td><code>pjax:beforeReplace</code></td>
210 |   <td></td>
211 |   <td><code>contents, options</code></td>
212 |   <td>before replacing HTML with content loaded from the server</td>
213 | </tr>
214 | <tr>
215 |   <td><code>pjax:success</code></td>
216 |   <td></td>
217 |   <td><code>data, status, xhr, options</code></td>
218 |   <td>after replacing HTML content loaded from the server</td>
219 | </tr>
220 | <tr>
221 |   <td><code>pjax:timeout</code></td>
222 |   <td>✔︎</td>
223 |   <td><code>xhr, options</code></td>
224 |   <td>fires after <code>options.timeout</code>; will hard refresh unless canceled</td>
225 | </tr>
226 | <tr>
227 |   <td><code>pjax:error</code></td>
228 |   <td>✔︎</td>
229 |   <td><code>xhr, textStatus, error, options</code></td>
230 |   <td>on ajax error; will hard refresh unless canceled</td>
231 | </tr>
232 | <tr>
233 |   <td><code>pjax:complete</code></td>
234 |   <td></td>
235 |   <td><code>xhr, textStatus, options</code></td>
236 |   <td>always fires after ajax, regardless of result</td>
237 | </tr>
238 | <tr>
239 |   <td><code>pjax:end</code></td>
240 |   <td></td>
241 |   <td><code>xhr, options</code></td>
242 |   <td></td>
243 | </tr>
244 | <tr>
245 |   <th colspan=4>event lifecycle on browser Back/Forward navigation</th>
246 | </tr>
247 | <tr>
248 |   <td><code>pjax:popstate</code></td>
249 |   <td></td>
250 |   <td></td>
251 |   <td>event <code>direction</code> property: &quot;back&quot;/&quot;forward&quot;</td>
252 | </tr>
253 | <tr>
254 |   <td><code>pjax:start</code></td>
255 |   <td></td>
256 |   <td><code>null, options</code></td>
257 |   <td>before replacing content</td>
258 | </tr>
259 | <tr>
260 |   <td><code>pjax:beforeReplace</code></td>
261 |   <td></td>
262 |   <td><code>contents, options</code></td>
263 |   <td>right before replacing HTML with content from cache</td>
264 | </tr>
265 | <tr>
266 |   <td><code>pjax:end</code></td>
267 |   <td></td>
268 |   <td><code>null, options</code></td>
269 |   <td>after replacing content</td>
270 | </tr>
271 | </table>
272 | 
273 | `pjax:send` & `pjax:complete` are a good pair of events to use if you are implementing a
274 | loading indicator. They'll only be triggered if an actual XHR request is made,
275 | not if the content is loaded from cache:
276 | 
277 | ``` javascript
278 | $(document).on('pjax:send', function() {
279 |   $('#loading').show()
280 | })
281 | $(document).on('pjax:complete', function() {
282 |   $('#loading').hide()
283 | })
284 | ```
285 | 
286 | An example of canceling a `pjax:timeout` event would be to disable the fallback
287 | timeout behavior if a spinner is being shown:
288 | 
289 | ``` javascript
290 | $(document).on('pjax:timeout', function(event) {
291 |   // Prevent default timeout redirection behavior
292 |   event.preventDefault()
293 | })
294 | ```
295 | 
296 | ## Advanced configuration
297 | 
298 | ### Reinitializing plugins/widget on new page content
299 | 
300 | The whole point of pjax is that it fetches and inserts new content _without_
301 | refreshing the page. However, other jQuery plugins or libraries that are set to
302 | react on page loaded event (such as `DOMContentLoaded`) will not pick up on
303 | these changes. Therefore, it's usually a good idea to configure these plugins to
304 | reinitialize in the scope of the updated page content. This can be done like so:
305 | 
306 | ``` js
307 | $(document).on('ready pjax:end', function(event) {
308 |   $(event.target).initializeMyPlugin()
309 | })
310 | ```
311 | 
312 | This will make `$.fn.initializeMyPlugin()` be called at the document level on
313 | normal page load, and on the container level after any pjax navigation (either
314 | after clicking on a link or going Back in the browser).
315 | 
316 | ### Response types that force a reload
317 | 
318 | By default, pjax will force a full reload of the page if it receives one of the
319 | following responses from the server:
320 | 
321 | * Page content that includes `<html>` when `fragment` selector wasn't explicitly
322 |   configured. Pjax presumes that the server's response hasn't been properly
323 |   configured for pjax. If `fragment` pjax option is given, pjax will extract the
324 |   content based on that selector.
325 | 
326 | * Page content that is blank. Pjax assumes that the server is unable to deliver
327 |   proper pjax contents.
328 | 
329 | * HTTP response code that is 4xx or 5xx, indicating some server error.
330 | 
331 | ### Affecting the browser URL
332 | 
333 | If the server needs to affect the URL which will appear in the browser URL after
334 | pjax navigation (like HTTP redirects work for normal requests), it can set the
335 | `X-PJAX-URL` header:
336 | 
337 | ``` ruby
338 | def index
339 |   request.headers['X-PJAX-URL'] = "http://example.com/hello"
340 | end
341 | ```
342 | 
343 | ### Layout Reloading
344 | 
345 | Layouts can be forced to do a hard reload when assets or html changes.
346 | 
347 | First set the initial layout version in your header with a custom meta tag.
348 | 
349 | ``` html
350 | <meta http-equiv="x-pjax-version" content="v123">
351 | ```
352 | 
353 | Then from the server side, set the `X-PJAX-Version` header to the same.
354 | 
355 | ``` ruby
356 | if request.headers['X-PJAX']
357 |   response.headers['X-PJAX-Version'] = "v123"
358 | end
359 | ```
360 | 
361 | Deploying a deploy, bumping the version constant to force clients to do a full reload the next request getting the new layout and assets.
362 | 
363 | 
364 | [$.fn.on]: http://api.jquery.com/on/
365 | [$.ajax]: http://api.jquery.com/jQuery.ajax/
366 | [pushState]: https://developer.mozilla.org/en-US/docs/Web/Guide/API/DOM/Manipulating_the_browser_history#Adding_and_modifying_history_entries
367 | [plugins]: https://gist.github.com/4283721
368 | [turbolinks]: https://github.com/rails/turbolinks
369 | [railscasts]: http://railscasts.com/episodes/294-playing-with-pjax
370 | 


--------------------------------------------------------------------------------
/bower.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "jquery-pjax",
 3 |   "main": "./jquery.pjax.js",
 4 |   "dependencies": {
 5 |     "jquery": ">=1.8"
 6 |   },
 7 |   "ignore": [
 8 |     ".travis.yml",
 9 |     "Gemfile",
10 |     "Gemfile.lock",
11 |     "CONTRIBUTING.md",
12 |     "vendor/",
13 |     "script/",
14 |     "test/"
15 |   ]
16 | }
17 | 


--------------------------------------------------------------------------------
/jquery.pjax.js:
--------------------------------------------------------------------------------
  1 | /*!
  2 |  * Copyright 2012, Chris Wanstrath
  3 |  * Released under the MIT License
  4 |  * https://github.com/defunkt/jquery-pjax
  5 |  */
  6 | 
  7 | (function($){
  8 | 
  9 | // When called on a container with a selector, fetches the href with
 10 | // ajax into the container or with the data-pjax attribute on the link
 11 | // itself.
 12 | //
 13 | // Tries to make sure the back button and ctrl+click work the way
 14 | // you'd expect.
 15 | //
 16 | // Exported as $.fn.pjax
 17 | //
 18 | // Accepts a jQuery ajax options object that may include these
 19 | // pjax specific options:
 20 | //
 21 | //
 22 | // container - String selector for the element where to place the response body.
 23 | //      push - Whether to pushState the URL. Defaults to true (of course).
 24 | //   replace - Want to use replaceState instead? That's cool.
 25 | //
 26 | // For convenience the second parameter can be either the container or
 27 | // the options object.
 28 | //
 29 | // Returns the jQuery object
 30 | function fnPjax(selector, container, options) {
 31 |   options = optionsFor(container, options)
 32 |   return this.on('click.pjax', selector, function(event) {
 33 |     var opts = options
 34 |     if (!opts.container) {
 35 |       opts = $.extend({}, options)
 36 |       opts.container = $(this).attr('data-pjax')
 37 |     }
 38 |     handleClick(event, opts)
 39 |   })
 40 | }
 41 | 
 42 | // Public: pjax on click handler
 43 | //
 44 | // Exported as $.pjax.click.
 45 | //
 46 | // event   - "click" jQuery.Event
 47 | // options - pjax options
 48 | //
 49 | // Examples
 50 | //
 51 | //   $(document).on('click', 'a', $.pjax.click)
 52 | //   // is the same as
 53 | //   $(document).pjax('a')
 54 | //
 55 | // Returns nothing.
 56 | function handleClick(event, container, options) {
 57 |   options = optionsFor(container, options)
 58 | 
 59 |   var link = event.currentTarget
 60 |   var $link = $(link)
 61 | 
 62 |   if (link.tagName.toUpperCase() !== 'A')
 63 |     throw "$.fn.pjax or $.pjax.click requires an anchor element"
 64 | 
 65 |   // Middle click, cmd click, and ctrl click should open
 66 |   // links in a new tab as normal.
 67 |   if ( event.which > 1 || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey )
 68 |     return
 69 | 
 70 |   // Ignore cross origin links
 71 |   if ( location.protocol !== link.protocol || location.hostname !== link.hostname )
 72 |     return
 73 | 
 74 |   // Ignore case when a hash is being tacked on the current URL
 75 |   if ( link.href.indexOf('#') > -1 && stripHash(link) == stripHash(location) )
 76 |     return
 77 | 
 78 |   // Ignore event with default prevented
 79 |   if (event.isDefaultPrevented())
 80 |     return
 81 | 
 82 |   var defaults = {
 83 |     url: link.href,
 84 |     container: $link.attr('data-pjax'),
 85 |     target: link
 86 |   }
 87 | 
 88 |   var opts = $.extend({}, defaults, options)
 89 |   var clickEvent = $.Event('pjax:click')
 90 |   $link.trigger(clickEvent, [opts])
 91 | 
 92 |   if (!clickEvent.isDefaultPrevented()) {
 93 |     pjax(opts)
 94 |     event.preventDefault()
 95 |     $link.trigger('pjax:clicked', [opts])
 96 |   }
 97 | }
 98 | 
 99 | // Public: pjax on form submit handler
100 | //
101 | // Exported as $.pjax.submit
102 | //
103 | // event   - "click" jQuery.Event
104 | // options - pjax options
105 | //
106 | // Examples
107 | //
108 | //  $(document).on('submit', 'form', function(event) {
109 | //    $.pjax.submit(event, '[data-pjax-container]')
110 | //  })
111 | //
112 | // Returns nothing.
113 | function handleSubmit(event, container, options) {
114 |   options = optionsFor(container, options)
115 | 
116 |   var form = event.currentTarget
117 |   var $form = $(form)
118 | 
119 |   if (form.tagName.toUpperCase() !== 'FORM')
120 |     throw "$.pjax.submit requires a form element"
121 | 
122 |   var defaults = {
123 |     type: ($form.attr('method') || 'GET').toUpperCase(),
124 |     url: $form.attr('action'),
125 |     container: $form.attr('data-pjax'),
126 |     target: form
127 |   }
128 | 
129 |   if (defaults.type !== 'GET' && window.FormData !== undefined) {
130 |     defaults.data = new FormData(form)
131 |     defaults.processData = false
132 |     defaults.contentType = false
133 |   } else {
134 |     // Can't handle file uploads, exit
135 |     if ($form.find(':file').length) {
136 |       return
137 |     }
138 | 
139 |     // Fallback to manually serializing the fields
140 |     defaults.data = $form.serializeArray()
141 |   }
142 | 
143 |   pjax($.extend({}, defaults, options))
144 | 
145 |   event.preventDefault()
146 | }
147 | 
148 | // Loads a URL with ajax, puts the response body inside a container,
149 | // then pushState()'s the loaded URL.
150 | //
151 | // Works just like $.ajax in that it accepts a jQuery ajax
152 | // settings object (with keys like url, type, data, etc).
153 | //
154 | // Accepts these extra keys:
155 | //
156 | // container - String selector for where to stick the response body.
157 | //      push - Whether to pushState the URL. Defaults to true (of course).
158 | //   replace - Want to use replaceState instead? That's cool.
159 | //
160 | // Use it just like $.ajax:
161 | //
162 | //   var xhr = $.pjax({ url: this.href, container: '#main' })
163 | //   console.log( xhr.readyState )
164 | //
165 | // Returns whatever $.ajax returns.
166 | function pjax(options) {
167 |   options = $.extend(true, {}, $.ajaxSettings, pjax.defaults, options)
168 | 
169 |   if ($.isFunction(options.url)) {
170 |     options.url = options.url()
171 |   }
172 | 
173 |   var hash = parseURL(options.url).hash
174 | 
175 |   var containerType = $.type(options.container)
176 |   if (containerType !== 'string') {
177 |     throw "expected string value for 'container' option; got " + containerType
178 |   }
179 |   var context = options.context = $(options.container)
180 |   if (!context.length) {
181 |     throw "the container selector '" + options.container + "' did not match anything"
182 |   }
183 | 
184 |   // We want the browser to maintain two separate internal caches: one
185 |   // for pjax'd partial page loads and one for normal page loads.
186 |   // Without adding this secret parameter, some browsers will often
187 |   // confuse the two.
188 |   if (!options.data) options.data = {}
189 |   if ($.isArray(options.data)) {
190 |     options.data.push({name: '_pjax', value: options.container})
191 |   } else {
192 |     options.data._pjax = options.container
193 |   }
194 | 
195 |   function fire(type, args, props) {
196 |     if (!props) props = {}
197 |     props.relatedTarget = options.target
198 |     var event = $.Event(type, props)
199 |     context.trigger(event, args)
200 |     return !event.isDefaultPrevented()
201 |   }
202 | 
203 |   var timeoutTimer
204 | 
205 |   options.beforeSend = function(xhr, settings) {
206 |     // No timeout for non-GET requests
207 |     // Its not safe to request the resource again with a fallback method.
208 |     if (settings.type !== 'GET') {
209 |       settings.timeout = 0
210 |     }
211 | 
212 |     xhr.setRequestHeader('X-PJAX', 'true')
213 |     xhr.setRequestHeader('X-PJAX-Container', options.container)
214 | 
215 |     if (!fire('pjax:beforeSend', [xhr, settings]))
216 |       return false
217 | 
218 |     if (settings.timeout > 0) {
219 |       timeoutTimer = setTimeout(function() {
220 |         if (fire('pjax:timeout', [xhr, options]))
221 |           xhr.abort('timeout')
222 |       }, settings.timeout)
223 | 
224 |       // Clear timeout setting so jquerys internal timeout isn't invoked
225 |       settings.timeout = 0
226 |     }
227 | 
228 |     var url = parseURL(settings.url)
229 |     if (hash) url.hash = hash
230 |     options.requestUrl = stripInternalParams(url)
231 |   }
232 | 
233 |   options.complete = function(xhr, textStatus) {
234 |     if (timeoutTimer)
235 |       clearTimeout(timeoutTimer)
236 | 
237 |     fire('pjax:complete', [xhr, textStatus, options])
238 | 
239 |     fire('pjax:end', [xhr, options])
240 |   }
241 | 
242 |   options.error = function(xhr, textStatus, errorThrown) {
243 |     var container = extractContainer("", xhr, options)
244 | 
245 |     var allowed = fire('pjax:error', [xhr, textStatus, errorThrown, options])
246 |     if (options.type == 'GET' && textStatus !== 'abort' && allowed) {
247 |       locationReplace(container.url)
248 |     }
249 |   }
250 | 
251 |   options.success = function(data, status, xhr) {
252 |     var previousState = pjax.state
253 | 
254 |     // If $.pjax.defaults.version is a function, invoke it first.
255 |     // Otherwise it can be a static string.
256 |     var currentVersion = typeof $.pjax.defaults.version === 'function' ?
257 |       $.pjax.defaults.version() :
258 |       $.pjax.defaults.version
259 | 
260 |     var latestVersion = xhr.getResponseHeader('X-PJAX-Version')
261 | 
262 |     var container = extractContainer(data, xhr, options)
263 | 
264 |     var url = parseURL(container.url)
265 |     if (hash) {
266 |       url.hash = hash
267 |       container.url = url.href
268 |     }
269 | 
270 |     // If there is a layout version mismatch, hard load the new url
271 |     if (currentVersion && latestVersion && currentVersion !== latestVersion) {
272 |       locationReplace(container.url)
273 |       return
274 |     }
275 | 
276 |     // If the new response is missing a body, hard load the page
277 |     if (!container.contents) {
278 |       locationReplace(container.url)
279 |       return
280 |     }
281 | 
282 |     pjax.state = {
283 |       id: options.id || uniqueId(),
284 |       url: container.url,
285 |       title: container.title,
286 |       container: options.container,
287 |       fragment: options.fragment,
288 |       timeout: options.timeout
289 |     }
290 | 
291 |     if (options.push || options.replace) {
292 |       window.history.replaceState(pjax.state, container.title, container.url)
293 |     }
294 | 
295 |     // Only blur the focus if the focused element is within the container.
296 |     var blurFocus = $.contains(context, document.activeElement)
297 | 
298 |     // Clear out any focused controls before inserting new page contents.
299 |     if (blurFocus) {
300 |       try {
301 |         document.activeElement.blur()
302 |       } catch (e) { /* ignore */ }
303 |     }
304 | 
305 |     if (container.title) document.title = container.title
306 | 
307 |     fire('pjax:beforeReplace', [container.contents, options], {
308 |       state: pjax.state,
309 |       previousState: previousState
310 |     })
311 |     context.html(container.contents)
312 | 
313 |     // FF bug: Won't autofocus fields that are inserted via JS.
314 |     // This behavior is incorrect. So if theres no current focus, autofocus
315 |     // the last field.
316 |     //
317 |     // http://www.w3.org/html/wg/drafts/html/master/forms.html
318 |     var autofocusEl = context.find('input[autofocus], textarea[autofocus]').last()[0]
319 |     if (autofocusEl && document.activeElement !== autofocusEl) {
320 |       autofocusEl.focus()
321 |     }
322 | 
323 |     executeScriptTags(container.scripts)
324 | 
325 |     var scrollTo = options.scrollTo
326 | 
327 |     // Ensure browser scrolls to the element referenced by the URL anchor
328 |     if (hash) {
329 |       var name = decodeURIComponent(hash.slice(1))
330 |       var target = document.getElementById(name) || document.getElementsByName(name)[0]
331 |       if (target) scrollTo = $(target).offset().top
332 |     }
333 | 
334 |     if (typeof scrollTo == 'number') $(window).scrollTop(scrollTo)
335 | 
336 |     fire('pjax:success', [data, status, xhr, options])
337 |   }
338 | 
339 | 
340 |   // Initialize pjax.state for the initial page load. Assume we're
341 |   // using the container and options of the link we're loading for the
342 |   // back button to the initial page. This ensures good back button
343 |   // behavior.
344 |   if (!pjax.state) {
345 |     pjax.state = {
346 |       id: uniqueId(),
347 |       url: window.location.href,
348 |       title: document.title,
349 |       container: options.container,
350 |       fragment: options.fragment,
351 |       timeout: options.timeout
352 |     }
353 |     window.history.replaceState(pjax.state, document.title)
354 |   }
355 | 
356 |   // Cancel the current request if we're already pjaxing
357 |   abortXHR(pjax.xhr)
358 | 
359 |   pjax.options = options
360 |   var xhr = pjax.xhr = $.ajax(options)
361 | 
362 |   if (xhr.readyState > 0) {
363 |     if (options.push && !options.replace) {
364 |       // Cache current container element before replacing it
365 |       cachePush(pjax.state.id, [options.container, cloneContents(context)])
366 | 
367 |       window.history.pushState(null, "", options.requestUrl)
368 |     }
369 | 
370 |     fire('pjax:start', [xhr, options])
371 |     fire('pjax:send', [xhr, options])
372 |   }
373 | 
374 |   return pjax.xhr
375 | }
376 | 
377 | // Public: Reload current page with pjax.
378 | //
379 | // Returns whatever $.pjax returns.
380 | function pjaxReload(container, options) {
381 |   var defaults = {
382 |     url: window.location.href,
383 |     push: false,
384 |     replace: true,
385 |     scrollTo: false
386 |   }
387 | 
388 |   return pjax($.extend(defaults, optionsFor(container, options)))
389 | }
390 | 
391 | // Internal: Hard replace current state with url.
392 | //
393 | // Work for around WebKit
394 | //   https://bugs.webkit.org/show_bug.cgi?id=93506
395 | //
396 | // Returns nothing.
397 | function locationReplace(url) {
398 |   window.history.replaceState(null, "", pjax.state.url)
399 |   window.location.replace(url)
400 | }
401 | 
402 | 
403 | var initialPop = true
404 | var initialURL = window.location.href
405 | var initialState = window.history.state
406 | 
407 | // Initialize $.pjax.state if possible
408 | // Happens when reloading a page and coming forward from a different
409 | // session history.
410 | if (initialState && initialState.container) {
411 |   pjax.state = initialState
412 | }
413 | 
414 | // Non-webkit browsers don't fire an initial popstate event
415 | if ('state' in window.history) {
416 |   initialPop = false
417 | }
418 | 
419 | // popstate handler takes care of the back and forward buttons
420 | //
421 | // You probably shouldn't use pjax on pages with other pushState
422 | // stuff yet.
423 | function onPjaxPopstate(event) {
424 | 
425 |   // Hitting back or forward should override any pending PJAX request.
426 |   if (!initialPop) {
427 |     abortXHR(pjax.xhr)
428 |   }
429 | 
430 |   var previousState = pjax.state
431 |   var state = event.state
432 |   var direction
433 | 
434 |   if (state && state.container) {
435 |     // When coming forward from a separate history session, will get an
436 |     // initial pop with a state we are already at. Skip reloading the current
437 |     // page.
438 |     if (initialPop && initialURL == state.url) return
439 | 
440 |     if (previousState) {
441 |       // If popping back to the same state, just skip.
442 |       // Could be clicking back from hashchange rather than a pushState.
443 |       if (previousState.id === state.id) return
444 | 
445 |       // Since state IDs always increase, we can deduce the navigation direction
446 |       direction = previousState.id < state.id ? 'forward' : 'back'
447 |     }
448 | 
449 |     var cache = cacheMapping[state.id] || []
450 |     var containerSelector = cache[0] || state.container
451 |     var container = $(containerSelector), contents = cache[1]
452 | 
453 |     if (container.length) {
454 |       if (previousState) {
455 |         // Cache current container before replacement and inform the
456 |         // cache which direction the history shifted.
457 |         cachePop(direction, previousState.id, [containerSelector, cloneContents(container)])
458 |       }
459 | 
460 |       var popstateEvent = $.Event('pjax:popstate', {
461 |         state: state,
462 |         direction: direction
463 |       })
464 |       container.trigger(popstateEvent)
465 | 
466 |       var options = {
467 |         id: state.id,
468 |         url: state.url,
469 |         container: containerSelector,
470 |         push: false,
471 |         fragment: state.fragment,
472 |         timeout: state.timeout,
473 |         scrollTo: false
474 |       }
475 | 
476 |       if (contents) {
477 |         container.trigger('pjax:start', [null, options])
478 | 
479 |         pjax.state = state
480 |         if (state.title) document.title = state.title
481 |         var beforeReplaceEvent = $.Event('pjax:beforeReplace', {
482 |           state: state,
483 |           previousState: previousState
484 |         })
485 |         container.trigger(beforeReplaceEvent, [contents, options])
486 |         container.html(contents)
487 | 
488 |         container.trigger('pjax:end', [null, options])
489 |       } else {
490 |         pjax(options)
491 |       }
492 | 
493 |       // Force reflow/relayout before the browser tries to restore the
494 |       // scroll position.
495 |       container[0].offsetHeight // eslint-disable-line no-unused-expressions
496 |     } else {
497 |       locationReplace(location.href)
498 |     }
499 |   }
500 |   initialPop = false
501 | }
502 | 
503 | // Fallback version of main pjax function for browsers that don't
504 | // support pushState.
505 | //
506 | // Returns nothing since it retriggers a hard form submission.
507 | function fallbackPjax(options) {
508 |   var url = $.isFunction(options.url) ? options.url() : options.url,
509 |       method = options.type ? options.type.toUpperCase() : 'GET'
510 | 
511 |   var form = $('<form>', {
512 |     method: method === 'GET' ? 'GET' : 'POST',
513 |     action: url,
514 |     style: 'display:none'
515 |   })
516 | 
517 |   if (method !== 'GET' && method !== 'POST') {
518 |     form.append($('<input>', {
519 |       type: 'hidden',
520 |       name: '_method',
521 |       value: method.toLowerCase()
522 |     }))
523 |   }
524 | 
525 |   var data = options.data
526 |   if (typeof data === 'string') {
527 |     $.each(data.split('&'), function(index, value) {
528 |       var pair = value.split('=')
529 |       form.append($('<input>', {type: 'hidden', name: pair[0], value: pair[1]}))
530 |     })
531 |   } else if ($.isArray(data)) {
532 |     $.each(data, function(index, value) {
533 |       form.append($('<input>', {type: 'hidden', name: value.name, value: value.value}))
534 |     })
535 |   } else if (typeof data === 'object') {
536 |     var key
537 |     for (key in data)
538 |       form.append($('<input>', {type: 'hidden', name: key, value: data[key]}))
539 |   }
540 | 
541 |   $(document.body).append(form)
542 |   form.submit()
543 | }
544 | 
545 | // Internal: Abort an XmlHttpRequest if it hasn't been completed,
546 | // also removing its event handlers.
547 | function abortXHR(xhr) {
548 |   if ( xhr && xhr.readyState < 4) {
549 |     xhr.onreadystatechange = $.noop
550 |     xhr.abort()
551 |   }
552 | }
553 | 
554 | // Internal: Generate unique id for state object.
555 | //
556 | // Use a timestamp instead of a counter since ids should still be
557 | // unique across page loads.
558 | //
559 | // Returns Number.
560 | function uniqueId() {
561 |   return (new Date).getTime()
562 | }
563 | 
564 | function cloneContents(container) {
565 |   var cloned = container.clone()
566 |   // Unmark script tags as already being eval'd so they can get executed again
567 |   // when restored from cache. HAXX: Uses jQuery internal method.
568 |   cloned.find('script').each(function(){
569 |     if (!this.src) $._data(this, 'globalEval', false)
570 |   })
571 |   return cloned.contents()
572 | }
573 | 
574 | // Internal: Strip internal query params from parsed URL.
575 | //
576 | // Returns sanitized url.href String.
577 | function stripInternalParams(url) {
578 |   url.search = url.search.replace(/([?&])(_pjax|_)=[^&]*/g, '').replace(/^&/, '')
579 |   return url.href.replace(/\?($|#)/, '$1')
580 | }
581 | 
582 | // Internal: Parse URL components and returns a Locationish object.
583 | //
584 | // url - String URL
585 | //
586 | // Returns HTMLAnchorElement that acts like Location.
587 | function parseURL(url) {
588 |   var a = document.createElement('a')
589 |   a.href = url
590 |   return a
591 | }
592 | 
593 | // Internal: Return the `href` component of given URL object with the hash
594 | // portion removed.
595 | //
596 | // location - Location or HTMLAnchorElement
597 | //
598 | // Returns String
599 | function stripHash(location) {
600 |   return location.href.replace(/#.*/, '')
601 | }
602 | 
603 | // Internal: Build options Object for arguments.
604 | //
605 | // For convenience the first parameter can be either the container or
606 | // the options object.
607 | //
608 | // Examples
609 | //
610 | //   optionsFor('#container')
611 | //   // => {container: '#container'}
612 | //
613 | //   optionsFor('#container', {push: true})
614 | //   // => {container: '#container', push: true}
615 | //
616 | //   optionsFor({container: '#container', push: true})
617 | //   // => {container: '#container', push: true}
618 | //
619 | // Returns options Object.
620 | function optionsFor(container, options) {
621 |   if (container && options) {
622 |     options = $.extend({}, options)
623 |     options.container = container
624 |     return options
625 |   } else if ($.isPlainObject(container)) {
626 |     return container
627 |   } else {
628 |     return {container: container}
629 |   }
630 | }
631 | 
632 | // Internal: Filter and find all elements matching the selector.
633 | //
634 | // Where $.fn.find only matches descendants, findAll will test all the
635 | // top level elements in the jQuery object as well.
636 | //
637 | // elems    - jQuery object of Elements
638 | // selector - String selector to match
639 | //
640 | // Returns a jQuery object.
641 | function findAll(elems, selector) {
642 |   return elems.filter(selector).add(elems.find(selector))
643 | }
644 | 
645 | function parseHTML(html) {
646 |   return $.parseHTML(html, document, true)
647 | }
648 | 
649 | // Internal: Extracts container and metadata from response.
650 | //
651 | // 1. Extracts X-PJAX-URL header if set
652 | // 2. Extracts inline <title> tags
653 | // 3. Builds response Element and extracts fragment if set
654 | //
655 | // data    - String response data
656 | // xhr     - XHR response
657 | // options - pjax options Object
658 | //
659 | // Returns an Object with url, title, and contents keys.
660 | function extractContainer(data, xhr, options) {
661 |   var obj = {}, fullDocument = /<html/i.test(data)
662 | 
663 |   // Prefer X-PJAX-URL header if it was set, otherwise fallback to
664 |   // using the original requested url.
665 |   var serverUrl = xhr.getResponseHeader('X-PJAX-URL')
666 |   obj.url = serverUrl ? stripInternalParams(parseURL(serverUrl)) : options.requestUrl
667 | 
668 |   var $head, $body
669 |   // Attempt to parse response html into elements
670 |   if (fullDocument) {
671 |     $body = $(parseHTML(data.match(/<body[^>]*>([\s\S.]*)<\/body>/i)[0]))
672 |     var head = data.match(/<head[^>]*>([\s\S.]*)<\/head>/i)
673 |     $head = head != null ? $(parseHTML(head[0])) : $body
674 |   } else {
675 |     $head = $body = $(parseHTML(data))
676 |   }
677 | 
678 |   // If response data is empty, return fast
679 |   if ($body.length === 0)
680 |     return obj
681 | 
682 |   // If there's a <title> tag in the header, use it as
683 |   // the page's title.
684 |   obj.title = findAll($head, 'title').last().text()
685 | 
686 |   if (options.fragment) {
687 |     var $fragment = $body
688 |     // If they specified a fragment, look for it in the response
689 |     // and pull it out.
690 |     if (options.fragment !== 'body') {
691 |       $fragment = findAll($fragment, options.fragment).first()
692 |     }
693 | 
694 |     if ($fragment.length) {
695 |       obj.contents = options.fragment === 'body' ? $fragment : $fragment.contents()
696 | 
697 |       // If there's no title, look for data-title and title attributes
698 |       // on the fragment
699 |       if (!obj.title)
700 |         obj.title = $fragment.attr('title') || $fragment.data('title')
701 |     }
702 | 
703 |   } else if (!fullDocument) {
704 |     obj.contents = $body
705 |   }
706 | 
707 |   // Clean up any <title> tags
708 |   if (obj.contents) {
709 |     // Remove any parent title elements
710 |     obj.contents = obj.contents.not(function() { return $(this).is('title') })
711 | 
712 |     // Then scrub any titles from their descendants
713 |     obj.contents.find('title').remove()
714 | 
715 |     // Gather all script[src] elements
716 |     obj.scripts = findAll(obj.contents, 'script[src]').remove()
717 |     obj.contents = obj.contents.not(obj.scripts)
718 |   }
719 | 
720 |   // Trim any whitespace off the title
721 |   if (obj.title) obj.title = $.trim(obj.title)
722 | 
723 |   return obj
724 | }
725 | 
726 | // Load an execute scripts using standard script request.
727 | //
728 | // Avoids jQuery's traditional $.getScript which does a XHR request and
729 | // globalEval.
730 | //
731 | // scripts - jQuery object of script Elements
732 | //
733 | // Returns nothing.
734 | function executeScriptTags(scripts) {
735 |   if (!scripts) return
736 | 
737 |   var existingScripts = $('script[src]')
738 | 
739 |   scripts.each(function() {
740 |     var src = this.src
741 |     var matchedScripts = existingScripts.filter(function() {
742 |       return this.src === src
743 |     })
744 |     if (matchedScripts.length) return
745 | 
746 |     var script = document.createElement('script')
747 |     var type = $(this).attr('type')
748 |     if (type) script.type = type
749 |     script.src = $(this).attr('src')
750 |     document.head.appendChild(script)
751 |   })
752 | }
753 | 
754 | // Internal: History DOM caching class.
755 | var cacheMapping      = {}
756 | var cacheForwardStack = []
757 | var cacheBackStack    = []
758 | 
759 | // Push previous state id and container contents into the history
760 | // cache. Should be called in conjunction with `pushState` to save the
761 | // previous container contents.
762 | //
763 | // id    - State ID Number
764 | // value - DOM Element to cache
765 | //
766 | // Returns nothing.
767 | function cachePush(id, value) {
768 |   cacheMapping[id] = value
769 |   cacheBackStack.push(id)
770 | 
771 |   // Remove all entries in forward history stack after pushing a new page.
772 |   trimCacheStack(cacheForwardStack, 0)
773 | 
774 |   // Trim back history stack to max cache length.
775 |   trimCacheStack(cacheBackStack, pjax.defaults.maxCacheLength)
776 | }
777 | 
778 | // Shifts cache from directional history cache. Should be
779 | // called on `popstate` with the previous state id and container
780 | // contents.
781 | //
782 | // direction - "forward" or "back" String
783 | // id        - State ID Number
784 | // value     - DOM Element to cache
785 | //
786 | // Returns nothing.
787 | function cachePop(direction, id, value) {
788 |   var pushStack, popStack
789 |   cacheMapping[id] = value
790 | 
791 |   if (direction === 'forward') {
792 |     pushStack = cacheBackStack
793 |     popStack  = cacheForwardStack
794 |   } else {
795 |     pushStack = cacheForwardStack
796 |     popStack  = cacheBackStack
797 |   }
798 | 
799 |   pushStack.push(id)
800 |   id = popStack.pop()
801 |   if (id) delete cacheMapping[id]
802 | 
803 |   // Trim whichever stack we just pushed to to max cache length.
804 |   trimCacheStack(pushStack, pjax.defaults.maxCacheLength)
805 | }
806 | 
807 | // Trim a cache stack (either cacheBackStack or cacheForwardStack) to be no
808 | // longer than the specified length, deleting cached DOM elements as necessary.
809 | //
810 | // stack  - Array of state IDs
811 | // length - Maximum length to trim to
812 | //
813 | // Returns nothing.
814 | function trimCacheStack(stack, length) {
815 |   while (stack.length > length)
816 |     delete cacheMapping[stack.shift()]
817 | }
818 | 
819 | // Public: Find version identifier for the initial page load.
820 | //
821 | // Returns String version or undefined.
822 | function findVersion() {
823 |   return $('meta').filter(function() {
824 |     var name = $(this).attr('http-equiv')
825 |     return name && name.toUpperCase() === 'X-PJAX-VERSION'
826 |   }).attr('content')
827 | }
828 | 
829 | // Install pjax functions on $.pjax to enable pushState behavior.
830 | //
831 | // Does nothing if already enabled.
832 | //
833 | // Examples
834 | //
835 | //     $.pjax.enable()
836 | //
837 | // Returns nothing.
838 | function enable() {
839 |   $.fn.pjax = fnPjax
840 |   $.pjax = pjax
841 |   $.pjax.enable = $.noop
842 |   $.pjax.disable = disable
843 |   $.pjax.click = handleClick
844 |   $.pjax.submit = handleSubmit
845 |   $.pjax.reload = pjaxReload
846 |   $.pjax.defaults = {
847 |     timeout: 650,
848 |     push: true,
849 |     replace: false,
850 |     type: 'GET',
851 |     dataType: 'html',
852 |     scrollTo: 0,
853 |     maxCacheLength: 20,
854 |     version: findVersion
855 |   }
856 |   $(window).on('popstate.pjax', onPjaxPopstate)
857 | }
858 | 
859 | // Disable pushState behavior.
860 | //
861 | // This is the case when a browser doesn't support pushState. It is
862 | // sometimes useful to disable pushState for debugging on a modern
863 | // browser.
864 | //
865 | // Examples
866 | //
867 | //     $.pjax.disable()
868 | //
869 | // Returns nothing.
870 | function disable() {
871 |   $.fn.pjax = function() { return this }
872 |   $.pjax = fallbackPjax
873 |   $.pjax.enable = enable
874 |   $.pjax.disable = $.noop
875 |   $.pjax.click = $.noop
876 |   $.pjax.submit = $.noop
877 |   $.pjax.reload = function() { window.location.reload() }
878 | 
879 |   $(window).off('popstate.pjax', onPjaxPopstate)
880 | }
881 | 
882 | 
883 | // Add the state property to jQuery's event object so we can use it in
884 | // $(window).bind('popstate')
885 | if ($.event.props && $.inArray('state', $.event.props) < 0) {
886 |   $.event.props.push('state')
887 | } else if (!('state' in $.Event.prototype)) {
888 |   $.event.addProp('state')
889 | }
890 | 
891 | // Is pjax supported by this browser?
892 | $.support.pjax =
893 |   window.history && window.history.pushState && window.history.replaceState &&
894 |   // pushState isn't reliable on iOS until 5.
895 |   !navigator.userAgent.match(/((iPod|iPhone|iPad).+\bOS\s+[1-4]\D|WebApps\/.+CFNetwork)/)
896 | 
897 | if ($.support.pjax) {
898 |   enable()
899 | } else {
900 |   disable()
901 | }
902 | 
903 | })(jQuery)
904 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "jquery-pjax",
 3 |   "description": "jQuery plugin for ajax + pushState navigation",
 4 |   "version": "2.0.1",
 5 |   "main": "jquery.pjax.js",
 6 |   "repository": "defunkt/jquery-pjax",
 7 |   "license": "MIT",
 8 |   "files": [
 9 |     "LICENSE",
10 |     "jquery.pjax.js"
11 |   ],
12 |   "devDependencies": {
13 |     "eslint": "^3.19.0"
14 |   },
15 |   "scripts": {
16 |     "test": "./script/test"
17 |   }
18 | }
19 | 


--------------------------------------------------------------------------------
/script/bootstrap:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | set -e
 3 | 
 4 | [ -n "$CI" ] || npm install
 5 | bundle install
 6 | 
 7 | if phantom_version="$(phantomjs --version)"; then
 8 |   echo "PhantomJS $phantom_version"
 9 | else
10 |   echo "Warning: script/test will not be able to run, but you can still start" >&2
11 |   echo "script/server and open the test suite in your browser." >&2
12 | fi
13 | 


--------------------------------------------------------------------------------
/script/server:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env bash
2 | set -e
3 | 
4 | exec bundle exec ruby ./test/app.rb "$@"
5 | 


--------------------------------------------------------------------------------
/script/test:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | set -e
 3 | 
 4 | ./node_modules/.bin/eslint *.js
 5 | 
 6 | port=3999
 7 | script/server -p "$port" &>/dev/null &
 8 | pid=$!
 9 | 
10 | trap "kill $pid" EXIT INT
11 | 
12 | while ! lsof -i :$port >/dev/null; do
13 |   sleep .05
14 | done
15 | 
16 | phantomjs ./test/run-qunit.js \
17 |   "http://localhost:$port/?jquery=3.2" \
18 |   "http://localhost:$port/?jquery=2.2" \
19 |   "http://localhost:$port/?jquery=1.12"
20 | 


--------------------------------------------------------------------------------
/test/app.rb:
--------------------------------------------------------------------------------
  1 | require 'sinatra'
  2 | require 'json'
  3 | 
  4 | set :public_folder, File.dirname(settings.root)
  5 | enable :static
  6 | 
  7 | jquery_version = '3.2'
  8 | 
  9 | helpers do
 10 |   def pjax?
 11 |     env['HTTP_X_PJAX'] && !params[:layout]
 12 |   end
 13 | 
 14 |   def title(str)
 15 |     if pjax?
 16 |       "<title>#{str}</title>"
 17 |     else
 18 |       @title = str
 19 |       nil
 20 |     end
 21 |   end
 22 | 
 23 |   define_method(:jquery_version) do
 24 |     jquery_version
 25 |   end
 26 | end
 27 | 
 28 | after do
 29 |   if pjax?
 30 |     response.headers['X-PJAX-URL'] ||= request.url
 31 |     response.headers['X-PJAX-Version'] = 'v1'
 32 |   end
 33 | end
 34 | 
 35 | 
 36 | get '/' do
 37 |   jquery_version = params[:jquery] if params[:jquery]
 38 |   erb :qunit
 39 | end
 40 | 
 41 | get '/env.html' do
 42 |   erb :env, :layout => !pjax?
 43 | end
 44 | 
 45 | post '/env.html' do
 46 |   erb :env, :layout => !pjax?
 47 | end
 48 | 
 49 | put '/env.html' do
 50 |   erb :env, :layout => !pjax?
 51 | end
 52 | 
 53 | delete '/env.html' do
 54 |   erb :env, :layout => !pjax?
 55 | end
 56 | 
 57 | get '/redirect.html' do
 58 |   if params[:anchor]
 59 |     path = "/hello.html##{params[:anchor]}"
 60 |     if pjax?
 61 |       response.headers['X-PJAX-URL'] = uri(path)
 62 |       status 200
 63 |     else
 64 |       redirect path
 65 |     end
 66 |   else
 67 |     redirect "/hello.html"
 68 |   end
 69 | end
 70 | 
 71 | get '/timeout.html' do
 72 |   if pjax?
 73 |     sleep 1
 74 |     erb :timeout, :layout => false
 75 |   else
 76 |     erb :timeout
 77 |   end
 78 | end
 79 | 
 80 | post '/timeout.html' do
 81 |   if pjax?
 82 |     sleep 1
 83 |     erb :timeout, :layout => false
 84 |   else
 85 |     status 500
 86 |     erb :boom
 87 |   end
 88 | end
 89 | 
 90 | get '/boom.html' do
 91 |   status 500
 92 |   erb :boom, :layout => !pjax?
 93 | end
 94 | 
 95 | get '/boom_sans_pjax.html' do
 96 |   status 500
 97 |   erb :boom_sans_pjax, :layout => false
 98 | end
 99 | 
100 | get '/:page.html' do
101 |   erb :"#{params[:page]}", :layout => !pjax?
102 | end
103 | 
104 | get '/some-&-path/hello.html' do
105 |   erb :hello, :layout => !pjax?
106 | end
107 | 


--------------------------------------------------------------------------------
/test/evaled.js:
--------------------------------------------------------------------------------
1 | window.externalScriptLoaded()
2 | 


--------------------------------------------------------------------------------
/test/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/defunkt/jquery-pjax/153262eda33e31119eabb97cd5f14365580a3b35/test/favicon.ico


--------------------------------------------------------------------------------
/test/run-qunit.js:
--------------------------------------------------------------------------------
 1 | var fs = require('fs')
 2 | var suites = require('system').args.slice(1)
 3 | 
 4 | function print(s) {
 5 |   fs.write('/dev/stdout', s, 'w')
 6 | }
 7 | 
 8 | var page = require('webpage').create()
 9 | page.onConsoleMessage = function(msg) {
10 |   console.log(msg)
11 | }
12 | page.onError = function(msg) {
13 |   console.error('ERROR: ' + msg)
14 | }
15 | 
16 | var timeoutId = null
17 | function deferTimeout() {
18 |   if (timeoutId) clearTimeout(timeoutId)
19 |   timeoutId = setTimeout(function() {
20 |     console.error('Timeout')
21 |     phantom.exit(1)
22 |   }, 3000)
23 | }
24 | 
25 | var endresult = 0
26 | 
27 | function runSuite() {
28 |   var suite = suites.shift()
29 |   if (!suite) {
30 |     phantom.exit(endresult)
31 |     return
32 |   }
33 | 
34 |   page.open(suite, function() {
35 |     deferTimeout()
36 | 
37 |     var interval = setInterval(function() {
38 |       var tests = page.evaluate(function() {
39 |         var results = []
40 |         var els = document.getElementById('qunit-tests').children
41 | 
42 |         for (var i = 0; i < els.length; i++) {
43 |           var test = els[i]
44 |           if (test.className !== 'running' && !test.recorded) {
45 |             test.recorded = true
46 |             if (test.className === 'pass') results.push('.')
47 |             else if (test.className === 'fail') results.push('F')
48 |           }
49 |         }
50 | 
51 |         return results
52 |       })
53 | 
54 |       for (var i = 0; i < tests.length; i++) {
55 |         deferTimeout()
56 |         print(tests[i])
57 |       }
58 | 
59 |       var result = page.evaluate(function() {
60 |         var testresult = document.getElementById('qunit-testresult')
61 |         var els = document.getElementById('qunit-tests').children
62 | 
63 |         if (testresult.innerText.match(/completed/)) {
64 |           console.log('')
65 | 
66 |           for (var i = 0; i < els.length; i++) {
67 |             var test = els[i]
68 |             if (test.className === 'fail') {
69 |               console.error(test.innerText)
70 |             }
71 |           }
72 | 
73 |           console.log(testresult.innerText)
74 |           return parseInt(testresult.getElementsByClassName('failed')[0].innerText)
75 |         }
76 |       })
77 | 
78 |       if (result != null) {
79 |         endresult = result
80 |         clearInterval(interval)
81 |         runSuite()
82 |       }
83 |     }, 100)
84 |   })
85 | }
86 | 
87 | runSuite()
88 | 


--------------------------------------------------------------------------------
/test/unit/fn_pjax.js:
--------------------------------------------------------------------------------
  1 | if ($.support.pjax) {
  2 |   module("$.fn.pjax", {
  3 |     setup: function() {
  4 |       var self = this
  5 |       stop()
  6 |       window.iframeLoad = function(frame) {
  7 |         self.frame = frame
  8 |         window.iframeLoad = $.noop
  9 |         start()
 10 |       }
 11 |       $("#qunit-fixture").append("<iframe src='home.html'>")
 12 |     },
 13 |     teardown: function() {
 14 |       delete window.iframeLoad
 15 |     }
 16 |   })
 17 | 
 18 | 
 19 |   asyncTest("pushes new url", function() {
 20 |     var frame = this.frame
 21 | 
 22 |     frame.$("#main").pjax("a", "#main").on("pjax:end", function() {
 23 |       equal(frame.location.pathname, "/dinosaurs.html")
 24 |       start()
 25 |     })
 26 | 
 27 |     frame.$("a[href='/dinosaurs.html']").click()
 28 |   })
 29 | 
 30 |   asyncTest("replaces container html from response data", function() {
 31 |     var frame = this.frame
 32 | 
 33 |     frame.$("#main").pjax("a", "#main").on("pjax:end", function() {
 34 |       equal(frame.$("iframe").attr('title'), "YouTube video player")
 35 |       start()
 36 |     })
 37 | 
 38 |     frame.$("a[href='/dinosaurs.html']").click()
 39 |   })
 40 | 
 41 |   asyncTest("sets title to response title tag", function() {
 42 |     var frame = this.frame
 43 | 
 44 |     frame.$("#main").pjax("a", "#main").on("pjax:end", function() {
 45 |       equal(frame.document.title, "dinosaurs")
 46 |       start()
 47 |     })
 48 | 
 49 |     frame.$("a[href='/dinosaurs.html']").trigger('click')
 50 |   })
 51 | 
 52 |   asyncTest("uses second argument as options", function() {
 53 |     var frame = this.frame
 54 | 
 55 |     frame.$("#main").pjax("a", {container: "#main", push: true}).on("pjax:end", function() {
 56 |       equal(frame.location.pathname, "/dinosaurs.html")
 57 |       start()
 58 |     })
 59 | 
 60 |     frame.$("a[href='/dinosaurs.html']").click()
 61 |   })
 62 | 
 63 |   asyncTest("uses second argument as container and third as options", function() {
 64 |     var frame = this.frame
 65 | 
 66 |     frame.$("body").pjax("a", "#main", {push: true}).on("pjax:end", function() {
 67 |       equal(frame.location.pathname, "/dinosaurs.html")
 68 |       start()
 69 |     })
 70 | 
 71 |     frame.$("a[href='/dinosaurs.html']").click()
 72 |   })
 73 | 
 74 | 
 75 |   asyncTest("defaults to data-pjax container", function() {
 76 |     var frame = this.frame
 77 | 
 78 |     frame.$("a").attr('data-pjax', "#main")
 79 | 
 80 |     frame.$("body").pjax("a")
 81 | 
 82 |     frame.$("#main").on("pjax:end", function() {
 83 |       equal(frame.location.pathname, "/dinosaurs.html")
 84 |       start()
 85 |     })
 86 | 
 87 |     frame.$("a[href='/dinosaurs.html']").click()
 88 |   })
 89 | 
 90 |   asyncTest("sets relatedTarget to clicked element", function() {
 91 |     var frame = this.frame
 92 | 
 93 |     frame.$("#main").pjax("a", "#main")
 94 | 
 95 |     var link = frame.$("a[href='/dinosaurs.html']")[0]
 96 | 
 97 |     frame.$("#main").on("pjax:end", function(event, xhr, options) {
 98 |       equal(link, event.relatedTarget)
 99 |       start()
100 |     })
101 | 
102 |     frame.$(link).click()
103 |   })
104 | 
105 | 
106 |   asyncTest("doesn't ignore left click", function() {
107 |     var frame = this.frame
108 | 
109 |     frame.$("#main").pjax("a", "#main")
110 | 
111 |     var event = frame.$.Event('click')
112 |     event.which = 0
113 |     frame.$("a[href='/dinosaurs.html']").trigger(event)
114 |     ok(event.isDefaultPrevented())
115 | 
116 |     start()
117 |   })
118 | 
119 |   asyncTest("ignores middle clicks", function() {
120 |     var frame = this.frame
121 | 
122 |     frame.$("#main").pjax("a", "#main")
123 | 
124 |     var event = frame.$.Event('click')
125 |     event.which = 3
126 |     frame.$("a[href='/dinosaurs.html']").trigger(event)
127 |     ok(!event.isDefaultPrevented())
128 | 
129 |     start()
130 |   })
131 | 
132 |   asyncTest("ignores command clicks", function() {
133 |     var frame = this.frame
134 | 
135 |     frame.$("#main").pjax("a")
136 | 
137 |     var event = frame.$.Event('click')
138 |     event.metaKey = true
139 |     frame.$("a[href='/dinosaurs.html']").trigger(event)
140 |     ok(!event.isDefaultPrevented())
141 | 
142 |     start()
143 |   })
144 | 
145 |   asyncTest("ignores ctrl clicks", function() {
146 |     var frame = this.frame
147 | 
148 |     frame.$("#main").pjax("a")
149 | 
150 |     var event = frame.$.Event('click')
151 |     event.ctrlKey = true
152 |     frame.$("a[href='/dinosaurs.html']").trigger(event)
153 |     ok(!event.isDefaultPrevented())
154 | 
155 |     start()
156 |   })
157 | 
158 |   asyncTest("ignores cross origin links", function() {
159 |     var frame = this.frame
160 | 
161 |     frame.$("#main").pjax("a")
162 | 
163 |     var event = frame.$.Event('click')
164 |     frame.$("a[href='https://www.google.com/']").trigger(event)
165 |     notEqual(event.result, false)
166 | 
167 |     start()
168 |   })
169 | 
170 |   asyncTest("ignores same page anchors", function() {
171 |     var event, frame = this.frame
172 | 
173 |     frame.$("#main").pjax("a")
174 | 
175 |     event = frame.$.Event('click')
176 |     frame.$("a[href='#main']").trigger(event)
177 |     equal(event.isDefaultPrevented(), false)
178 | 
179 |     event = frame.$.Event('click')
180 |     frame.$("a[href='#']").trigger(event)
181 |     equal(event.isDefaultPrevented(), false)
182 | 
183 |     start()
184 |   })
185 | 
186 |   asyncTest("ignores same page anchors from URL that has hash", function() {
187 |     var event, frame = this.frame
188 | 
189 |     frame.window.location = "#foo"
190 |     frame.$("#main").pjax("a")
191 | 
192 |     event = frame.$.Event('click')
193 |     frame.$("a[href='#main']").trigger(event)
194 |     equal(event.isDefaultPrevented(), false)
195 | 
196 |     event = frame.$.Event('click')
197 |     frame.$("a[href='#']").trigger(event)
198 |     equal(event.isDefaultPrevented(), false)
199 | 
200 |     start()
201 |   })
202 | 
203 |   asyncTest("ignores event with prevented default", function() {
204 |     var frame = this.frame
205 |     var eventIgnored = true
206 | 
207 |     frame.$("#main").pjax("a").on("pjax:click", function() {
208 |       eventIgnored = false
209 |     })
210 |     frame.$("a[href='/dinosaurs.html']").on("click", function(event) {
211 |       event.preventDefault()
212 |       setTimeout(function() {
213 |         ok(eventIgnored, "Event with prevented default ignored")
214 |         start()
215 |       }, 10)
216 |     })
217 | 
218 |     frame.$("a[href='/dinosaurs.html']").click()
219 |   })
220 | 
221 |   asyncTest("triggers pjax:click event from link", function() {
222 |     var frame = this.frame
223 | 
224 |     frame.$("#main").pjax("a", "#main").on("pjax:click", function(event, options) {
225 |       ok(event)
226 |       equal(options.container, "#main")
227 |       ok(options.url.match("/dinosaurs.html"))
228 |       start()
229 |     })
230 | 
231 |     frame.$("a[href='/dinosaurs.html']").click()
232 |   })
233 | 
234 |   asyncTest("triggers pjax:clicked event from link", function() {
235 |     var frame = this.frame
236 | 
237 |     frame.$("#main").pjax("a", "#main").on("pjax:clicked", function(event, options) {
238 |       ok(event)
239 |       equal(options.container, "#main")
240 |       ok(options.url.match("/dinosaurs.html"))
241 |       start()
242 |     })
243 | 
244 |     frame.$("a[href='/dinosaurs.html']").click()
245 |   })
246 | }
247 | 


--------------------------------------------------------------------------------
/test/unit/helpers.js:
--------------------------------------------------------------------------------
 1 | // Navigation helper for the test iframe. Queues navigation actions and
 2 | // callbacks, then executes them serially with respect to async. This is to
 3 | // avoid deep nesting of callbacks in tests.
 4 | //
 5 | // If a `then`able object is returned from a callback, then the navigation will
 6 | // resume only after the promise has been resolved.
 7 | //
 8 | // After last successful navigation, asyncTest is automatically resumed.
 9 | //
10 | // Usage:
11 | //
12 | //   navigate(this.frame)
13 | //   .pjax(pjaxOptions, function(frame){ ... }
14 | //   .back(-1, function(frame){ ... }
15 | //
16 | function navigate(frame) {
17 |   var queue = []
18 |   var api = {}
19 | 
20 |   api.pjax = function(options, callback) {
21 |     queue.push([options, callback])
22 |     return api
23 |   }
24 |   api.back = api.pjax
25 | 
26 |   var workOff = function() {
27 |     var item = queue.shift()
28 |     if (!item) {
29 |       start()
30 |       return
31 |     }
32 | 
33 |     var target = item[0], callback = item[1]
34 | 
35 |     frame.$(frame.document).one("pjax:end", function() {
36 |       var promise = callback && callback(frame)
37 |       if (promise && typeof promise.then == "function") promise.then(workOff)
38 |       else setTimeout(workOff, 0)
39 |     })
40 | 
41 |     if (typeof target == "number") {
42 |       frame.history.go(target)
43 |     } else {
44 |       frame.$.pjax(target)
45 |     }
46 |   }
47 | 
48 |   setTimeout(workOff, 0)
49 | 
50 |   return api
51 | }
52 | 
53 | // A poor man's Promise implementation. Only resolvable promises with no
54 | // reject/catch support.
55 | function PoorMansPromise(setup) {
56 |   var result, callback, i = 0, callbacks = []
57 |   setup(function(_result) {
58 |     result = _result
59 |     while (callback = callbacks[i++]) callback(result)
60 |   })
61 |   this.then = function(done) {
62 |     if (i == 0) callbacks.push(done)
63 |     else setTimeout(function(){ done(result) }, 0)
64 |     return this
65 |   }
66 | }
67 | 


--------------------------------------------------------------------------------
/test/unit/pjax.js:
--------------------------------------------------------------------------------
   1 | if ($.support.pjax) {
   2 |   module("$.pjax", {
   3 |     setup: function() {
   4 |       var self = this
   5 |       stop()
   6 |       window.iframeLoad = function(frame) {
   7 |         self.frame = frame
   8 |         window.iframeLoad = $.noop
   9 |         start()
  10 |       }
  11 |       $("#qunit-fixture").append("<iframe src='home.html'>")
  12 |       this.iframe = $("iframe")[0]
  13 |     },
  14 |     teardown: function() {
  15 |       delete window.iframeLoad
  16 |     }
  17 |   })
  18 | 
  19 |   asyncTest("pushes new url", 2, function() {
  20 |     navigate(this.frame)
  21 |     .pjax({ url: "hello.html", container: "#main", cache: false }, function(frame) {
  22 |       equal(frame.location.pathname, "/hello.html")
  23 |       equal(frame.location.search, "")
  24 |     })
  25 |   })
  26 | 
  27 |   asyncTest("replaces container html from response data", 2, function() {
  28 |     navigate(this.frame)
  29 |     .pjax({ url: "hello.html", container: "#main" }, function(frame) {
  30 |       equal(frame.$("#main > p").html().trim(), "Hello!")
  31 |       equal(frame.$("#main").contents().eq(1).text().trim(), "How's it going?")
  32 |     })
  33 |   })
  34 | 
  35 |   asyncTest("sets title to response title tag", 2, function() {
  36 |     navigate(this.frame)
  37 |     .pjax({ url: "hello.html", container: "#main" }, function(frame) {
  38 |       equal(frame.document.title, "Hello")
  39 |       equal(frame.$("#main title").length, 0)
  40 |     })
  41 |   })
  42 | 
  43 |   asyncTest("sets title to response nested title tag", 2, function() {
  44 |     navigate(this.frame)
  45 |     .pjax({ url: "nested_title.html", container: "#main" }, function(frame) {
  46 |       equal(frame.document.title, "Hello")
  47 |       equal(frame.$("#main title").length, 0)
  48 |     })
  49 |   })
  50 | 
  51 |   asyncTest("sets title to response last title tag", 2, function() {
  52 |     navigate(this.frame)
  53 |     .pjax({ url: "double_title.html", container: "#main" }, function(frame) {
  54 |       equal(frame.document.title, "World!")
  55 |       equal(frame.$("#main title").length, 0)
  56 |     })
  57 |   })
  58 | 
  59 |   asyncTest("scrolls to top of page", 2, function() {
  60 |     this.frame.scrollTo(0, 100)
  61 |     equal(this.frame.pageYOffset, 100)
  62 | 
  63 |     navigate(this.frame)
  64 |     .pjax({ url: "long.html", container: "#main" }, function(frame) {
  65 |       equal(frame.pageYOffset, 0)
  66 |     })
  67 |   })
  68 | 
  69 |   asyncTest("scrollTo: false avoids changing current scroll position", 2, function() {
  70 |     this.frame.scrollTo(0, 100)
  71 |     equal(this.frame.pageYOffset, 100)
  72 | 
  73 |     navigate(this.frame)
  74 |     .pjax({ url: "long.html", scrollTo: false, container: "#main" }, function(frame) {
  75 |       equal(frame.window.pageYOffset, 100)
  76 |     })
  77 |   })
  78 | 
  79 |   asyncTest("evals scripts", 7, function() {
  80 |     var externalLoadedCount = 0
  81 |     this.frame.externalScriptLoaded = function() {
  82 |       externalLoadedCount++
  83 |     }
  84 | 
  85 |     navigate(this.frame)
  86 |     .pjax({ url: "scripts.html?name=one", container: "#main" }, function(frame) {
  87 |       deepEqual(frame.evaledInlineLog, ["one"])
  88 |       equal(externalLoadedCount, 0)
  89 |       return new PoorMansPromise(function(resolve) {
  90 |         setTimeout(resolve, 100)
  91 |       }).then(function() {
  92 |         equal(externalLoadedCount, 2, "expected scripts to have loaded")
  93 |       })
  94 |     })
  95 |     .pjax({ url: "scripts.html?name=two", container: "#main" }, function(frame) {
  96 |       deepEqual(frame.evaledInlineLog, ["one", "two"])
  97 |     })
  98 |     .back(-1, function(frame) {
  99 |       deepEqual(frame.evaledInlineLog, ["one", "two", "one"])
 100 |     })
 101 |     .back(+1, function(frame) {
 102 |       deepEqual(frame.evaledInlineLog, ["one", "two", "one", "two"])
 103 |       return new PoorMansPromise(function(resolve) {
 104 |         setTimeout(resolve, 100)
 105 |       }).then(function() {
 106 |         equal(externalLoadedCount, 2, "expected no extra scripts to load")
 107 |       })
 108 |     })
 109 |   })
 110 | 
 111 |   asyncTest("url option accepts function", 2, function() {
 112 |     var numCalls = 0
 113 |     var url = function() {
 114 |       numCalls++
 115 |       return "hello.html"
 116 |     }
 117 | 
 118 |     navigate(this.frame)
 119 |     .pjax({ url: url, container: "#main" }, function(frame) {
 120 |       equal(frame.$("#main > p").html().trim(), "Hello!")
 121 |       equal(numCalls, 1)
 122 |     })
 123 |   })
 124 | 
 125 |   asyncTest("sets X-PJAX header on XHR request", 1, function() {
 126 |     navigate(this.frame)
 127 |     .pjax({ url: "env.html", container: "#main" }, function(frame) {
 128 |       var env = JSON.parse(frame.$("#env").text())
 129 |       equal(env["HTTP_X_PJAX"], "true")
 130 |     })
 131 |   })
 132 | 
 133 |   asyncTest("sets X-PJAX-Container header to container on XHR request", 1, function() {
 134 |     navigate(this.frame)
 135 |     .pjax({ url: "env.html", container: "#main" }, function(frame) {
 136 |       var env = JSON.parse(frame.$("#env").text())
 137 |       equal(env["HTTP_X_PJAX_CONTAINER"], "#main")
 138 |     })
 139 |   })
 140 | 
 141 |   asyncTest("sets hidden _pjax param on XHR GET request", 1, function() {
 142 |     navigate(this.frame)
 143 |     .pjax({ data: undefined, url: "env.html", container: "#main" }, function(frame) {
 144 |       var env = JSON.parse(frame.$("#env").text())
 145 |       equal(env["rack.request.query_hash"]["_pjax"], "#main")
 146 |     })
 147 |   })
 148 | 
 149 |   asyncTest("sets hidden _pjax param if array data is supplied", 1, function() {
 150 |     var data = [{ name: "foo", value: "bar" }]
 151 | 
 152 |     navigate(this.frame)
 153 |     .pjax({ data: data, url: "env.html", container: "#main" }, function(frame) {
 154 |       var env = JSON.parse(frame.$("#env").text())
 155 |       deepEqual(env["rack.request.query_hash"], {
 156 |         "_pjax": "#main"
 157 |       , "foo": "bar"
 158 |       })
 159 |     })
 160 |   })
 161 | 
 162 |   asyncTest("sets hidden _pjax param if object data is supplied", 1, function() {
 163 |     var data = { foo: "bar" }
 164 | 
 165 |     navigate(this.frame)
 166 |     .pjax({ data: data, url: "env.html", container: "#main" }, function(frame) {
 167 |       var env = JSON.parse(frame.$("#env").text())
 168 |       deepEqual(env["rack.request.query_hash"], {
 169 |         "_pjax": "#main"
 170 |       , "foo": "bar"
 171 |       })
 172 |     })
 173 |   })
 174 | 
 175 |   asyncTest("preserves query string on GET request", 3, function() {
 176 |     navigate(this.frame)
 177 |     .pjax({ url: "env.html?foo=1&bar=2", container: "#main" }, function(frame) {
 178 |       equal(frame.location.pathname, "/env.html")
 179 |       equal(frame.location.search, "?foo=1&bar=2")
 180 | 
 181 |       var env = JSON.parse(frame.$("#env").text())
 182 |       deepEqual(env["rack.request.query_hash"], {
 183 |         "_pjax": "#main"
 184 |       , "foo": "1"
 185 |       , "bar": "2"
 186 |       })
 187 |     })
 188 |   })
 189 | 
 190 |   asyncTest("GET data is appended to query string", 6, function() {
 191 |     var data = { foo: 1, bar: 2 }
 192 | 
 193 |     navigate(this.frame)
 194 |     .pjax({ data: data, url: "env.html", container: "#main" }, function(frame) {
 195 |       equal(frame.location.pathname, "/env.html")
 196 |       equal(frame.location.search, "?foo=1&bar=2")
 197 | 
 198 |       var env = JSON.parse(frame.$("#env").text())
 199 |       deepEqual(env["rack.request.query_hash"], {
 200 |         "_pjax": "#main"
 201 |       , "foo": "1"
 202 |       , "bar": "2"
 203 |       })
 204 |     })
 205 | 
 206 |     var frame = this.frame
 207 |     setTimeout(function() {
 208 |       // URL is set immediately
 209 |       equal(frame.location.pathname, "/env.html")
 210 |       equal(frame.location.search, "?foo=1&bar=2")
 211 |       equal(frame.location.href.indexOf("#"), -1)
 212 |     }, 0)
 213 |   })
 214 | 
 215 |   asyncTest("GET data is merged into query string", 6, function() {
 216 |     var data = { bar: 2 }
 217 | 
 218 |     navigate(this.frame)
 219 |     .pjax({ data: data, url: "env.html?foo=1", container: "#main" }, function(frame) {
 220 |       equal(frame.location.pathname, "/env.html")
 221 |       equal(frame.location.search, "?foo=1&bar=2")
 222 | 
 223 |       var env = JSON.parse(frame.$("#env").text())
 224 |       deepEqual(env["rack.request.query_hash"], {
 225 |         "_pjax": "#main"
 226 |       , "foo": "1"
 227 |       , "bar": "2"
 228 |       })
 229 |     })
 230 | 
 231 |     var frame = this.frame
 232 |     setTimeout(function() {
 233 |       // URL is set immediately
 234 |       equal(frame.location.pathname, "/env.html")
 235 |       equal(frame.location.search, "?foo=1&bar=2")
 236 |       equal(frame.location.href.indexOf("#"), -1)
 237 |     }, 0)
 238 |   })
 239 | 
 240 |   asyncTest("mixed containers", 6, function() {
 241 |     navigate(this.frame)
 242 |     .pjax({ url: "fragment.html", container: "#main" })
 243 |     .pjax({ url: "aliens.html", container: "#foo" }, function(frame) {
 244 |       equal(frame.$("#main > #foo > ul > li").last().text(), "aliens")
 245 |     })
 246 |     .back(-1, function(frame) {
 247 |       equal(frame.$("#main > #foo").text().trim(), "Foo")
 248 |     })
 249 |     .pjax({ url: "env.html", replace: true, fragment: "#env", container: "#bar" }, function(frame) {
 250 |       // This replaceState shouldn't affect restoring other popstates
 251 |       equal(frame.$("#main > #foo").text().trim(), "Foo")
 252 |       ok(JSON.parse(frame.$("#bar").text()))
 253 |     })
 254 |     .back(-1, function(frame) {
 255 |       equal(frame.$("#main > ul > li").first().text(), "home")
 256 |     })
 257 |     .back(+1)
 258 |     .back(+1, function(frame) {
 259 |       equal(frame.$("#main > #foo > ul > li").last().text(), "aliens")
 260 |     })
 261 |   })
 262 | 
 263 |   asyncTest("only fragment is inserted", 2, function() {
 264 |     navigate(this.frame)
 265 |     .pjax({ url: "hello.html?layout=true", fragment: "#main", container: "#main" }, function(frame) {
 266 |       equal(frame.$("#main > p").html().trim(), "Hello!")
 267 |       equal(frame.document.title, "Hello")
 268 |     })
 269 |   })
 270 | 
 271 |   asyncTest("use body as fragment", 2, function() {
 272 |     navigate(this.frame)
 273 |     .pjax({ url: "hello.html?layout=true", fragment: "body", container: "body" }, function(frame) {
 274 |       equal(frame.$("body > #main > p").html().trim(), "Hello!")
 275 |       equal(frame.document.title, "Hello")
 276 |     })
 277 |   })
 278 | 
 279 |   asyncTest("fragment sets title to response title attr", 2, function() {
 280 |     navigate(this.frame)
 281 |     .pjax({ url: "fragment.html", fragment: "#foo", container: "#main" }, function(frame) {
 282 |       equal(frame.$("#main > p").html(), "Foo")
 283 |       equal(frame.document.title, "Foo")
 284 |     })
 285 |   })
 286 | 
 287 |   asyncTest("fragment sets title to response data-title attr", 2, function() {
 288 |     navigate(this.frame)
 289 |     .pjax({ url: "fragment.html", fragment: "#bar", container: "#main" }, function(frame) {
 290 |       equal(frame.$("#main > p").html(), "Bar")
 291 |       equal(frame.document.title, "Bar")
 292 |     })
 293 |   })
 294 | 
 295 |   asyncTest("missing fragment falls back to full load", 2, function() {
 296 |     var iframe = this.iframe
 297 | 
 298 |     navigate(this.frame)
 299 |     .pjax({ url: "hello.html?layout=true", fragment: "#missing", container: "#main" }, function() {
 300 |       return new PoorMansPromise(function(resolve) {
 301 |         iframe.onload = function() { resolve(this.contentWindow) }
 302 |       }).then(function(frame) {
 303 |         equal(frame.$("#main p").html(), "Hello!")
 304 |         equal(frame.location.pathname, "/hello.html")
 305 |       })
 306 |     })
 307 |   })
 308 | 
 309 |   asyncTest("missing data falls back to full load", 2, function() {
 310 |     var iframe = this.iframe
 311 | 
 312 |     navigate(this.frame)
 313 |     .pjax({ url: "empty.html", container: "#main" }, function() {
 314 |       return new PoorMansPromise(function(resolve) {
 315 |         iframe.onload = function() { resolve(this.contentWindow) }
 316 |       }).then(function(frame) {
 317 |         equal(frame.$("#main").html().trim(), "")
 318 |         equal(frame.location.pathname, "/empty.html")
 319 |       })
 320 |     })
 321 |   })
 322 | 
 323 |   asyncTest("full html page falls back to full load", 2, function() {
 324 |     var iframe = this.iframe
 325 | 
 326 |     navigate(this.frame)
 327 |     .pjax({ url: "hello.html?layout=true", container: "#main" }, function() {
 328 |       return new PoorMansPromise(function(resolve) {
 329 |         iframe.onload = function() { resolve(this.contentWindow) }
 330 |       }).then(function(frame) {
 331 |         equal(frame.$("#main p").html(), "Hello!")
 332 |         equal(frame.location.pathname, "/hello.html")
 333 |       })
 334 |     })
 335 |   })
 336 | 
 337 |   asyncTest("header version mismatch does a full load", 2, function() {
 338 |     var iframe = this.iframe
 339 |     this.frame.$.pjax.defaults.version = "v2"
 340 | 
 341 |     navigate(this.frame)
 342 |     .pjax({ url: "hello.html", container: "#main" }, function() {
 343 |       return new PoorMansPromise(function(resolve) {
 344 |         iframe.onload = function() { resolve(this.contentWindow) }
 345 |       }).then(function(frame) {
 346 |         equal(frame.$("#main p").html(), "Hello!")
 347 |         equal(frame.location.pathname, "/hello.html")
 348 |       })
 349 |     })
 350 |   })
 351 | 
 352 |   asyncTest("triggers pjax:start/end events from container", 12, function() {
 353 |     var eventLog = []
 354 |     var container = this.frame.document.getElementById("main")
 355 |     ok(container)
 356 | 
 357 |     this.frame.$(container).on("pjax:start pjax:end", function(event, xhr, options) {
 358 |       eventLog.push(arguments)
 359 |     })
 360 | 
 361 |     navigate(this.frame)
 362 |     .pjax({ url: "hello.html", container: "#main" }, function(frame) {
 363 |       equal(eventLog.length, 2)
 364 |       $.each(["pjax:start", "pjax:end"], function(i, expectedType) {
 365 |         (function(event, xhr, options){
 366 |           equal(event.type, expectedType)
 367 |           equal(event.target, container)
 368 |           equal(event.relatedTarget, null)
 369 |           equal(typeof xhr.abort, "function")
 370 |           equal(options.url, "hello.html")
 371 |         }).apply(this, eventLog[i])
 372 |       })
 373 |     })
 374 |   })
 375 | 
 376 |   asyncTest("events preserve explicit target as relatedTarget", 7, function() {
 377 |     var eventLog = []
 378 |     var container = this.frame.document.getElementById("main")
 379 |     ok(container)
 380 | 
 381 |     this.frame.$(container).on("pjax:start pjax:end", function(event, xhr, options) {
 382 |       eventLog.push(event)
 383 |     })
 384 | 
 385 |     navigate(this.frame)
 386 |     .pjax({ url: "hello.html", target: container, container: "#main" }, function(frame) {
 387 |       $.each(["pjax:start", "pjax:end"], function(i, expectedType) {
 388 |         var event = eventLog[i]
 389 |         equal(event.type, expectedType)
 390 |         equal(event.target, container)
 391 |         equal(event.relatedTarget, container)
 392 |       })
 393 |     })
 394 |   })
 395 | 
 396 |   asyncTest("stopping pjax:beforeSend prevents the request", 6, function() {
 397 |     var eventLog = []
 398 |     var container = this.frame.document.getElementById("main")
 399 |     ok(container)
 400 | 
 401 |     this.frame.$(container).on("pjax:beforeSend", function(event, xhr, settings) {
 402 |       eventLog.push(arguments)
 403 |       return false
 404 |     })
 405 | 
 406 |     navigate(this.frame)
 407 |     .pjax({ url: "hello.html", container: "#main" }, function(frame) {
 408 |       ok(false)
 409 |     })
 410 | 
 411 |     setTimeout(function() {
 412 |       equal(eventLog.length, 1)
 413 |       ;(function(event, xhr, settings){
 414 |         equal(event.type, "pjax:beforeSend")
 415 |         equal(event.target, container)
 416 |         equal(typeof xhr.abort, "function")
 417 |         equal(settings.dataType, "html")
 418 |       }).apply(this, eventLog[0])
 419 |       start()
 420 |     }, 100)
 421 |   })
 422 | 
 423 |   asyncTest("triggers pjax:beforeReplace event from container", 9, function() {
 424 |     var eventLog = []
 425 |     var container = this.frame.document.getElementById("main")
 426 |     ok(container)
 427 | 
 428 |     this.frame.$(container).on("pjax:beforeReplace", function(event, contents, options) {
 429 |       eventLog.push(arguments)
 430 |       equal(container.textContent.indexOf("Hello!"), -1)
 431 |     })
 432 | 
 433 |     var urlPrefix = location.protocol + "//" + location.host
 434 | 
 435 |     navigate(this.frame)
 436 |     .pjax({ url: "hello.html", container: "#main" }, function(frame) {
 437 |       equal(eventLog.length, 1)
 438 | 
 439 |       ;(function(event, contents, options){
 440 |         equal(event.target, container)
 441 |         equal(event.state.url, urlPrefix + "/hello.html")
 442 |         equal(event.previousState.url, urlPrefix + "/home.html")
 443 |         equal(contents[0].nodeName, "P")
 444 |         // FIXME: Should this be absolute URL?
 445 |         equal(options.url, "hello.html")
 446 |       }).apply(this, eventLog[0])
 447 | 
 448 |       ok(container.textContent.indexOf("Hello!") >= 0)
 449 |     })
 450 |   })
 451 | 
 452 |   asyncTest("triggers pjax:success/complete events from container", function() {
 453 |     var eventLog = []
 454 |     var container = this.frame.document.getElementById("main")
 455 |     ok(container)
 456 | 
 457 |     this.frame.$(container).on("pjax:success pjax:complete", function(event) {
 458 |       eventLog.push(arguments)
 459 |     })
 460 | 
 461 |     navigate(this.frame)
 462 |     .pjax({ url: "hello.html", container: "#main" }, function(frame) {
 463 |       equal(eventLog.length, 2)
 464 | 
 465 |       ;(function(event, data, status, xhr, options){
 466 |         equal(event.type, "pjax:success")
 467 |         equal(event.target, container)
 468 |         ok(data.indexOf("<p>Hello!</p>") >= 0)
 469 |         equal(status, "success")
 470 |         equal(typeof xhr.abort, "function")
 471 |         equal(options.url, "hello.html")
 472 |       }).apply(this, eventLog[0])
 473 | 
 474 |       ;(function(event, xhr, status, options){
 475 |         equal(event.type, "pjax:complete")
 476 |         equal(event.target, container)
 477 |         equal(typeof xhr.abort, "function")
 478 |         equal(status, "success")
 479 |         equal(options.url, "hello.html")
 480 |       }).apply(this, eventLog[1])
 481 |     })
 482 |   })
 483 | 
 484 |   asyncTest("triggers pjax:error event from container", function() {
 485 |     var frame = this.frame
 486 | 
 487 |     frame.$("#main").on("pjax:error", function(event, xhr, status, error, options) {
 488 |       ok(event)
 489 |       equal(xhr.status, 500)
 490 |       equal(status, 'error')
 491 |       equal(error.trim(), 'Internal Server Error')
 492 |       equal(options.url, "boom.html")
 493 |       start()
 494 |     })
 495 | 
 496 |     frame.$.pjax({
 497 |       url: "boom.html",
 498 |       container: "#main"
 499 |     })
 500 |   })
 501 | 
 502 |   asyncTest("stopping pjax:error disables default behavior", function() {
 503 |     var frame = this.frame
 504 | 
 505 |     frame.$("#main").on("pjax:error", function(event, xhr) {
 506 |       ok(true)
 507 | 
 508 |       setTimeout(function() {
 509 |         xhr.abort()
 510 |         start()
 511 |       }, 0)
 512 | 
 513 |       return false
 514 |     })
 515 | 
 516 |     this.iframe.onload = function() { ok(false) }
 517 | 
 518 |     frame.$.pjax({
 519 |       url: "boom.html",
 520 |       container: "#main"
 521 |     })
 522 |   })
 523 | 
 524 |   asyncTest("loads fallback if timeout event isn't handled", function() {
 525 |     var frame = this.frame
 526 | 
 527 |     frame.$.pjax({
 528 |       url: "timeout.html#hello",
 529 |       container: "#main"
 530 |     })
 531 | 
 532 |     equal(frame.location.pathname, "/timeout.html")
 533 |     equal(frame.location.hash, "#hello")
 534 | 
 535 |     this.iframe.onload = function() {
 536 |       equal(frame.$("#main p").html(), "SLOW DOWN!")
 537 |       equal(frame.location.pathname, "/timeout.html")
 538 |       equal(frame.location.hash, "#hello")
 539 |       start()
 540 |     }
 541 |   })
 542 | 
 543 |   asyncTest("stopping pjax:timeout disables default behavior", function() {
 544 |     var frame = this.frame
 545 | 
 546 |     frame.$("#main").on("pjax:timeout", function(event, xhr) {
 547 |       ok(true)
 548 | 
 549 |       setTimeout(function() {
 550 |         xhr.abort()
 551 |         start()
 552 |       }, 0)
 553 | 
 554 |       return false
 555 |     })
 556 | 
 557 |     this.iframe.onload = function() { ok(false) }
 558 | 
 559 |     frame.$.pjax({
 560 |       url: "timeout.html",
 561 |       container: "#main"
 562 |     })
 563 |   })
 564 | 
 565 |   asyncTest("POST never times out", function() {
 566 |     var frame = this.frame
 567 | 
 568 |     frame.$("#main").on("pjax:complete", function() {
 569 |       equal(frame.$("#main p").html(), "SLOW DOWN!")
 570 |       equal(frame.location.pathname, "/timeout.html")
 571 |       start()
 572 |     })
 573 |     frame.$("#main").on("pjax:timeout", function(event, xhr) {
 574 |       ok(false)
 575 |     })
 576 |     this.iframe.onload = function() { ok(false) }
 577 | 
 578 |     frame.$.pjax({
 579 |       type: 'POST',
 580 |       url: "timeout.html",
 581 |       container: "#main"
 582 |     })
 583 |   })
 584 | 
 585 |   asyncTest("500 loads fallback", function() {
 586 |     var frame = this.frame
 587 | 
 588 |     frame.$.pjax({
 589 |       url: "boom.html",
 590 |       container: "#main"
 591 |     })
 592 | 
 593 |     this.iframe.onload = function() {
 594 |       equal(frame.$("#main p").html(), "500")
 595 |       equal(frame.location.pathname, "/boom.html")
 596 |       start()
 597 |     }
 598 |   })
 599 | 
 600 |   asyncTest("POST 500 never loads fallback", function() {
 601 |     var frame = this.frame
 602 | 
 603 |     frame.$("#main").on("pjax:complete", function() {
 604 |       equal(frame.location.pathname, "/boom.html")
 605 |       start()
 606 |     })
 607 |     frame.$("#main").on("pjax:error", function(event, xhr) {
 608 |       ok(true)
 609 |     })
 610 |     frame.$("#main").on("pjax:timeout", function(event, xhr) {
 611 |       ok(false)
 612 |     })
 613 |     this.iframe.onload = function() { ok(false) }
 614 | 
 615 |     frame.$.pjax({
 616 |       type: 'POST',
 617 |       url: "boom.html",
 618 |       container: "#main"
 619 |     })
 620 |   })
 621 | 
 622 |   function goBack(frame, callback) {
 623 |     setTimeout(function() {
 624 |       frame.$("#main").one("pjax:end", callback)
 625 |       frame.history.back()
 626 |     }, 0)
 627 |   }
 628 | 
 629 |   asyncTest("clicking back while loading cancels XHR", function() {
 630 |     var frame = this.frame
 631 | 
 632 |     frame.$('#main').on('pjax:timeout', function(event) {
 633 |       event.preventDefault()
 634 |     })
 635 | 
 636 |     frame.$("#main").one('pjax:send', function() {
 637 | 
 638 |       // Check that our request is aborted (need to check
 639 |       // how robust this is across browsers)
 640 |       frame.$("#main").one('pjax:complete', function(e, xhr, textStatus) {
 641 |         equal(xhr.status, 0)
 642 |         equal(textStatus, 'abort')
 643 |       })
 644 | 
 645 |       setTimeout(function() {
 646 |         frame.history.back()
 647 |       }, 250)
 648 | 
 649 |       // Make sure the URL and content remain the same after the
 650 |       // XHR would have arrived (delay on timeout.html is 1s)
 651 |       setTimeout(function() {
 652 |         var afterBackLocation = frame.location.pathname
 653 |         var afterBackTitle = frame.document.title
 654 | 
 655 |         setTimeout(function() {
 656 |           equal(frame.location.pathname, afterBackLocation)
 657 |           equal(frame.document.title, afterBackTitle)
 658 |           start()
 659 |         }, 1000)
 660 |       }, 500)
 661 |     })
 662 | 
 663 |     frame.$.pjax({
 664 |       url: "timeout.html",
 665 |       container: "#main"
 666 |     })
 667 |   })
 668 | 
 669 |   asyncTest("popstate going back/forward in history", 14, function() {
 670 |     var eventLog = []
 671 |     var container = this.frame.document.getElementById("main")
 672 |     ok(container)
 673 | 
 674 |     this.frame.$(container).on("pjax:popstate", function(event) {
 675 |       eventLog.push(event)
 676 |     })
 677 | 
 678 |     navigate(this.frame)
 679 |     .pjax({ url: "hello.html", container: "#main" }, function(frame) {
 680 |       equal(frame.location.pathname, "/hello.html")
 681 |       equal(frame.document.title, "Hello")
 682 |       equal(eventLog.length, 0)
 683 |     })
 684 |     .back(-1, function(frame) {
 685 |       equal(frame.location.pathname, "/home.html")
 686 |       equal(frame.document.title, "Home")
 687 |       equal(eventLog.length, 1)
 688 |       equal(eventLog[0].direction, "back")
 689 |       equal(eventLog[0].state.container, "#main")
 690 |     })
 691 |     .back(+1, function(frame) {
 692 |       equal(frame.location.pathname, "/hello.html")
 693 |       equal(frame.document.title, "Hello")
 694 |       equal(eventLog.length, 2)
 695 |       equal(eventLog[1].direction, "forward")
 696 |       equal(eventLog[1].state.container, "#main")
 697 |     })
 698 |   })
 699 | 
 700 |   asyncTest("popstate restores original scroll position", 2, function() {
 701 |     this.frame.scrollTo(0, 100)
 702 |     equal(this.frame.pageYOffset, 100)
 703 | 
 704 |     navigate(this.frame)
 705 |     .pjax({ url: "long.html", container: "#main" }, function(frame) {
 706 |       equal(frame.pageYOffset, 0)
 707 |     })
 708 |     .back(-1, function(frame) {
 709 |       // FIXME: Seems like this functionality is natively broken in PhantomJS and Safari
 710 |       // equal(frame.pageYOffset, 100)
 711 |     })
 712 |   })
 713 | 
 714 |   asyncTest("popstate triggers pjax:beforeReplace event", 10, function() {
 715 |     var eventLog = []
 716 |     var container = this.frame.document.getElementById("main")
 717 |     ok(container)
 718 | 
 719 |     this.frame.$(container).on("pjax:beforeReplace", function(event, contents, options) {
 720 |       eventLog.push(arguments)
 721 |       if (eventLog.length == 2) {
 722 |         equal(container.textContent.indexOf("home"), -1)
 723 |       }
 724 |     })
 725 | 
 726 |     var urlPrefix = location.protocol + "//" + location.host
 727 | 
 728 |     navigate(this.frame)
 729 |     .pjax({ url: "hello.html", container: "#main" })
 730 |     .back(-1, function(frame) {
 731 |       equal(eventLog.length, 2)
 732 | 
 733 |       // FIXME: First "pjax:beforeReplace" event has relative URL,
 734 |       // while the 2nd (triggered by popstate) has absolute URL.
 735 |       equal(eventLog[0][2].url, "hello.html")
 736 | 
 737 |       ;(function(event, contents, options){
 738 |         equal(event.target, container)
 739 |         equal(event.previousState.url, urlPrefix + "/hello.html")
 740 |         equal(event.state.url, urlPrefix + "/home.html")
 741 |         equal(contents[1].nodeName, "UL")
 742 |         equal(options.url, urlPrefix + "/home.html")
 743 |       }).apply(this, eventLog[1])
 744 | 
 745 |       ok(container.textContent.indexOf("home") >= 0)
 746 |     })
 747 |   })
 748 | 
 749 |   asyncTest("no initial pjax:popstate event", function() {
 750 |     var frame = this.frame
 751 |     var count = 0
 752 | 
 753 |     window.iframeLoad = function() {
 754 |       count++
 755 | 
 756 |       if (count == 1) {
 757 |         equal(frame.location.pathname, "/home.html")
 758 |         frame.location.pathname = "/hello.html"
 759 |       } else if (count == 2) {
 760 |         equal(frame.location.pathname, "/hello.html")
 761 |         frame.$.pjax({url: "env.html", container: "#main"})
 762 |       } else if (count == 3) {
 763 |         equal(frame.location.pathname, "/env.html")
 764 |         frame.history.back()
 765 |       } else if (count == 4) {
 766 |         equal(frame.location.pathname, "/hello.html")
 767 |         frame.history.back()
 768 |       } else if (count == 5) {
 769 |         equal(frame.location.pathname, "/home.html")
 770 |         frame.history.forward()
 771 |       } else if (count == 6) {
 772 |         frame.$('#main').on('pjax:popstate', function(event) {
 773 |           if (count == 6) {
 774 |             // Should skip pjax:popstate since there's no initial pjax.state
 775 |             ok(event.state.url.match("/hello.html"), event.state.url)
 776 |             ok(false)
 777 |           } else if (count == 7) {
 778 |             ok(event.state.url.match("/env.html"), event.state.url)
 779 |             ok(true)
 780 |           }
 781 |         })
 782 | 
 783 |         frame.$(frame.window).on('popstate', function() {
 784 |           if (count == 6) {
 785 |             count++
 786 |             frame.history.forward()
 787 |           }
 788 |         })
 789 | 
 790 |         // Browsers that don't fire initial "popstate" should just resume
 791 |         setTimeout(function() {
 792 |           start()
 793 |         }, 100)
 794 |       }
 795 |     }
 796 | 
 797 |     window.iframeLoad()
 798 |   })
 799 | 
 800 |   asyncTest("hitting the back button obeys maxCacheLength", function() {
 801 |     var frame = this.frame
 802 |     var count = 0
 803 |     var didHitServer
 804 | 
 805 |     // Reduce the maxCacheLength for this spec to make it easier to test.
 806 |     frame.$.pjax.defaults.maxCacheLength = 1
 807 | 
 808 |     // This event will fire only when we request a page from the server, so we
 809 |     // can use it to detect a cache miss.
 810 |     frame.$("#main").on("pjax:beforeSend", function() {
 811 |       didHitServer = true
 812 |     })
 813 | 
 814 |     frame.$("#main").on("pjax:end", function() {
 815 |       count++
 816 | 
 817 |       // First, navigate twice.
 818 |       if (count == 1) {
 819 |         frame.$.pjax({url: "env.html", container: "#main"})
 820 |       } else if (count == 2) {
 821 |         frame.$.pjax({url: "hello.html", container: "#main"})
 822 |       } else if (count == 3) {
 823 |         // There should now be one item in the back cache.
 824 |         didHitServer = false
 825 |         frame.history.back()
 826 |       } else if (count == 4) {
 827 |         equal(frame.location.pathname, "/env.html", "Went backward")
 828 |         equal(didHitServer, false, "Hit cache")
 829 |         frame.history.back()
 830 |       } else if (count == 5) {
 831 |         equal(frame.location.pathname, "/hello.html", "Went backward")
 832 |         equal(didHitServer, true, "Hit server")
 833 |         start()
 834 |       }
 835 |     })
 836 | 
 837 |     frame.$.pjax({url: "hello.html", container: "#main"})
 838 |   })
 839 | 
 840 |   asyncTest("hitting the forward button obeys maxCacheLength", function() {
 841 |     var frame = this.frame
 842 |     var count = 0
 843 |     var didHitServer
 844 | 
 845 |     // Reduce the maxCacheLength for this spec to make it easier to test.
 846 |     frame.$.pjax.defaults.maxCacheLength = 1
 847 | 
 848 |     // This event will fire only when we request a page from the server, so we
 849 |     // can use it to detect a cache miss.
 850 |     frame.$("#main").on("pjax:beforeSend", function() {
 851 |       didHitServer = true
 852 |     })
 853 | 
 854 |     frame.$("#main").on("pjax:end", function() {
 855 |       count++
 856 | 
 857 |       if (count == 1) {
 858 |         frame.$.pjax({url: "env.html", container: "#main"})
 859 |       } else if (count == 2) {
 860 |         frame.$.pjax({url: "hello.html", container: "#main"})
 861 |       } else if (count == 3) {
 862 |         frame.history.back()
 863 |       } else if (count == 4) {
 864 |         frame.history.back()
 865 |       } else if (count == 5) {
 866 |         // There should now be one item in the forward cache.
 867 |         didHitServer = false
 868 |         frame.history.forward()
 869 |       } else if (count == 6) {
 870 |         equal(frame.location.pathname, "/env.html", "Went forward")
 871 |         equal(didHitServer, false, "Hit cache")
 872 |         frame.history.forward()
 873 |       } else if (count == 7) {
 874 |         equal(frame.location.pathname, "/hello.html", "Went forward")
 875 |         equal(didHitServer, true, "Hit server")
 876 |         start()
 877 |       }
 878 |     })
 879 | 
 880 |     frame.$.pjax({url: "hello.html", container: "#main"})
 881 |   })
 882 | 
 883 |   asyncTest("setting maxCacheLength to 0 disables caching", function() {
 884 |     var frame = this.frame
 885 |     var count = 0
 886 |     var didHitServer
 887 | 
 888 |     // Set maxCacheLength to 0 to disable caching completely.
 889 |     frame.$.pjax.defaults.maxCacheLength = 0
 890 | 
 891 |     // This event will fire only when we request a page from the server, so we
 892 |     // can use it to detect a cache miss.
 893 |     frame.$("#main").on("pjax:beforeSend", function() {
 894 |       didHitServer = true
 895 |     })
 896 | 
 897 |     frame.$("#main").on("pjax:end", function() {
 898 |       count++
 899 | 
 900 |       if (count == 1) {
 901 |         didHitServer = false
 902 |         frame.$.pjax({url: "env.html", container: "#main"})
 903 |       } else if (count == 2) {
 904 |         equal(frame.location.pathname, "/env.html", "Navigated to a new page")
 905 |         equal(didHitServer, true, "Hit server")
 906 |         didHitServer = false
 907 |         frame.history.back()
 908 |       } else if (count == 3) {
 909 |         equal(frame.location.pathname, "/hello.html", "Went backward")
 910 |         equal(didHitServer, true, "Hit server")
 911 |         didHitServer = false
 912 |         frame.history.forward()
 913 |       } else if (count == 4) {
 914 |         equal(frame.location.pathname, "/env.html", "Went forward")
 915 |         equal(didHitServer, true, "Hit server")
 916 |         start()
 917 |       }
 918 |     })
 919 | 
 920 |     frame.$.pjax({url: "hello.html", container: "#main"})
 921 |   })
 922 | 
 923 |   asyncTest("lazily sets initial $.pjax.state", function() {
 924 |     var frame = this.frame
 925 | 
 926 |     equal(frame.$.pjax.state, null)
 927 | 
 928 |     frame.$('#main').on("pjax:success", function() {
 929 |       start()
 930 |     })
 931 |     frame.$.pjax({
 932 |       url: "hello.html",
 933 |       container: "#main"
 934 |     })
 935 | 
 936 |     var initialState = frame.$.pjax.state
 937 |     ok(initialState.id)
 938 |     equal(initialState.url, "http://" + frame.location.host + "/home.html")
 939 |     equal(initialState.container, "#main")
 940 |   })
 941 | 
 942 |   asyncTest("updates $.pjax.state to new page", function() {
 943 |     var frame = this.frame
 944 | 
 945 |     frame.$('#main').on("pjax:success", function() {
 946 |       var state = frame.$.pjax.state
 947 |       ok(state.id)
 948 |       equal(state.url, "http://" + frame.location.host + "/hello.html#new")
 949 |       equal(state.container, "#main")
 950 |       start()
 951 |     })
 952 |     frame.$.pjax({
 953 |       url: "hello.html#new",
 954 |       container: "#main"
 955 |     })
 956 | 
 957 |     var initialState = frame.$.pjax.state
 958 |   })
 959 | 
 960 |   asyncTest("new id is generated for new pages", function() {
 961 |     var frame = this.frame
 962 | 
 963 |     var oldId
 964 | 
 965 |     frame.$('#main').on("pjax:success", function() {
 966 |       ok(frame.$.pjax.state.id)
 967 |       notEqual(oldId, frame.$.pjax.state.id)
 968 |       start()
 969 |     })
 970 |     frame.$.pjax({
 971 |       url: "hello.html",
 972 |       container: "#main"
 973 |     })
 974 | 
 975 |     ok(frame.$.pjax.state.id)
 976 |     oldId = frame.$.pjax.state.id
 977 |   })
 978 | 
 979 |   asyncTest("id is the same going back", function() {
 980 |     var frame = this.frame
 981 | 
 982 |     var oldId
 983 | 
 984 |     equal(frame.location.pathname, "/home.html")
 985 | 
 986 |     frame.$('#main').on("pjax:complete", function() {
 987 |       ok(frame.$.pjax.state.id)
 988 |       notEqual(oldId, frame.$.pjax.state.id)
 989 | 
 990 |       ok(frame.history.length > 1)
 991 |       goBack(frame, function() {
 992 |         ok(frame.$.pjax.state.id)
 993 |         equal(oldId, frame.$.pjax.state.id)
 994 |         start()
 995 |       })
 996 |     })
 997 |     frame.$.pjax({
 998 |       url: "hello.html",
 999 |       container: "#main"
1000 |     })
1001 | 
1002 |     ok(frame.$.pjax.state.id)
1003 |     oldId = frame.$.pjax.state.id
1004 |   })
1005 | 
1006 |   asyncTest("handles going back to pjaxed state after reloading a fragment navigation", function() {
1007 |     var iframe = this.iframe
1008 |     var frame = this.frame
1009 |     var supportsHistoryState = 'state' in window.history
1010 | 
1011 |     // Get some pjax state in the history.
1012 |     frame.$.pjax({
1013 |       url: "hello.html",
1014 |       container: "#main",
1015 |     })
1016 |     frame.$("#main").on("pjax:complete", function() {
1017 |       var state = frame.history.state
1018 |       ok(frame.$.pjax.state)
1019 |       if (supportsHistoryState)
1020 |         ok(frame.history.state)
1021 | 
1022 |       // Navigate to a fragment, which will result in a new history entry with
1023 |       // no state object. $.pjax.state remains unchanged however.
1024 |       iframe.src = frame.location.href + '#foo'
1025 |       ok(frame.$.pjax.state)
1026 |       if (supportsHistoryState)
1027 |         ok(!frame.history.state)
1028 | 
1029 |       // Reload the frame. This will clear out $.pjax.state.
1030 |       frame.location.reload()
1031 |       $(iframe).one("load", function() {
1032 |         ok(!frame.$.pjax.state)
1033 |         if (supportsHistoryState)
1034 |           ok(!frame.history.state)
1035 | 
1036 |         // Go back to #main. We'll get a popstate event with a pjax state
1037 |         // object attached from the initial pjax navigation, even though
1038 |         // $.pjax.state is null.
1039 |         window.iframeLoad = function() {
1040 |           ok(frame.$.pjax.state)
1041 |           if (supportsHistoryState) {
1042 |             ok(frame.history.state)
1043 |             equal(frame.$.pjax.state.id, state.id)
1044 |           }
1045 |           start()
1046 |         }
1047 |         frame.history.back()
1048 |       })
1049 |     })
1050 |   })
1051 | 
1052 |   asyncTest("handles going back to page after loading an error page", function() {
1053 |     var frame = this.frame
1054 |     var iframe = this.iframe
1055 | 
1056 |     equal(frame.location.pathname, "/home.html")
1057 |     equal(frame.document.title, "Home")
1058 | 
1059 |     $(iframe).one("load", function() {
1060 | 
1061 |       window.iframeLoad = function() {
1062 |         equal(frame.location.pathname, "/home.html")
1063 |         equal(frame.document.title, "Home")
1064 | 
1065 |         start()
1066 |       }
1067 | 
1068 |       frame.history.back()
1069 |     })
1070 | 
1071 |     frame.$.pjax({
1072 |       url: "boom_sans_pjax.html",
1073 |       container: "#main"
1074 |     })
1075 |   })
1076 | 
1077 |   asyncTest("copes with ampersands when pushing urls", 2, function() {
1078 |     navigate(this.frame)
1079 |     .pjax({ url: "/some-&-path/hello.html", container: "#main" }, function(frame) {
1080 |       equal(frame.location.pathname, "/some-&-path/hello.html")
1081 |       equal(frame.location.search, "")
1082 |     })
1083 |   })
1084 | }
1085 | 


--------------------------------------------------------------------------------
/test/unit/pjax_fallback.js:
--------------------------------------------------------------------------------
  1 | // $.pjax fallback tests should run on both pushState and
  2 | // non-pushState compatible browsers.
  3 | $.each([true, false], function() {
  4 | 
  5 | var disabled = this == false
  6 | var s = disabled ? " (disabled)" : ""
  7 | 
  8 | var ua = navigator.userAgent
  9 | var safari = ua.match("Safari") && !ua.match("Chrome") && !ua.match("Edge")
 10 | var chrome = ua.match("Chrome") && !ua.match("Edge")
 11 | 
 12 | module("$.pjax fallback"+s, {
 13 |   setup: function() {
 14 |     var self = this
 15 |     stop()
 16 |     this.loaded = function(frame) {
 17 |       self.frame  = frame
 18 |       self.loaded = $.noop
 19 |       start()
 20 |     }
 21 |     window.iframeLoad = function(frame) {
 22 |       setTimeout(function() {
 23 |         if (disabled && frame.$ && frame.$.pjax) frame.$.pjax.disable()
 24 |         self.loaded(frame)
 25 |       }, 0)
 26 |     }
 27 |     $("#qunit-fixture").append("<iframe src='home.html'>")
 28 |   },
 29 |   teardown: function() {
 30 |     delete window.iframeLoad
 31 |   }
 32 | })
 33 | 
 34 | 
 35 | asyncTest("sets new url"+s, function() {
 36 |   var frame = this.frame
 37 | 
 38 |   this.loaded = function() {
 39 |     equal(frame.location.pathname, "/hello.html")
 40 |     start()
 41 |   }
 42 | 
 43 |   frame.$.pjax({
 44 |     url: "hello.html",
 45 |     container: "#main"
 46 |   })
 47 | })
 48 | 
 49 | asyncTest("sets new url for function"+s, function() {
 50 |   var frame = this.frame
 51 | 
 52 |   this.loaded = function() {
 53 |     equal(frame.location.pathname, "/hello.html")
 54 |     start()
 55 |   }
 56 | 
 57 |   frame.$.pjax({
 58 |     url: function() { return "hello.html" },
 59 |     container: "#main"
 60 |   })
 61 | })
 62 | 
 63 | asyncTest("updates container html"+s, function() {
 64 |   var frame = this.frame
 65 | 
 66 |   this.loaded = function(frame) {
 67 |     equal(frame.$("#main p").html(), "Hello!")
 68 |     start()
 69 |   }
 70 | 
 71 |   frame.$.pjax({
 72 |     url: "/hello.html",
 73 |     container: "#main"
 74 |   })
 75 | })
 76 | 
 77 | asyncTest("sets title to response <title>"+s, function() {
 78 |   var frame = this.frame
 79 | 
 80 |   this.loaded = function(frame) {
 81 |     equal(frame.document.title, "Hello")
 82 |     start()
 83 |   }
 84 | 
 85 |   frame.$.pjax({
 86 |     url: "/hello.html",
 87 |     container: "#main"
 88 |   })
 89 | })
 90 | 
 91 | asyncTest("sends correct HTTP referer"+s, function() {
 92 |   var frame = this.frame
 93 | 
 94 |   this.loaded = function(frame) {
 95 |     var referer = frame.document.getElementById("referer").textContent
 96 |     ok(referer.match("/home.html"), referer)
 97 |     start()
 98 |   }
 99 | 
100 |   frame.$.pjax({
101 |     url: "/referer.html",
102 |     container: "#main"
103 |   })
104 | })
105 | 
106 | asyncTest("scrolls to top of the page"+s, function() {
107 |   var frame = this.frame
108 | 
109 |   frame.window.scrollTo(0, 100)
110 |   equal(frame.window.pageYOffset, 100)
111 | 
112 |   this.loaded = function(frame) {
113 |     equal(frame.window.pageYOffset, 0)
114 |     start()
115 |   }
116 | 
117 |   frame.$.pjax({
118 |     url: "/long.html",
119 |     container: "#main"
120 |   })
121 | })
122 | 
123 | asyncTest("scrolls to anchor at top page"+s, function() {
124 |   var frame = this.frame
125 | 
126 |   equal(frame.window.pageYOffset, 0)
127 | 
128 |   this.loaded = function(frame) {
129 |     setTimeout(function() {
130 |       equal(frame.location.pathname, "/anchor.html")
131 |       equal(frame.location.hash, "#top")
132 |       equal(frame.window.pageYOffset, 8)
133 |       start()
134 |     }, 100)
135 |   }
136 | 
137 |   frame.$.pjax({
138 |     url: "/anchor.html#top",
139 |     container: "#main"
140 |   })
141 | 
142 |   if (disabled) {
143 |     equal(frame.location.pathname, "/home.html")
144 |     equal(frame.location.href.indexOf("#"), -1)
145 |   } else {
146 |     equal(frame.location.pathname, "/anchor.html")
147 |     equal(frame.location.hash, "#top")
148 |   }
149 | })
150 | 
151 | asyncTest("empty anchor doesn't scroll page"+s, function() {
152 |   var frame = this.frame
153 | 
154 |   equal(frame.window.pageYOffset, 0)
155 | 
156 |   this.loaded = function(frame) {
157 |     setTimeout(function() {
158 |       equal(frame.window.pageYOffset, 0)
159 |       start()
160 |     }, 10)
161 |   }
162 | 
163 |   frame.$.pjax({
164 |     url: "/anchor.html#",
165 |     container: "#main"
166 |   })
167 | })
168 | 
169 | asyncTest("scrolls to anchor at bottom page"+s, function() {
170 |   var frame = this.frame
171 | 
172 |   equal(frame.window.pageYOffset, 0)
173 | 
174 |   this.loaded = function(frame) {
175 |     setTimeout(function() {
176 |       equal(frame.window.pageYOffset, 10008)
177 |       start()
178 |     }, 10)
179 |   }
180 | 
181 |   frame.$.pjax({
182 |     url: "/anchor.html#bottom",
183 |     container: "#main"
184 |   })
185 | })
186 | 
187 | asyncTest("scrolls to named encoded anchor"+s, function() {
188 |   var frame = this.frame
189 | 
190 |   equal(frame.window.pageYOffset, 0)
191 | 
192 |   this.loaded = function(frame) {
193 |     setTimeout(function() {
194 |       equal(frame.window.pageYOffset, 10008)
195 |       start()
196 |     }, 10)
197 |   }
198 | 
199 |   frame.$.pjax({
200 |     url: "/anchor.html#%62%6F%74%74%6F%6D",
201 |     container: "#main"
202 |   })
203 | })
204 | 
205 | asyncTest("sets GET method"+s, function() {
206 |   var frame = this.frame
207 | 
208 |   this.loaded = function() {
209 |     equal(frame.location.pathname, "/env.html")
210 |     var env = JSON.parse(frame.$("#env").text())
211 |     equal(env['REQUEST_METHOD'], "GET")
212 |     start()
213 |   }
214 | 
215 |   frame.$.pjax({
216 |     type: 'GET',
217 |     url: "env.html",
218 |     container: "#main"
219 |   })
220 | })
221 | 
222 | 
223 | asyncTest("sets POST method"+s, function() {
224 |   var frame = this.frame
225 | 
226 |   this.loaded = function() {
227 |     equal(frame.location.pathname, "/env.html")
228 |     var env = JSON.parse(frame.$("#env").text())
229 |     equal(env['REQUEST_METHOD'], "POST")
230 |     start()
231 |   }
232 | 
233 |   frame.$.pjax({
234 |     type: 'POST',
235 |     url: "env.html",
236 |     container: "#main"
237 |   })
238 | })
239 | 
240 | asyncTest("sets PUT method"+s, function() {
241 |   var frame = this.frame
242 | 
243 |   this.loaded = function() {
244 |     equal(frame.location.pathname, "/env.html")
245 |     var env = JSON.parse(frame.$("#env").text())
246 |     equal(env['REQUEST_METHOD'], "PUT")
247 |     start()
248 |   }
249 | 
250 |   frame.$.pjax({
251 |     type: 'PUT',
252 |     url: "env.html",
253 |     container: "#main"
254 |   })
255 | })
256 | 
257 | asyncTest("sets DELETE method"+s, function() {
258 |   var frame = this.frame
259 | 
260 |   this.loaded = function() {
261 |     equal(frame.location.pathname, "/env.html")
262 |     var env = JSON.parse(frame.$("#env").text())
263 |     equal(env['REQUEST_METHOD'], "DELETE")
264 |     start()
265 |   }
266 | 
267 |   frame.$.pjax({
268 |     type: 'DELETE',
269 |     url: "env.html",
270 |     container: "#main"
271 |   })
272 | })
273 | 
274 | 
275 | asyncTest("GET with data object"+s, function() {
276 |   var frame = this.frame
277 | 
278 |   this.loaded = function() {
279 |     equal(frame.location.pathname, "/env.html")
280 |     equal(frame.location.search, "?foo=bar")
281 | 
282 |     var env = JSON.parse(frame.$("#env").text())
283 |     equal(env['REQUEST_METHOD'], "GET")
284 |     equal(env['rack.request.query_hash']['foo'], 'bar')
285 | 
286 |     start()
287 |   }
288 | 
289 |   frame.$.pjax({
290 |     type: 'GET',
291 |     url: "env.html",
292 |     data: {foo: 'bar'},
293 |     container: "#main"
294 |   })
295 | })
296 | 
297 | asyncTest("POST with data object"+s, function() {
298 |   var frame = this.frame
299 | 
300 |   this.loaded = function() {
301 |     equal(frame.location.pathname, "/env.html")
302 |     equal(frame.location.search, "")
303 | 
304 |     var env = JSON.parse(frame.$("#env").text())
305 |     equal(env['REQUEST_METHOD'], "POST")
306 |     equal(env['rack.request.form_hash']['foo'], 'bar')
307 | 
308 |     start()
309 |   }
310 | 
311 |   frame.$.pjax({
312 |     type: 'POST',
313 |     url: "env.html",
314 |     data: {foo: 'bar'},
315 |     container: "#main"
316 |   })
317 | })
318 | 
319 | asyncTest("GET with data array"+s, function() {
320 |   var frame = this.frame
321 | 
322 |   this.loaded = function() {
323 |     equal(frame.location.pathname, "/env.html")
324 |     equal(frame.location.search, "?foo%5B%5D=bar&foo%5B%5D=baz")
325 | 
326 |     var env = JSON.parse(frame.$("#env").text())
327 |     equal(env['REQUEST_METHOD'], "GET")
328 |     var expected = {'foo': ['bar', 'baz']}
329 |     if (!disabled) expected._pjax = "#main"
330 |     deepEqual(env['rack.request.query_hash'], expected)
331 | 
332 |     start()
333 |   }
334 | 
335 |   frame.$.pjax({
336 |     type: 'GET',
337 |     url: "env.html",
338 |     data: [{name: "foo[]", value: "bar"}, {name: "foo[]", value: "baz"}],
339 |     container: "#main"
340 |   })
341 | })
342 | 
343 | asyncTest("POST with data array"+s, function() {
344 |   var frame = this.frame
345 | 
346 |   this.loaded = function() {
347 |     equal(frame.location.pathname, "/env.html")
348 |     equal(frame.location.search, "")
349 | 
350 |     var env = JSON.parse(frame.$("#env").text())
351 |     equal(env['REQUEST_METHOD'], "POST")
352 |     var expected = {'foo': ['bar', 'baz']}
353 |     if (!disabled) expected._pjax = "#main"
354 |     deepEqual(env['rack.request.form_hash'], expected)
355 | 
356 |     start()
357 |   }
358 | 
359 |   frame.$.pjax({
360 |     type: 'POST',
361 |     url: "env.html",
362 |     data: [{name: "foo[]", value: "bar"}, {name: "foo[]", value: "baz"}],
363 |     container: "#main"
364 |   })
365 | })
366 | 
367 | asyncTest("GET with data string"+s, function() {
368 |   var frame = this.frame
369 | 
370 |   this.loaded = function() {
371 |     equal(frame.location.pathname, "/env.html")
372 |     equal(frame.location.search, "?foo=bar")
373 | 
374 |     var env = JSON.parse(frame.$("#env").text())
375 |     equal(env['REQUEST_METHOD'], "GET")
376 |     equal(env['rack.request.query_hash']['foo'], 'bar')
377 | 
378 |     start()
379 |   }
380 | 
381 |   frame.$.pjax({
382 |     type: 'GET',
383 |     url: "env.html",
384 |     data: "foo=bar",
385 |     container: "#main"
386 |   })
387 | })
388 | 
389 | asyncTest("POST with data string"+s, function() {
390 |   var frame = this.frame
391 | 
392 |   this.loaded = function() {
393 |     equal(frame.location.pathname, "/env.html")
394 |     equal(frame.location.search, "")
395 | 
396 |     var env = JSON.parse(frame.$("#env").text())
397 |     equal(env['REQUEST_METHOD'], "POST")
398 |     equal(env['rack.request.form_hash']['foo'], 'bar')
399 | 
400 |     start()
401 |   }
402 | 
403 |   frame.$.pjax({
404 |     type: 'POST',
405 |     url: "env.html",
406 |     data: "foo=bar",
407 |     container: "#main"
408 |   })
409 | })
410 | 
411 | asyncTest("handle form submit"+s, function() {
412 |   var frame = this.frame
413 | 
414 |   frame.$(frame.document).on("submit", "form", function(event) {
415 |     frame.$.pjax.submit(event, "#main")
416 |   })
417 | 
418 |   this.loaded = function() {
419 |     var env = JSON.parse(frame.$("#env").text())
420 |     var expected = {foo: "1", bar: "2"}
421 |     if (!disabled) expected._pjax = "#main"
422 |     deepEqual(env['rack.request.query_hash'], expected)
423 |     start()
424 |   }
425 | 
426 |   frame.$("form").submit()
427 | })
428 | 
429 | asyncTest("browser URL is correct after redirect"+s, function() {
430 |   var frame = this.frame
431 | 
432 |   this.loaded = function() {
433 |     equal(frame.location.pathname, "/hello.html")
434 |     var expectedHash = safari && disabled ? "" : "#new"
435 |     equal(frame.location.hash, expectedHash)
436 |     start()
437 |   }
438 | 
439 |   frame.$.pjax({
440 |     url: "redirect.html#new",
441 |     container: "#main"
442 |   })
443 | })
444 | 
445 | asyncTest("server can't affect anchor after redirect"+s, function() {
446 |   var frame = this.frame
447 | 
448 |   this.loaded = function() {
449 |     equal(frame.location.pathname, "/hello.html")
450 |     var expectedHash = safari && disabled ? "" : "#new"
451 |     equal(frame.location.hash, expectedHash)
452 |     start()
453 |   }
454 | 
455 |   frame.$.pjax({
456 |     url: "redirect.html?anchor=server#new",
457 |     container: "#main"
458 |   })
459 | })
460 | 
461 | })
462 | 


--------------------------------------------------------------------------------
/test/views/aliens.erb:
--------------------------------------------------------------------------------
 1 | <%= title 'aliens' %>
 2 | 
 3 | <ul>
 4 |   <li><a href="/home.html">home</a></li>
 5 |   <li><a href="/dinosaurs.html">dinosaurs</a></li>
 6 |   <li>aliens</li>
 7 | </ul>
 8 | 
 9 | <img src="/img/aliens.jpg" title="aliens">
10 | 
11 | <script type="text/javascript">window.parent.iframeLoad(window)</script>
12 | 


--------------------------------------------------------------------------------
/test/views/anchor.erb:
--------------------------------------------------------------------------------
1 | <%= title 'Anchor' %>
2 | <div id="top" style="width:500px;height:10000px;"></div>
3 | <a name="bottom" style="width:500px;height:10000px;display:block;"></a>
4 | <script type="text/javascript">window.parent.iframeLoad(window)</script>
5 | 


--------------------------------------------------------------------------------
/test/views/boom.erb:
--------------------------------------------------------------------------------
1 | <p>500</p>
2 | 


--------------------------------------------------------------------------------
/test/views/boom_sans_pjax.erb:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | <head>
 4 |   <meta charset="utf-8">
 5 |   <title>500 sans pjax</title>
 6 | </head>
 7 | <body>
 8 |   <div id="main">
 9 |     <p>500 sans pjax</p>
10 |   </div>
11 | </body>
12 | </html>
13 | 


--------------------------------------------------------------------------------
/test/views/dinosaurs.erb:
--------------------------------------------------------------------------------
 1 | <%= title 'dinosaurs' %>
 2 | 
 3 | <ul>
 4 |   <li><a href="/home.html">home</a></li>
 5 |   <li>dinosaurs</li>
 6 |   <li><a href="/aliens.html">aliens</a></li>
 7 | </ul>
 8 | 
 9 | <iframe title="YouTube video player" width="480" height="390" src="http://www.youtube.com/embed/GcjxwXCxBBU" frameborder="0" allowfullscreen></iframe>
10 | 
11 | <script type="text/javascript">window.parent.iframeLoad(window)</script>
12 | 


--------------------------------------------------------------------------------
/test/views/double_title.erb:
--------------------------------------------------------------------------------
1 | <%= title 'Hello' %>
2 | <p><title>World!</title> Hello!</p>
3 | <script type="text/javascript">window.parent.iframeLoad(window)</script>
4 | 


--------------------------------------------------------------------------------
/test/views/empty.erb:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/defunkt/jquery-pjax/153262eda33e31119eabb97cd5f14365580a3b35/test/views/empty.erb


--------------------------------------------------------------------------------
/test/views/env.erb:
--------------------------------------------------------------------------------
1 | <div id="env"><%= Rack::Utils.escape_html JSON.generate(request.env) %></div>
2 | <script type="text/javascript">window.parent.iframeLoad(window)</script>
3 | 


--------------------------------------------------------------------------------
/test/views/fragment.erb:
--------------------------------------------------------------------------------
1 | <div id="foo" title="Foo">
2 |   <p>Foo</p>
3 | </div>
4 | 
5 | <div id="bar" data-title="Bar">
6 |   <p>Bar</p>
7 | </div>
8 | 


--------------------------------------------------------------------------------
/test/views/hello.erb:
--------------------------------------------------------------------------------
1 | <%= title 'Hello' %>
2 | <p>Hello!</p>
3 | How's it going?
4 | <script type="text/javascript">window.parent.iframeLoad(window)</script>
5 | 


--------------------------------------------------------------------------------
/test/views/home.erb:
--------------------------------------------------------------------------------
 1 | <%= title 'Home' %>
 2 | 
 3 | <ul>
 4 |   <li>home</li>
 5 |   <li><a href="/dinosaurs.html">dinosaurs</a></li>
 6 |   <li><a href="/aliens.html">aliens</a></li>
 7 |   <li><a href="https://www.google.com/">Google</a></li>
 8 |   <li><a href="#main">Main</a></li>
 9 |   <li><a href="#">Empty</a></li>
10 | </ul>
11 | 
12 | <form action="env.html" method="GET">
13 |   <input name="foo" value="1">
14 |   <input name="bar" value="2">
15 | </form>
16 | 
17 | <div style="width:500px;height:10000px;"></div>
18 | 
19 | <script type="text/javascript">window.parent.iframeLoad(window)</script>
20 | 


--------------------------------------------------------------------------------
/test/views/layout.erb:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | <head>
 4 |   <meta charset="utf-8">
 5 |   <title><%= @title %></title>
 6 |   <script type="text/javascript" src="/vendor/jquery-<%= jquery_version %>.js"></script>
 7 |   <script type="text/javascript" src="/jquery.pjax.js"></script>
 8 | </head>
 9 | <body>
10 |   <div id="main">
11 |     <%= yield %>
12 |   </div>
13 | </body>
14 | </html>
15 | 


--------------------------------------------------------------------------------
/test/views/long.erb:
--------------------------------------------------------------------------------
1 | <%= title 'Long' %>
2 | <p>Long Page</p>
3 | <div style="width:500px;height:10000px;"></div>
4 | <script type="text/javascript">window.parent.iframeLoad(window)</script>
5 | 


--------------------------------------------------------------------------------
/test/views/nested_title.erb:
--------------------------------------------------------------------------------
1 | <p><%= title 'Hello' %> Hello!</p>
2 | <script type="text/javascript">window.parent.iframeLoad(window)</script>
3 | 


--------------------------------------------------------------------------------
/test/views/qunit.erb:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | <head>
 4 |   <meta charset="utf-8">
 5 |   <link rel="stylesheet" href="/vendor/qunit.css">
 6 |   <meta name="viewport" content="initial-scale=1.0,width=device-width">
 7 | 
 8 |   <script type="text/javascript" src="/vendor/jquery-<%= jquery_version %>.js"></script>
 9 |   <script type="text/javascript" src="/vendor/qunit.js"></script>
10 |   <script type="text/javascript">QUnit.config.testTimeout = 2000</script>
11 |   <script type="text/javascript" src="/jquery.pjax.js"></script>
12 |   <script type="text/javascript" src="/test/unit/helpers.js"></script>
13 |   <script type="text/javascript" src="/test/unit/pjax.js"></script>
14 |   <script type="text/javascript" src="/test/unit/fn_pjax.js"></script>
15 |   <script type="text/javascript" src="/test/unit/pjax_fallback.js"></script>
16 | </head>
17 | <body>
18 |   <div id="qunit"></div>
19 |   <ol id="qunit-fixture"></ol>
20 | </body>
21 | </html>
22 | 


--------------------------------------------------------------------------------
/test/views/referer.erb:
--------------------------------------------------------------------------------
1 | <p id="referer"><%= request.referer %></p>
2 | <script type="text/javascript">window.parent.iframeLoad(window)</script>
3 | 


--------------------------------------------------------------------------------
/test/views/scripts.erb:
--------------------------------------------------------------------------------
1 | <p>Got some script tags here</p>
2 | <script type="text/javascript" src="/test/evaled.js?1"></script>
3 | <script src="/test/evaled.js?2"></script>
4 | <script type="text/javascript">
5 |   window.evaledInlineLog = window.evaledInlineLog || []
6 |   window.evaledInlineLog.push('<%= params[:name] %>')
7 | </script>
8 | <script type="text/javascript">window.parent.iframeLoad(window)</script>
9 | 


--------------------------------------------------------------------------------
/test/views/timeout.erb:
--------------------------------------------------------------------------------
1 | <%= title 'Timeout!' %>
2 | 
3 | <p>SLOW DOWN!</p>
4 | 
5 | <script type="text/javascript">window.parent.iframeLoad(window)</script>
6 | 


--------------------------------------------------------------------------------
/vendor/qunit.css:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * QUnit v1.11.0 - A JavaScript Unit Testing Framework
  3 |  *
  4 |  * http://qunitjs.com
  5 |  *
  6 |  * Copyright 2012 jQuery Foundation and other contributors
  7 |  * Released under the MIT license.
  8 |  * http://jquery.org/license
  9 |  */
 10 | 
 11 | /** Font Family and Sizes */
 12 | 
 13 | #qunit-tests, #qunit-header, #qunit-banner, #qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult {
 14 | 	font-family: "Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial, sans-serif;
 15 | }
 16 | 
 17 | #qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult, #qunit-tests li { font-size: small; }
 18 | #qunit-tests { font-size: smaller; }
 19 | 
 20 | 
 21 | /** Resets */
 22 | 
 23 | #qunit-tests, #qunit-header, #qunit-banner, #qunit-userAgent, #qunit-testresult, #qunit-modulefilter {
 24 | 	margin: 0;
 25 | 	padding: 0;
 26 | }
 27 | 
 28 | 
 29 | /** Header */
 30 | 
 31 | #qunit-header {
 32 | 	padding: 0.5em 0 0.5em 1em;
 33 | 
 34 | 	color: #8699a4;
 35 | 	background-color: #0d3349;
 36 | 
 37 | 	font-size: 1.5em;
 38 | 	line-height: 1em;
 39 | 	font-weight: normal;
 40 | 
 41 | 	border-radius: 5px 5px 0 0;
 42 | 	-moz-border-radius: 5px 5px 0 0;
 43 | 	-webkit-border-top-right-radius: 5px;
 44 | 	-webkit-border-top-left-radius: 5px;
 45 | }
 46 | 
 47 | #qunit-header a {
 48 | 	text-decoration: none;
 49 | 	color: #c2ccd1;
 50 | }
 51 | 
 52 | #qunit-header a:hover,
 53 | #qunit-header a:focus {
 54 | 	color: #fff;
 55 | }
 56 | 
 57 | #qunit-testrunner-toolbar label {
 58 | 	display: inline-block;
 59 | 	padding: 0 .5em 0 .1em;
 60 | }
 61 | 
 62 | #qunit-banner {
 63 | 	height: 5px;
 64 | }
 65 | 
 66 | #qunit-testrunner-toolbar {
 67 | 	padding: 0.5em 0 0.5em 2em;
 68 | 	color: #5E740B;
 69 | 	background-color: #eee;
 70 | 	overflow: hidden;
 71 | }
 72 | 
 73 | #qunit-userAgent {
 74 | 	padding: 0.5em 0 0.5em 2.5em;
 75 | 	background-color: #2b81af;
 76 | 	color: #fff;
 77 | 	text-shadow: rgba(0, 0, 0, 0.5) 2px 2px 1px;
 78 | }
 79 | 
 80 | #qunit-modulefilter-container {
 81 | 	float: right;
 82 | }
 83 | 
 84 | /** Tests: Pass/Fail */
 85 | 
 86 | #qunit-tests {
 87 | 	list-style-position: inside;
 88 | }
 89 | 
 90 | #qunit-tests li {
 91 | 	padding: 0.4em 0.5em 0.4em 2.5em;
 92 | 	border-bottom: 1px solid #fff;
 93 | 	list-style-position: inside;
 94 | }
 95 | 
 96 | #qunit-tests.hidepass li.pass, #qunit-tests.hidepass li.running  {
 97 | 	display: none;
 98 | }
 99 | 
100 | #qunit-tests li strong {
101 | 	cursor: pointer;
102 | }
103 | 
104 | #qunit-tests li a {
105 | 	padding: 0.5em;
106 | 	color: #c2ccd1;
107 | 	text-decoration: none;
108 | }
109 | #qunit-tests li a:hover,
110 | #qunit-tests li a:focus {
111 | 	color: #000;
112 | }
113 | 
114 | #qunit-tests li .runtime {
115 | 	float: right;
116 | 	font-size: smaller;
117 | }
118 | 
119 | .qunit-assert-list {
120 | 	margin-top: 0.5em;
121 | 	padding: 0.5em;
122 | 
123 | 	background-color: #fff;
124 | 
125 | 	border-radius: 5px;
126 | 	-moz-border-radius: 5px;
127 | 	-webkit-border-radius: 5px;
128 | }
129 | 
130 | .qunit-collapsed {
131 | 	display: none;
132 | }
133 | 
134 | #qunit-tests table {
135 | 	border-collapse: collapse;
136 | 	margin-top: .2em;
137 | }
138 | 
139 | #qunit-tests th {
140 | 	text-align: right;
141 | 	vertical-align: top;
142 | 	padding: 0 .5em 0 0;
143 | }
144 | 
145 | #qunit-tests td {
146 | 	vertical-align: top;
147 | }
148 | 
149 | #qunit-tests pre {
150 | 	margin: 0;
151 | 	white-space: pre-wrap;
152 | 	word-wrap: break-word;
153 | }
154 | 
155 | #qunit-tests del {
156 | 	background-color: #e0f2be;
157 | 	color: #374e0c;
158 | 	text-decoration: none;
159 | }
160 | 
161 | #qunit-tests ins {
162 | 	background-color: #ffcaca;
163 | 	color: #500;
164 | 	text-decoration: none;
165 | }
166 | 
167 | /*** Test Counts */
168 | 
169 | #qunit-tests b.counts                       { color: black; }
170 | #qunit-tests b.passed                       { color: #5E740B; }
171 | #qunit-tests b.failed                       { color: #710909; }
172 | 
173 | #qunit-tests li li {
174 | 	padding: 5px;
175 | 	background-color: #fff;
176 | 	border-bottom: none;
177 | 	list-style-position: inside;
178 | }
179 | 
180 | /*** Passing Styles */
181 | 
182 | #qunit-tests li li.pass {
183 | 	color: #3c510c;
184 | 	background-color: #fff;
185 | 	border-left: 10px solid #C6E746;
186 | }
187 | 
188 | #qunit-tests .pass                          { color: #528CE0; background-color: #D2E0E6; }
189 | #qunit-tests .pass .test-name               { color: #366097; }
190 | 
191 | #qunit-tests .pass .test-actual,
192 | #qunit-tests .pass .test-expected           { color: #999999; }
193 | 
194 | #qunit-banner.qunit-pass                    { background-color: #C6E746; }
195 | 
196 | /*** Failing Styles */
197 | 
198 | #qunit-tests li li.fail {
199 | 	color: #710909;
200 | 	background-color: #fff;
201 | 	border-left: 10px solid #EE5757;
202 | 	white-space: pre;
203 | }
204 | 
205 | #qunit-tests > li:last-child {
206 | 	border-radius: 0 0 5px 5px;
207 | 	-moz-border-radius: 0 0 5px 5px;
208 | 	-webkit-border-bottom-right-radius: 5px;
209 | 	-webkit-border-bottom-left-radius: 5px;
210 | }
211 | 
212 | #qunit-tests .fail                          { color: #000000; background-color: #EE5757; }
213 | #qunit-tests .fail .test-name,
214 | #qunit-tests .fail .module-name             { color: #000000; }
215 | 
216 | #qunit-tests .fail .test-actual             { color: #EE5757; }
217 | #qunit-tests .fail .test-expected           { color: green;   }
218 | 
219 | #qunit-banner.qunit-fail                    { background-color: #EE5757; }
220 | 
221 | 
222 | /** Result */
223 | 
224 | #qunit-testresult {
225 | 	padding: 0.5em 0.5em 0.5em 2.5em;
226 | 
227 | 	color: #2b81af;
228 | 	background-color: #D2E0E6;
229 | 
230 | 	border-bottom: 1px solid white;
231 | }
232 | #qunit-testresult .module-name {
233 | 	font-weight: bold;
234 | }
235 | 
236 | /** Fixture */
237 | 
238 | #qunit-fixture {
239 | 	position: absolute;
240 | 	top: -10000px;
241 | 	left: -10000px;
242 | 	width: 1000px;
243 | 	height: 1000px;
244 | }
245 | 


--------------------------------------------------------------------------------
/vendor/qunit.js:
--------------------------------------------------------------------------------
   1 | /**
   2 |  * QUnit v1.11.0 - A JavaScript Unit Testing Framework
   3 |  *
   4 |  * http://qunitjs.com
   5 |  *
   6 |  * Copyright 2012 jQuery Foundation and other contributors
   7 |  * Released under the MIT license.
   8 |  * http://jquery.org/license
   9 |  */
  10 | 
  11 | (function( window ) {
  12 | 
  13 | var QUnit,
  14 | 	assert,
  15 | 	config,
  16 | 	onErrorFnPrev,
  17 | 	testId = 0,
  18 | 	fileName = (sourceFromStacktrace( 0 ) || "" ).replace(/(:\d+)+\)?/, "").replace(/.+\//, ""),
  19 | 	toString = Object.prototype.toString,
  20 | 	hasOwn = Object.prototype.hasOwnProperty,
  21 | 	// Keep a local reference to Date (GH-283)
  22 | 	Date = window.Date,
  23 | 	defined = {
  24 | 		setTimeout: typeof window.setTimeout !== "undefined",
  25 | 		sessionStorage: (function() {
  26 | 			var x = "qunit-test-string";
  27 | 			try {
  28 | 				sessionStorage.setItem( x, x );
  29 | 				sessionStorage.removeItem( x );
  30 | 				return true;
  31 | 			} catch( e ) {
  32 | 				return false;
  33 | 			}
  34 | 		}())
  35 | 	},
  36 | 	/**
  37 | 	 * Provides a normalized error string, correcting an issue
  38 | 	 * with IE 7 (and prior) where Error.prototype.toString is
  39 | 	 * not properly implemented
  40 | 	 *
  41 | 	 * Based on http://es5.github.com/#x15.11.4.4
  42 | 	 *
  43 | 	 * @param {String|Error} error
  44 | 	 * @return {String} error message
  45 | 	 */
  46 | 	errorString = function( error ) {
  47 | 		var name, message,
  48 | 			errorString = error.toString();
  49 | 		if ( errorString.substring( 0, 7 ) === "[object" ) {
  50 | 			name = error.name ? error.name.toString() : "Error";
  51 | 			message = error.message ? error.message.toString() : "";
  52 | 			if ( name && message ) {
  53 | 				return name + ": " + message;
  54 | 			} else if ( name ) {
  55 | 				return name;
  56 | 			} else if ( message ) {
  57 | 				return message;
  58 | 			} else {
  59 | 				return "Error";
  60 | 			}
  61 | 		} else {
  62 | 			return errorString;
  63 | 		}
  64 | 	},
  65 | 	/**
  66 | 	 * Makes a clone of an object using only Array or Object as base,
  67 | 	 * and copies over the own enumerable properties.
  68 | 	 *
  69 | 	 * @param {Object} obj
  70 | 	 * @return {Object} New object with only the own properties (recursively).
  71 | 	 */
  72 | 	objectValues = function( obj ) {
  73 | 		// Grunt 0.3.x uses an older version of jshint that still has jshint/jshint#392.
  74 | 		/*jshint newcap: false */
  75 | 		var key, val,
  76 | 			vals = QUnit.is( "array", obj ) ? [] : {};
  77 | 		for ( key in obj ) {
  78 | 			if ( hasOwn.call( obj, key ) ) {
  79 | 				val = obj[key];
  80 | 				vals[key] = val === Object(val) ? objectValues(val) : val;
  81 | 			}
  82 | 		}
  83 | 		return vals;
  84 | 	};
  85 | 
  86 | function Test( settings ) {
  87 | 	extend( this, settings );
  88 | 	this.assertions = [];
  89 | 	this.testNumber = ++Test.count;
  90 | }
  91 | 
  92 | Test.count = 0;
  93 | 
  94 | Test.prototype = {
  95 | 	init: function() {
  96 | 		var a, b, li,
  97 | 			tests = id( "qunit-tests" );
  98 | 
  99 | 		if ( tests ) {
 100 | 			b = document.createElement( "strong" );
 101 | 			b.innerHTML = this.nameHtml;
 102 | 
 103 | 			// `a` initialized at top of scope
 104 | 			a = document.createElement( "a" );
 105 | 			a.innerHTML = "Rerun";
 106 | 			a.href = QUnit.url({ testNumber: this.testNumber });
 107 | 
 108 | 			li = document.createElement( "li" );
 109 | 			li.appendChild( b );
 110 | 			li.appendChild( a );
 111 | 			li.className = "running";
 112 | 			li.id = this.id = "qunit-test-output" + testId++;
 113 | 
 114 | 			tests.appendChild( li );
 115 | 		}
 116 | 	},
 117 | 	setup: function() {
 118 | 		if ( this.module !== config.previousModule ) {
 119 | 			if ( config.previousModule ) {
 120 | 				runLoggingCallbacks( "moduleDone", QUnit, {
 121 | 					name: config.previousModule,
 122 | 					failed: config.moduleStats.bad,
 123 | 					passed: config.moduleStats.all - config.moduleStats.bad,
 124 | 					total: config.moduleStats.all
 125 | 				});
 126 | 			}
 127 | 			config.previousModule = this.module;
 128 | 			config.moduleStats = { all: 0, bad: 0 };
 129 | 			runLoggingCallbacks( "moduleStart", QUnit, {
 130 | 				name: this.module
 131 | 			});
 132 | 		} else if ( config.autorun ) {
 133 | 			runLoggingCallbacks( "moduleStart", QUnit, {
 134 | 				name: this.module
 135 | 			});
 136 | 		}
 137 | 
 138 | 		config.current = this;
 139 | 
 140 | 		this.testEnvironment = extend({
 141 | 			setup: function() {},
 142 | 			teardown: function() {}
 143 | 		}, this.moduleTestEnvironment );
 144 | 
 145 | 		this.started = +new Date();
 146 | 		runLoggingCallbacks( "testStart", QUnit, {
 147 | 			name: this.testName,
 148 | 			module: this.module
 149 | 		});
 150 | 
 151 | 		// allow utility functions to access the current test environment
 152 | 		// TODO why??
 153 | 		QUnit.current_testEnvironment = this.testEnvironment;
 154 | 
 155 | 		if ( !config.pollution ) {
 156 | 			saveGlobal();
 157 | 		}
 158 | 		if ( config.notrycatch ) {
 159 | 			this.testEnvironment.setup.call( this.testEnvironment );
 160 | 			return;
 161 | 		}
 162 | 		try {
 163 | 			this.testEnvironment.setup.call( this.testEnvironment );
 164 | 		} catch( e ) {
 165 | 			QUnit.pushFailure( "Setup failed on " + this.testName + ": " + ( e.message || e ), extractStacktrace( e, 1 ) );
 166 | 		}
 167 | 	},
 168 | 	run: function() {
 169 | 		config.current = this;
 170 | 
 171 | 		var running = id( "qunit-testresult" );
 172 | 
 173 | 		if ( running ) {
 174 | 			running.innerHTML = "Running: <br/>" + this.nameHtml;
 175 | 		}
 176 | 
 177 | 		if ( this.async ) {
 178 | 			QUnit.stop();
 179 | 		}
 180 | 
 181 | 		this.callbackStarted = +new Date();
 182 | 
 183 | 		if ( config.notrycatch ) {
 184 | 			this.callback.call( this.testEnvironment, QUnit.assert );
 185 | 			this.callbackRuntime = +new Date() - this.callbackStarted;
 186 | 			return;
 187 | 		}
 188 | 
 189 | 		try {
 190 | 			this.callback.call( this.testEnvironment, QUnit.assert );
 191 | 			this.callbackRuntime = +new Date() - this.callbackStarted;
 192 | 		} catch( e ) {
 193 | 			this.callbackRuntime = +new Date() - this.callbackStarted;
 194 | 
 195 | 			QUnit.pushFailure( "Died on test #" + (this.assertions.length + 1) + " " + this.stack + ": " + ( e.message || e ), extractStacktrace( e, 0 ) );
 196 | 			// else next test will carry the responsibility
 197 | 			saveGlobal();
 198 | 
 199 | 			// Restart the tests if they're blocking
 200 | 			if ( config.blocking ) {
 201 | 				QUnit.start();
 202 | 			}
 203 | 		}
 204 | 	},
 205 | 	teardown: function() {
 206 | 		config.current = this;
 207 | 		if ( config.notrycatch ) {
 208 | 			if ( typeof this.callbackRuntime === "undefined" ) {
 209 | 				this.callbackRuntime = +new Date() - this.callbackStarted;
 210 | 			}
 211 | 			this.testEnvironment.teardown.call( this.testEnvironment );
 212 | 			return;
 213 | 		} else {
 214 | 			try {
 215 | 				this.testEnvironment.teardown.call( this.testEnvironment );
 216 | 			} catch( e ) {
 217 | 				QUnit.pushFailure( "Teardown failed on " + this.testName + ": " + ( e.message || e ), extractStacktrace( e, 1 ) );
 218 | 			}
 219 | 		}
 220 | 		checkPollution();
 221 | 	},
 222 | 	finish: function() {
 223 | 		config.current = this;
 224 | 		if ( config.requireExpects && this.expected === null ) {
 225 | 			QUnit.pushFailure( "Expected number of assertions to be defined, but expect() was not called.", this.stack );
 226 | 		} else if ( this.expected !== null && this.expected !== this.assertions.length ) {
 227 | 			QUnit.pushFailure( "Expected " + this.expected + " assertions, but " + this.assertions.length + " were run", this.stack );
 228 | 		} else if ( this.expected === null && !this.assertions.length ) {
 229 | 			QUnit.pushFailure( "Expected at least one assertion, but none were run - call expect(0) to accept zero assertions.", this.stack );
 230 | 		}
 231 | 
 232 | 		var i, assertion, a, b, time, li, ol,
 233 | 			test = this,
 234 | 			good = 0,
 235 | 			bad = 0,
 236 | 			tests = id( "qunit-tests" );
 237 | 
 238 | 		this.runtime = +new Date() - this.started;
 239 | 		config.stats.all += this.assertions.length;
 240 | 		config.moduleStats.all += this.assertions.length;
 241 | 
 242 | 		if ( tests ) {
 243 | 			ol = document.createElement( "ol" );
 244 | 			ol.className = "qunit-assert-list";
 245 | 
 246 | 			for ( i = 0; i < this.assertions.length; i++ ) {
 247 | 				assertion = this.assertions[i];
 248 | 
 249 | 				li = document.createElement( "li" );
 250 | 				li.className = assertion.result ? "pass" : "fail";
 251 | 				li.innerHTML = assertion.message || ( assertion.result ? "okay" : "failed" );
 252 | 				ol.appendChild( li );
 253 | 
 254 | 				if ( assertion.result ) {
 255 | 					good++;
 256 | 				} else {
 257 | 					bad++;
 258 | 					config.stats.bad++;
 259 | 					config.moduleStats.bad++;
 260 | 				}
 261 | 			}
 262 | 
 263 | 			// store result when possible
 264 | 			if ( QUnit.config.reorder && defined.sessionStorage ) {
 265 | 				if ( bad ) {
 266 | 					sessionStorage.setItem( "qunit-test-" + this.module + "-" + this.testName, bad );
 267 | 				} else {
 268 | 					sessionStorage.removeItem( "qunit-test-" + this.module + "-" + this.testName );
 269 | 				}
 270 | 			}
 271 | 
 272 | 			if ( bad === 0 ) {
 273 | 				addClass( ol, "qunit-collapsed" );
 274 | 			}
 275 | 
 276 | 			// `b` initialized at top of scope
 277 | 			b = document.createElement( "strong" );
 278 | 			b.innerHTML = this.nameHtml + " <b class='counts'>(<b class='failed'>" + bad + "</b>, <b class='passed'>" + good + "</b>, " + this.assertions.length + ")</b>";
 279 | 
 280 | 			addEvent(b, "click", function() {
 281 | 				var next = b.parentNode.lastChild,
 282 | 					collapsed = hasClass( next, "qunit-collapsed" );
 283 | 				( collapsed ? removeClass : addClass )( next, "qunit-collapsed" );
 284 | 			});
 285 | 
 286 | 			addEvent(b, "dblclick", function( e ) {
 287 | 				var target = e && e.target ? e.target : window.event.srcElement;
 288 | 				if ( target.nodeName.toLowerCase() === "span" || target.nodeName.toLowerCase() === "b" ) {
 289 | 					target = target.parentNode;
 290 | 				}
 291 | 				if ( window.location && target.nodeName.toLowerCase() === "strong" ) {
 292 | 					window.location = QUnit.url({ testNumber: test.testNumber });
 293 | 				}
 294 | 			});
 295 | 
 296 | 			// `time` initialized at top of scope
 297 | 			time = document.createElement( "span" );
 298 | 			time.className = "runtime";
 299 | 			time.innerHTML = this.runtime + " ms";
 300 | 
 301 | 			// `li` initialized at top of scope
 302 | 			li = id( this.id );
 303 | 			li.className = bad ? "fail" : "pass";
 304 | 			li.removeChild( li.firstChild );
 305 | 			a = li.firstChild;
 306 | 			li.appendChild( b );
 307 | 			li.appendChild( a );
 308 | 			li.appendChild( time );
 309 | 			li.appendChild( ol );
 310 | 
 311 | 		} else {
 312 | 			for ( i = 0; i < this.assertions.length; i++ ) {
 313 | 				if ( !this.assertions[i].result ) {
 314 | 					bad++;
 315 | 					config.stats.bad++;
 316 | 					config.moduleStats.bad++;
 317 | 				}
 318 | 			}
 319 | 		}
 320 | 
 321 | 		runLoggingCallbacks( "testDone", QUnit, {
 322 | 			name: this.testName,
 323 | 			module: this.module,
 324 | 			failed: bad,
 325 | 			passed: this.assertions.length - bad,
 326 | 			total: this.assertions.length,
 327 | 			duration: this.runtime
 328 | 		});
 329 | 
 330 | 		QUnit.reset();
 331 | 
 332 | 		config.current = undefined;
 333 | 	},
 334 | 
 335 | 	queue: function() {
 336 | 		var bad,
 337 | 			test = this;
 338 | 
 339 | 		synchronize(function() {
 340 | 			test.init();
 341 | 		});
 342 | 		function run() {
 343 | 			// each of these can by async
 344 | 			synchronize(function() {
 345 | 				test.setup();
 346 | 			});
 347 | 			synchronize(function() {
 348 | 				test.run();
 349 | 			});
 350 | 			synchronize(function() {
 351 | 				test.teardown();
 352 | 			});
 353 | 			synchronize(function() {
 354 | 				test.finish();
 355 | 			});
 356 | 		}
 357 | 
 358 | 		// `bad` initialized at top of scope
 359 | 		// defer when previous test run passed, if storage is available
 360 | 		bad = QUnit.config.reorder && defined.sessionStorage &&
 361 | 						+sessionStorage.getItem( "qunit-test-" + this.module + "-" + this.testName );
 362 | 
 363 | 		if ( bad ) {
 364 | 			run();
 365 | 		} else {
 366 | 			synchronize( run, true );
 367 | 		}
 368 | 	}
 369 | };
 370 | 
 371 | // Root QUnit object.
 372 | // `QUnit` initialized at top of scope
 373 | QUnit = {
 374 | 
 375 | 	// call on start of module test to prepend name to all tests
 376 | 	module: function( name, testEnvironment ) {
 377 | 		config.currentModule = name;
 378 | 		config.currentModuleTestEnvironment = testEnvironment;
 379 | 		config.modules[name] = true;
 380 | 	},
 381 | 
 382 | 	asyncTest: function( testName, expected, callback ) {
 383 | 		if ( arguments.length === 2 ) {
 384 | 			callback = expected;
 385 | 			expected = null;
 386 | 		}
 387 | 
 388 | 		QUnit.test( testName, expected, callback, true );
 389 | 	},
 390 | 
 391 | 	test: function( testName, expected, callback, async ) {
 392 | 		var test,
 393 | 			nameHtml = "<span class='test-name'>" + escapeText( testName ) + "</span>";
 394 | 
 395 | 		if ( arguments.length === 2 ) {
 396 | 			callback = expected;
 397 | 			expected = null;
 398 | 		}
 399 | 
 400 | 		if ( config.currentModule ) {
 401 | 			nameHtml = "<span class='module-name'>" + escapeText( config.currentModule ) + "</span>: " + nameHtml;
 402 | 		}
 403 | 
 404 | 		test = new Test({
 405 | 			nameHtml: nameHtml,
 406 | 			testName: testName,
 407 | 			expected: expected,
 408 | 			async: async,
 409 | 			callback: callback,
 410 | 			module: config.currentModule,
 411 | 			moduleTestEnvironment: config.currentModuleTestEnvironment,
 412 | 			stack: sourceFromStacktrace( 2 )
 413 | 		});
 414 | 
 415 | 		if ( !validTest( test ) ) {
 416 | 			return;
 417 | 		}
 418 | 
 419 | 		test.queue();
 420 | 	},
 421 | 
 422 | 	// Specify the number of expected assertions to gurantee that failed test (no assertions are run at all) don't slip through.
 423 | 	expect: function( asserts ) {
 424 | 		if (arguments.length === 1) {
 425 | 			config.current.expected = asserts;
 426 | 		} else {
 427 | 			return config.current.expected;
 428 | 		}
 429 | 	},
 430 | 
 431 | 	start: function( count ) {
 432 | 		// QUnit hasn't been initialized yet.
 433 | 		// Note: RequireJS (et al) may delay onLoad
 434 | 		if ( config.semaphore === undefined ) {
 435 | 			QUnit.begin(function() {
 436 | 				// This is triggered at the top of QUnit.load, push start() to the event loop, to allow QUnit.load to finish first
 437 | 				setTimeout(function() {
 438 | 					QUnit.start( count );
 439 | 				});
 440 | 			});
 441 | 			return;
 442 | 		}
 443 | 
 444 | 		config.semaphore -= count || 1;
 445 | 		// don't start until equal number of stop-calls
 446 | 		if ( config.semaphore > 0 ) {
 447 | 			return;
 448 | 		}
 449 | 		// ignore if start is called more often then stop
 450 | 		if ( config.semaphore < 0 ) {
 451 | 			config.semaphore = 0;
 452 | 			QUnit.pushFailure( "Called start() while already started (QUnit.config.semaphore was 0 already)", null, sourceFromStacktrace(2) );
 453 | 			return;
 454 | 		}
 455 | 		// A slight delay, to avoid any current callbacks
 456 | 		if ( defined.setTimeout ) {
 457 | 			window.setTimeout(function() {
 458 | 				if ( config.semaphore > 0 ) {
 459 | 					return;
 460 | 				}
 461 | 				if ( config.timeout ) {
 462 | 					clearTimeout( config.timeout );
 463 | 				}
 464 | 
 465 | 				config.blocking = false;
 466 | 				process( true );
 467 | 			}, 13);
 468 | 		} else {
 469 | 			config.blocking = false;
 470 | 			process( true );
 471 | 		}
 472 | 	},
 473 | 
 474 | 	stop: function( count ) {
 475 | 		config.semaphore += count || 1;
 476 | 		config.blocking = true;
 477 | 
 478 | 		if ( config.testTimeout && defined.setTimeout ) {
 479 | 			clearTimeout( config.timeout );
 480 | 			config.timeout = window.setTimeout(function() {
 481 | 				QUnit.ok( false, "Test timed out" );
 482 | 				config.semaphore = 1;
 483 | 				QUnit.start();
 484 | 			}, config.testTimeout );
 485 | 		}
 486 | 	}
 487 | };
 488 | 
 489 | // `assert` initialized at top of scope
 490 | // Asssert helpers
 491 | // All of these must either call QUnit.push() or manually do:
 492 | // - runLoggingCallbacks( "log", .. );
 493 | // - config.current.assertions.push({ .. });
 494 | // We attach it to the QUnit object *after* we expose the public API,
 495 | // otherwise `assert` will become a global variable in browsers (#341).
 496 | assert = {
 497 | 	/**
 498 | 	 * Asserts rough true-ish result.
 499 | 	 * @name ok
 500 | 	 * @function
 501 | 	 * @example ok( "asdfasdf".length > 5, "There must be at least 5 chars" );
 502 | 	 */
 503 | 	ok: function( result, msg ) {
 504 | 		if ( !config.current ) {
 505 | 			throw new Error( "ok() assertion outside test context, was " + sourceFromStacktrace(2) );
 506 | 		}
 507 | 		result = !!result;
 508 | 
 509 | 		var source,
 510 | 			details = {
 511 | 				module: config.current.module,
 512 | 				name: config.current.testName,
 513 | 				result: result,
 514 | 				message: msg
 515 | 			};
 516 | 
 517 | 		msg = escapeText( msg || (result ? "okay" : "failed" ) );
 518 | 		msg = "<span class='test-message'>" + msg + "</span>";
 519 | 
 520 | 		if ( !result ) {
 521 | 			source = sourceFromStacktrace( 2 );
 522 | 			if ( source ) {
 523 | 				details.source = source;
 524 | 				msg += "<table><tr class='test-source'><th>Source: </th><td><pre>" + escapeText( source ) + "</pre></td></tr></table>";
 525 | 			}
 526 | 		}
 527 | 		runLoggingCallbacks( "log", QUnit, details );
 528 | 		config.current.assertions.push({
 529 | 			result: result,
 530 | 			message: msg
 531 | 		});
 532 | 	},
 533 | 
 534 | 	/**
 535 | 	 * Assert that the first two arguments are equal, with an optional message.
 536 | 	 * Prints out both actual and expected values.
 537 | 	 * @name equal
 538 | 	 * @function
 539 | 	 * @example equal( format( "Received {0} bytes.", 2), "Received 2 bytes.", "format() replaces {0} with next argument" );
 540 | 	 */
 541 | 	equal: function( actual, expected, message ) {
 542 | 		/*jshint eqeqeq:false */
 543 | 		QUnit.push( expected == actual, actual, expected, message );
 544 | 	},
 545 | 
 546 | 	/**
 547 | 	 * @name notEqual
 548 | 	 * @function
 549 | 	 */
 550 | 	notEqual: function( actual, expected, message ) {
 551 | 		/*jshint eqeqeq:false */
 552 | 		QUnit.push( expected != actual, actual, expected, message );
 553 | 	},
 554 | 
 555 | 	/**
 556 | 	 * @name propEqual
 557 | 	 * @function
 558 | 	 */
 559 | 	propEqual: function( actual, expected, message ) {
 560 | 		actual = objectValues(actual);
 561 | 		expected = objectValues(expected);
 562 | 		QUnit.push( QUnit.equiv(actual, expected), actual, expected, message );
 563 | 	},
 564 | 
 565 | 	/**
 566 | 	 * @name notPropEqual
 567 | 	 * @function
 568 | 	 */
 569 | 	notPropEqual: function( actual, expected, message ) {
 570 | 		actual = objectValues(actual);
 571 | 		expected = objectValues(expected);
 572 | 		QUnit.push( !QUnit.equiv(actual, expected), actual, expected, message );
 573 | 	},
 574 | 
 575 | 	/**
 576 | 	 * @name deepEqual
 577 | 	 * @function
 578 | 	 */
 579 | 	deepEqual: function( actual, expected, message ) {
 580 | 		QUnit.push( QUnit.equiv(actual, expected), actual, expected, message );
 581 | 	},
 582 | 
 583 | 	/**
 584 | 	 * @name notDeepEqual
 585 | 	 * @function
 586 | 	 */
 587 | 	notDeepEqual: function( actual, expected, message ) {
 588 | 		QUnit.push( !QUnit.equiv(actual, expected), actual, expected, message );
 589 | 	},
 590 | 
 591 | 	/**
 592 | 	 * @name strictEqual
 593 | 	 * @function
 594 | 	 */
 595 | 	strictEqual: function( actual, expected, message ) {
 596 | 		QUnit.push( expected === actual, actual, expected, message );
 597 | 	},
 598 | 
 599 | 	/**
 600 | 	 * @name notStrictEqual
 601 | 	 * @function
 602 | 	 */
 603 | 	notStrictEqual: function( actual, expected, message ) {
 604 | 		QUnit.push( expected !== actual, actual, expected, message );
 605 | 	},
 606 | 
 607 | 	"throws": function( block, expected, message ) {
 608 | 		var actual,
 609 | 			expectedOutput = expected,
 610 | 			ok = false;
 611 | 
 612 | 		// 'expected' is optional
 613 | 		if ( typeof expected === "string" ) {
 614 | 			message = expected;
 615 | 			expected = null;
 616 | 		}
 617 | 
 618 | 		config.current.ignoreGlobalErrors = true;
 619 | 		try {
 620 | 			block.call( config.current.testEnvironment );
 621 | 		} catch (e) {
 622 | 			actual = e;
 623 | 		}
 624 | 		config.current.ignoreGlobalErrors = false;
 625 | 
 626 | 		if ( actual ) {
 627 | 			// we don't want to validate thrown error
 628 | 			if ( !expected ) {
 629 | 				ok = true;
 630 | 				expectedOutput = null;
 631 | 			// expected is a regexp
 632 | 			} else if ( QUnit.objectType( expected ) === "regexp" ) {
 633 | 				ok = expected.test( errorString( actual ) );
 634 | 			// expected is a constructor
 635 | 			} else if ( actual instanceof expected ) {
 636 | 				ok = true;
 637 | 			// expected is a validation function which returns true is validation passed
 638 | 			} else if ( expected.call( {}, actual ) === true ) {
 639 | 				expectedOutput = null;
 640 | 				ok = true;
 641 | 			}
 642 | 
 643 | 			QUnit.push( ok, actual, expectedOutput, message );
 644 | 		} else {
 645 | 			QUnit.pushFailure( message, null, 'No exception was thrown.' );
 646 | 		}
 647 | 	}
 648 | };
 649 | 
 650 | /**
 651 |  * @deprecate since 1.8.0
 652 |  * Kept assertion helpers in root for backwards compatibility.
 653 |  */
 654 | extend( QUnit, assert );
 655 | 
 656 | /**
 657 |  * @deprecated since 1.9.0
 658 |  * Kept root "raises()" for backwards compatibility.
 659 |  * (Note that we don't introduce assert.raises).
 660 |  */
 661 | QUnit.raises = assert[ "throws" ];
 662 | 
 663 | /**
 664 |  * @deprecated since 1.0.0, replaced with error pushes since 1.3.0
 665 |  * Kept to avoid TypeErrors for undefined methods.
 666 |  */
 667 | QUnit.equals = function() {
 668 | 	QUnit.push( false, false, false, "QUnit.equals has been deprecated since 2009 (e88049a0), use QUnit.equal instead" );
 669 | };
 670 | QUnit.same = function() {
 671 | 	QUnit.push( false, false, false, "QUnit.same has been deprecated since 2009 (e88049a0), use QUnit.deepEqual instead" );
 672 | };
 673 | 
 674 | // We want access to the constructor's prototype
 675 | (function() {
 676 | 	function F() {}
 677 | 	F.prototype = QUnit;
 678 | 	QUnit = new F();
 679 | 	// Make F QUnit's constructor so that we can add to the prototype later
 680 | 	QUnit.constructor = F;
 681 | }());
 682 | 
 683 | /**
 684 |  * Config object: Maintain internal state
 685 |  * Later exposed as QUnit.config
 686 |  * `config` initialized at top of scope
 687 |  */
 688 | config = {
 689 | 	// The queue of tests to run
 690 | 	queue: [],
 691 | 
 692 | 	// block until document ready
 693 | 	blocking: true,
 694 | 
 695 | 	// when enabled, show only failing tests
 696 | 	// gets persisted through sessionStorage and can be changed in UI via checkbox
 697 | 	hidepassed: false,
 698 | 
 699 | 	// by default, run previously failed tests first
 700 | 	// very useful in combination with "Hide passed tests" checked
 701 | 	reorder: true,
 702 | 
 703 | 	// by default, modify document.title when suite is done
 704 | 	altertitle: true,
 705 | 
 706 | 	// when enabled, all tests must call expect()
 707 | 	requireExpects: false,
 708 | 
 709 | 	// add checkboxes that are persisted in the query-string
 710 | 	// when enabled, the id is set to `true` as a `QUnit.config` property
 711 | 	urlConfig: [
 712 | 		{
 713 | 			id: "noglobals",
 714 | 			label: "Check for Globals",
 715 | 			tooltip: "Enabling this will test if any test introduces new properties on the `window` object. Stored as query-strings."
 716 | 		},
 717 | 		{
 718 | 			id: "notrycatch",
 719 | 			label: "No try-catch",
 720 | 			tooltip: "Enabling this will run tests outside of a try-catch block. Makes debugging exceptions in IE reasonable. Stored as query-strings."
 721 | 		}
 722 | 	],
 723 | 
 724 | 	// Set of all modules.
 725 | 	modules: {},
 726 | 
 727 | 	// logging callback queues
 728 | 	begin: [],
 729 | 	done: [],
 730 | 	log: [],
 731 | 	testStart: [],
 732 | 	testDone: [],
 733 | 	moduleStart: [],
 734 | 	moduleDone: []
 735 | };
 736 | 
 737 | // Export global variables, unless an 'exports' object exists,
 738 | // in that case we assume we're in CommonJS (dealt with on the bottom of the script)
 739 | if ( typeof exports === "undefined" ) {
 740 | 	extend( window, QUnit );
 741 | 
 742 | 	// Expose QUnit object
 743 | 	window.QUnit = QUnit;
 744 | }
 745 | 
 746 | // Initialize more QUnit.config and QUnit.urlParams
 747 | (function() {
 748 | 	var i,
 749 | 		location = window.location || { search: "", protocol: "file:" },
 750 | 		params = location.search.slice( 1 ).split( "&" ),
 751 | 		length = params.length,
 752 | 		urlParams = {},
 753 | 		current;
 754 | 
 755 | 	if ( params[ 0 ] ) {
 756 | 		for ( i = 0; i < length; i++ ) {
 757 | 			current = params[ i ].split( "=" );
 758 | 			current[ 0 ] = decodeURIComponent( current[ 0 ] );
 759 | 			// allow just a key to turn on a flag, e.g., test.html?noglobals
 760 | 			current[ 1 ] = current[ 1 ] ? decodeURIComponent( current[ 1 ] ) : true;
 761 | 			urlParams[ current[ 0 ] ] = current[ 1 ];
 762 | 		}
 763 | 	}
 764 | 
 765 | 	QUnit.urlParams = urlParams;
 766 | 
 767 | 	// String search anywhere in moduleName+testName
 768 | 	config.filter = urlParams.filter;
 769 | 
 770 | 	// Exact match of the module name
 771 | 	config.module = urlParams.module;
 772 | 
 773 | 	config.testNumber = parseInt( urlParams.testNumber, 10 ) || null;
 774 | 
 775 | 	// Figure out if we're running the tests from a server or not
 776 | 	QUnit.isLocal = location.protocol === "file:";
 777 | }());
 778 | 
 779 | // Extend QUnit object,
 780 | // these after set here because they should not be exposed as global functions
 781 | extend( QUnit, {
 782 | 	assert: assert,
 783 | 
 784 | 	config: config,
 785 | 
 786 | 	// Initialize the configuration options
 787 | 	init: function() {
 788 | 		extend( config, {
 789 | 			stats: { all: 0, bad: 0 },
 790 | 			moduleStats: { all: 0, bad: 0 },
 791 | 			started: +new Date(),
 792 | 			updateRate: 1000,
 793 | 			blocking: false,
 794 | 			autostart: true,
 795 | 			autorun: false,
 796 | 			filter: "",
 797 | 			queue: [],
 798 | 			semaphore: 1
 799 | 		});
 800 | 
 801 | 		var tests, banner, result,
 802 | 			qunit = id( "qunit" );
 803 | 
 804 | 		if ( qunit ) {
 805 | 			qunit.innerHTML =
 806 | 				"<h1 id='qunit-header'>" + escapeText( document.title ) + "</h1>" +
 807 | 				"<h2 id='qunit-banner'></h2>" +
 808 | 				"<div id='qunit-testrunner-toolbar'></div>" +
 809 | 				"<h2 id='qunit-userAgent'></h2>" +
 810 | 				"<ol id='qunit-tests'></ol>";
 811 | 		}
 812 | 
 813 | 		tests = id( "qunit-tests" );
 814 | 		banner = id( "qunit-banner" );
 815 | 		result = id( "qunit-testresult" );
 816 | 
 817 | 		if ( tests ) {
 818 | 			tests.innerHTML = "";
 819 | 		}
 820 | 
 821 | 		if ( banner ) {
 822 | 			banner.className = "";
 823 | 		}
 824 | 
 825 | 		if ( result ) {
 826 | 			result.parentNode.removeChild( result );
 827 | 		}
 828 | 
 829 | 		if ( tests ) {
 830 | 			result = document.createElement( "p" );
 831 | 			result.id = "qunit-testresult";
 832 | 			result.className = "result";
 833 | 			tests.parentNode.insertBefore( result, tests );
 834 | 			result.innerHTML = "Running...<br/>&nbsp;";
 835 | 		}
 836 | 	},
 837 | 
 838 | 	// Resets the test setup. Useful for tests that modify the DOM.
 839 | 	reset: function() {
 840 | 		var fixture = id( "qunit-fixture" );
 841 | 		if ( fixture ) {
 842 | 			fixture.innerHTML = config.fixture;
 843 | 		}
 844 | 	},
 845 | 
 846 | 	// Trigger an event on an element.
 847 | 	// @example triggerEvent( document.body, "click" );
 848 | 	triggerEvent: function( elem, type, event ) {
 849 | 		if ( document.createEvent ) {
 850 | 			event = document.createEvent( "MouseEvents" );
 851 | 			event.initMouseEvent(type, true, true, elem.ownerDocument.defaultView,
 852 | 				0, 0, 0, 0, 0, false, false, false, false, 0, null);
 853 | 
 854 | 			elem.dispatchEvent( event );
 855 | 		} else if ( elem.fireEvent ) {
 856 | 			elem.fireEvent( "on" + type );
 857 | 		}
 858 | 	},
 859 | 
 860 | 	// Safe object type checking
 861 | 	is: function( type, obj ) {
 862 | 		return QUnit.objectType( obj ) === type;
 863 | 	},
 864 | 
 865 | 	objectType: function( obj ) {
 866 | 		if ( typeof obj === "undefined" ) {
 867 | 				return "undefined";
 868 | 		// consider: typeof null === object
 869 | 		}
 870 | 		if ( obj === null ) {
 871 | 				return "null";
 872 | 		}
 873 | 
 874 | 		var match = toString.call( obj ).match(/^\[object\s(.*)\]$/),
 875 | 			type = match && match[1] || "";
 876 | 
 877 | 		switch ( type ) {
 878 | 			case "Number":
 879 | 				if ( isNaN(obj) ) {
 880 | 					return "nan";
 881 | 				}
 882 | 				return "number";
 883 | 			case "String":
 884 | 			case "Boolean":
 885 | 			case "Array":
 886 | 			case "Date":
 887 | 			case "RegExp":
 888 | 			case "Function":
 889 | 				return type.toLowerCase();
 890 | 		}
 891 | 		if ( typeof obj === "object" ) {
 892 | 			return "object";
 893 | 		}
 894 | 		return undefined;
 895 | 	},
 896 | 
 897 | 	push: function( result, actual, expected, message ) {
 898 | 		if ( !config.current ) {
 899 | 			throw new Error( "assertion outside test context, was " + sourceFromStacktrace() );
 900 | 		}
 901 | 
 902 | 		var output, source,
 903 | 			details = {
 904 | 				module: config.current.module,
 905 | 				name: config.current.testName,
 906 | 				result: result,
 907 | 				message: message,
 908 | 				actual: actual,
 909 | 				expected: expected
 910 | 			};
 911 | 
 912 | 		message = escapeText( message ) || ( result ? "okay" : "failed" );
 913 | 		message = "<span class='test-message'>" + message + "</span>";
 914 | 		output = message;
 915 | 
 916 | 		if ( !result ) {
 917 | 			expected = escapeText( QUnit.jsDump.parse(expected) );
 918 | 			actual = escapeText( QUnit.jsDump.parse(actual) );
 919 | 			output += "<table><tr class='test-expected'><th>Expected: </th><td><pre>" + expected + "</pre></td></tr>";
 920 | 
 921 | 			if ( actual !== expected ) {
 922 | 				output += "<tr class='test-actual'><th>Result: </th><td><pre>" + actual + "</pre></td></tr>";
 923 | 				output += "<tr class='test-diff'><th>Diff: </th><td><pre>" + QUnit.diff( expected, actual ) + "</pre></td></tr>";
 924 | 			}
 925 | 
 926 | 			source = sourceFromStacktrace();
 927 | 
 928 | 			if ( source ) {
 929 | 				details.source = source;
 930 | 				output += "<tr class='test-source'><th>Source: </th><td><pre>" + escapeText( source ) + "</pre></td></tr>";
 931 | 			}
 932 | 
 933 | 			output += "</table>";
 934 | 		}
 935 | 
 936 | 		runLoggingCallbacks( "log", QUnit, details );
 937 | 
 938 | 		config.current.assertions.push({
 939 | 			result: !!result,
 940 | 			message: output
 941 | 		});
 942 | 	},
 943 | 
 944 | 	pushFailure: function( message, source, actual ) {
 945 | 		if ( !config.current ) {
 946 | 			throw new Error( "pushFailure() assertion outside test context, was " + sourceFromStacktrace(2) );
 947 | 		}
 948 | 
 949 | 		var output,
 950 | 			details = {
 951 | 				module: config.current.module,
 952 | 				name: config.current.testName,
 953 | 				result: false,
 954 | 				message: message
 955 | 			};
 956 | 
 957 | 		message = escapeText( message ) || "error";
 958 | 		message = "<span class='test-message'>" + message + "</span>";
 959 | 		output = message;
 960 | 
 961 | 		output += "<table>";
 962 | 
 963 | 		if ( actual ) {
 964 | 			output += "<tr class='test-actual'><th>Result: </th><td><pre>" + escapeText( actual ) + "</pre></td></tr>";
 965 | 		}
 966 | 
 967 | 		if ( source ) {
 968 | 			details.source = source;
 969 | 			output += "<tr class='test-source'><th>Source: </th><td><pre>" + escapeText( source ) + "</pre></td></tr>";
 970 | 		}
 971 | 
 972 | 		output += "</table>";
 973 | 
 974 | 		runLoggingCallbacks( "log", QUnit, details );
 975 | 
 976 | 		config.current.assertions.push({
 977 | 			result: false,
 978 | 			message: output
 979 | 		});
 980 | 	},
 981 | 
 982 | 	url: function( params ) {
 983 | 		params = extend( extend( {}, QUnit.urlParams ), params );
 984 | 		var key,
 985 | 			querystring = "?";
 986 | 
 987 | 		for ( key in params ) {
 988 | 			if ( !hasOwn.call( params, key ) ) {
 989 | 				continue;
 990 | 			}
 991 | 			querystring += encodeURIComponent( key ) + "=" +
 992 | 				encodeURIComponent( params[ key ] ) + "&";
 993 | 		}
 994 | 		return window.location.protocol + "//" + window.location.host +
 995 | 			window.location.pathname + querystring.slice( 0, -1 );
 996 | 	},
 997 | 
 998 | 	extend: extend,
 999 | 	id: id,
1000 | 	addEvent: addEvent
1001 | 	// load, equiv, jsDump, diff: Attached later
1002 | });
1003 | 
1004 | /**
1005 |  * @deprecated: Created for backwards compatibility with test runner that set the hook function
1006 |  * into QUnit.{hook}, instead of invoking it and passing the hook function.
1007 |  * QUnit.constructor is set to the empty F() above so that we can add to it's prototype here.
1008 |  * Doing this allows us to tell if the following methods have been overwritten on the actual
1009 |  * QUnit object.
1010 |  */
1011 | extend( QUnit.constructor.prototype, {
1012 | 
1013 | 	// Logging callbacks; all receive a single argument with the listed properties
1014 | 	// run test/logs.html for any related changes
1015 | 	begin: registerLoggingCallback( "begin" ),
1016 | 
1017 | 	// done: { failed, passed, total, runtime }
1018 | 	done: registerLoggingCallback( "done" ),
1019 | 
1020 | 	// log: { result, actual, expected, message }
1021 | 	log: registerLoggingCallback( "log" ),
1022 | 
1023 | 	// testStart: { name }
1024 | 	testStart: registerLoggingCallback( "testStart" ),
1025 | 
1026 | 	// testDone: { name, failed, passed, total, duration }
1027 | 	testDone: registerLoggingCallback( "testDone" ),
1028 | 
1029 | 	// moduleStart: { name }
1030 | 	moduleStart: registerLoggingCallback( "moduleStart" ),
1031 | 
1032 | 	// moduleDone: { name, failed, passed, total }
1033 | 	moduleDone: registerLoggingCallback( "moduleDone" )
1034 | });
1035 | 
1036 | if ( typeof document === "undefined" || document.readyState === "complete" ) {
1037 | 	config.autorun = true;
1038 | }
1039 | 
1040 | QUnit.load = function() {
1041 | 	runLoggingCallbacks( "begin", QUnit, {} );
1042 | 
1043 | 	// Initialize the config, saving the execution queue
1044 | 	var banner, filter, i, label, len, main, ol, toolbar, userAgent, val,
1045 | 		urlConfigCheckboxesContainer, urlConfigCheckboxes, moduleFilter,
1046 | 		numModules = 0,
1047 | 		moduleFilterHtml = "",
1048 | 		urlConfigHtml = "",
1049 | 		oldconfig = extend( {}, config );
1050 | 
1051 | 	QUnit.init();
1052 | 	extend(config, oldconfig);
1053 | 
1054 | 	config.blocking = false;
1055 | 
1056 | 	len = config.urlConfig.length;
1057 | 
1058 | 	for ( i = 0; i < len; i++ ) {
1059 | 		val = config.urlConfig[i];
1060 | 		if ( typeof val === "string" ) {
1061 | 			val = {
1062 | 				id: val,
1063 | 				label: val,
1064 | 				tooltip: "[no tooltip available]"
1065 | 			};
1066 | 		}
1067 | 		config[ val.id ] = QUnit.urlParams[ val.id ];
1068 | 		urlConfigHtml += "<input id='qunit-urlconfig-" + escapeText( val.id ) +
1069 | 			"' name='" + escapeText( val.id ) +
1070 | 			"' type='checkbox'" + ( config[ val.id ] ? " checked='checked'" : "" ) +
1071 | 			" title='" + escapeText( val.tooltip ) +
1072 | 			"'><label for='qunit-urlconfig-" + escapeText( val.id ) +
1073 | 			"' title='" + escapeText( val.tooltip ) + "'>" + val.label + "</label>";
1074 | 	}
1075 | 
1076 | 	moduleFilterHtml += "<label for='qunit-modulefilter'>Module: </label><select id='qunit-modulefilter' name='modulefilter'><option value='' " +
1077 | 		( config.module === undefined  ? "selected='selected'" : "" ) +
1078 | 		">< All Modules ></option>";
1079 | 
1080 | 	for ( i in config.modules ) {
1081 | 		if ( config.modules.hasOwnProperty( i ) ) {
1082 | 			numModules += 1;
1083 | 			moduleFilterHtml += "<option value='" + escapeText( encodeURIComponent(i) ) + "' " +
1084 | 				( config.module === i ? "selected='selected'" : "" ) +
1085 | 				">" + escapeText(i) + "</option>";
1086 | 		}
1087 | 	}
1088 | 	moduleFilterHtml += "</select>";
1089 | 
1090 | 	// `userAgent` initialized at top of scope
1091 | 	userAgent = id( "qunit-userAgent" );
1092 | 	if ( userAgent ) {
1093 | 		userAgent.innerHTML = navigator.userAgent;
1094 | 	}
1095 | 
1096 | 	// `banner` initialized at top of scope
1097 | 	banner = id( "qunit-header" );
1098 | 	if ( banner ) {
1099 | 		banner.innerHTML = "<a href='" + QUnit.url({ filter: undefined, module: undefined, testNumber: undefined }) + "'>" + banner.innerHTML + "</a> ";
1100 | 	}
1101 | 
1102 | 	// `toolbar` initialized at top of scope
1103 | 	toolbar = id( "qunit-testrunner-toolbar" );
1104 | 	if ( toolbar ) {
1105 | 		// `filter` initialized at top of scope
1106 | 		filter = document.createElement( "input" );
1107 | 		filter.type = "checkbox";
1108 | 		filter.id = "qunit-filter-pass";
1109 | 
1110 | 		addEvent( filter, "click", function() {
1111 | 			var tmp,
1112 | 				ol = document.getElementById( "qunit-tests" );
1113 | 
1114 | 			if ( filter.checked ) {
1115 | 				ol.className = ol.className + " hidepass";
1116 | 			} else {
1117 | 				tmp = " " + ol.className.replace( /[\n\t\r]/g, " " ) + " ";
1118 | 				ol.className = tmp.replace( / hidepass /, " " );
1119 | 			}
1120 | 			if ( defined.sessionStorage ) {
1121 | 				if (filter.checked) {
1122 | 					sessionStorage.setItem( "qunit-filter-passed-tests", "true" );
1123 | 				} else {
1124 | 					sessionStorage.removeItem( "qunit-filter-passed-tests" );
1125 | 				}
1126 | 			}
1127 | 		});
1128 | 
1129 | 		if ( config.hidepassed || defined.sessionStorage && sessionStorage.getItem( "qunit-filter-passed-tests" ) ) {
1130 | 			filter.checked = true;
1131 | 			// `ol` initialized at top of scope
1132 | 			ol = document.getElementById( "qunit-tests" );
1133 | 			ol.className = ol.className + " hidepass";
1134 | 		}
1135 | 		toolbar.appendChild( filter );
1136 | 
1137 | 		// `label` initialized at top of scope
1138 | 		label = document.createElement( "label" );
1139 | 		label.setAttribute( "for", "qunit-filter-pass" );
1140 | 		label.setAttribute( "title", "Only show tests and assertons that fail. Stored in sessionStorage." );
1141 | 		label.innerHTML = "Hide passed tests";
1142 | 		toolbar.appendChild( label );
1143 | 
1144 | 		urlConfigCheckboxesContainer = document.createElement("span");
1145 | 		urlConfigCheckboxesContainer.innerHTML = urlConfigHtml;
1146 | 		urlConfigCheckboxes = urlConfigCheckboxesContainer.getElementsByTagName("input");
1147 | 		// For oldIE support:
1148 | 		// * Add handlers to the individual elements instead of the container
1149 | 		// * Use "click" instead of "change"
1150 | 		// * Fallback from event.target to event.srcElement
1151 | 		addEvents( urlConfigCheckboxes, "click", function( event ) {
1152 | 			var params = {},
1153 | 				target = event.target || event.srcElement;
1154 | 			params[ target.name ] = target.checked ? true : undefined;
1155 | 			window.location = QUnit.url( params );
1156 | 		});
1157 | 		toolbar.appendChild( urlConfigCheckboxesContainer );
1158 | 
1159 | 		if (numModules > 1) {
1160 | 			moduleFilter = document.createElement( 'span' );
1161 | 			moduleFilter.setAttribute( 'id', 'qunit-modulefilter-container' );
1162 | 			moduleFilter.innerHTML = moduleFilterHtml;
1163 | 			addEvent( moduleFilter.lastChild, "change", function() {
1164 | 				var selectBox = moduleFilter.getElementsByTagName("select")[0],
1165 | 					selectedModule = decodeURIComponent(selectBox.options[selectBox.selectedIndex].value);
1166 | 
1167 | 				window.location = QUnit.url( { module: ( selectedModule === "" ) ? undefined : selectedModule } );
1168 | 			});
1169 | 			toolbar.appendChild(moduleFilter);
1170 | 		}
1171 | 	}
1172 | 
1173 | 	// `main` initialized at top of scope
1174 | 	main = id( "qunit-fixture" );
1175 | 	if ( main ) {
1176 | 		config.fixture = main.innerHTML;
1177 | 	}
1178 | 
1179 | 	if ( config.autostart ) {
1180 | 		QUnit.start();
1181 | 	}
1182 | };
1183 | 
1184 | addEvent( window, "load", QUnit.load );
1185 | 
1186 | // `onErrorFnPrev` initialized at top of scope
1187 | // Preserve other handlers
1188 | onErrorFnPrev = window.onerror;
1189 | 
1190 | // Cover uncaught exceptions
1191 | // Returning true will surpress the default browser handler,
1192 | // returning false will let it run.
1193 | window.onerror = function ( error, filePath, linerNr ) {
1194 | 	var ret = false;
1195 | 	if ( onErrorFnPrev ) {
1196 | 		ret = onErrorFnPrev( error, filePath, linerNr );
1197 | 	}
1198 | 
1199 | 	// Treat return value as window.onerror itself does,
1200 | 	// Only do our handling if not surpressed.
1201 | 	if ( ret !== true ) {
1202 | 		if ( QUnit.config.current ) {
1203 | 			if ( QUnit.config.current.ignoreGlobalErrors ) {
1204 | 				return true;
1205 | 			}
1206 | 			QUnit.pushFailure( error, filePath + ":" + linerNr );
1207 | 		} else {
1208 | 			QUnit.test( "global failure", extend( function() {
1209 | 				QUnit.pushFailure( error, filePath + ":" + linerNr );
1210 | 			}, { validTest: validTest } ) );
1211 | 		}
1212 | 		return false;
1213 | 	}
1214 | 
1215 | 	return ret;
1216 | };
1217 | 
1218 | function done() {
1219 | 	config.autorun = true;
1220 | 
1221 | 	// Log the last module results
1222 | 	if ( config.currentModule ) {
1223 | 		runLoggingCallbacks( "moduleDone", QUnit, {
1224 | 			name: config.currentModule,
1225 | 			failed: config.moduleStats.bad,
1226 | 			passed: config.moduleStats.all - config.moduleStats.bad,
1227 | 			total: config.moduleStats.all
1228 | 		});
1229 | 	}
1230 | 
1231 | 	var i, key,
1232 | 		banner = id( "qunit-banner" ),
1233 | 		tests = id( "qunit-tests" ),
1234 | 		runtime = +new Date() - config.started,
1235 | 		passed = config.stats.all - config.stats.bad,
1236 | 		html = [
1237 | 			"Tests completed in ",
1238 | 			runtime,
1239 | 			" milliseconds.<br/>",
1240 | 			"<span class='passed'>",
1241 | 			passed,
1242 | 			"</span> assertions of <span class='total'>",
1243 | 			config.stats.all,
1244 | 			"</span> passed, <span class='failed'>",
1245 | 			config.stats.bad,
1246 | 			"</span> failed."
1247 | 		].join( "" );
1248 | 
1249 | 	if ( banner ) {
1250 | 		banner.className = ( config.stats.bad ? "qunit-fail" : "qunit-pass" );
1251 | 	}
1252 | 
1253 | 	if ( tests ) {
1254 | 		id( "qunit-testresult" ).innerHTML = html;
1255 | 	}
1256 | 
1257 | 	if ( config.altertitle && typeof document !== "undefined" && document.title ) {
1258 | 		// show ✖ for good, ✔ for bad suite result in title
1259 | 		// use escape sequences in case file gets loaded with non-utf-8-charset
1260 | 		document.title = [
1261 | 			( config.stats.bad ? "\u2716" : "\u2714" ),
1262 | 			document.title.replace( /^[\u2714\u2716] /i, "" )
1263 | 		].join( " " );
1264 | 	}
1265 | 
1266 | 	// clear own sessionStorage items if all tests passed
1267 | 	if ( config.reorder && defined.sessionStorage && config.stats.bad === 0 ) {
1268 | 		// `key` & `i` initialized at top of scope
1269 | 		for ( i = 0; i < sessionStorage.length; i++ ) {
1270 | 			key = sessionStorage.key( i++ );
1271 | 			if ( key.indexOf( "qunit-test-" ) === 0 ) {
1272 | 				sessionStorage.removeItem( key );
1273 | 			}
1274 | 		}
1275 | 	}
1276 | 
1277 | 	// scroll back to top to show results
1278 | 	if ( window.scrollTo ) {
1279 | 		window.scrollTo(0, 0);
1280 | 	}
1281 | 
1282 | 	runLoggingCallbacks( "done", QUnit, {
1283 | 		failed: config.stats.bad,
1284 | 		passed: passed,
1285 | 		total: config.stats.all,
1286 | 		runtime: runtime
1287 | 	});
1288 | }
1289 | 
1290 | /** @return Boolean: true if this test should be ran */
1291 | function validTest( test ) {
1292 | 	var include,
1293 | 		filter = config.filter && config.filter.toLowerCase(),
1294 | 		module = config.module && config.module.toLowerCase(),
1295 | 		fullName = (test.module + ": " + test.testName).toLowerCase();
1296 | 
1297 | 	// Internally-generated tests are always valid
1298 | 	if ( test.callback && test.callback.validTest === validTest ) {
1299 | 		delete test.callback.validTest;
1300 | 		return true;
1301 | 	}
1302 | 
1303 | 	if ( config.testNumber ) {
1304 | 		return test.testNumber === config.testNumber;
1305 | 	}
1306 | 
1307 | 	if ( module && ( !test.module || test.module.toLowerCase() !== module ) ) {
1308 | 		return false;
1309 | 	}
1310 | 
1311 | 	if ( !filter ) {
1312 | 		return true;
1313 | 	}
1314 | 
1315 | 	include = filter.charAt( 0 ) !== "!";
1316 | 	if ( !include ) {
1317 | 		filter = filter.slice( 1 );
1318 | 	}
1319 | 
1320 | 	// If the filter matches, we need to honour include
1321 | 	if ( fullName.indexOf( filter ) !== -1 ) {
1322 | 		return include;
1323 | 	}
1324 | 
1325 | 	// Otherwise, do the opposite
1326 | 	return !include;
1327 | }
1328 | 
1329 | // so far supports only Firefox, Chrome and Opera (buggy), Safari (for real exceptions)
1330 | // Later Safari and IE10 are supposed to support error.stack as well
1331 | // See also https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error/Stack
1332 | function extractStacktrace( e, offset ) {
1333 | 	offset = offset === undefined ? 3 : offset;
1334 | 
1335 | 	var stack, include, i;
1336 | 
1337 | 	if ( e.stacktrace ) {
1338 | 		// Opera
1339 | 		return e.stacktrace.split( "\n" )[ offset + 3 ];
1340 | 	} else if ( e.stack ) {
1341 | 		// Firefox, Chrome
1342 | 		stack = e.stack.split( "\n" );
1343 | 		if (/^error$/i.test( stack[0] ) ) {
1344 | 			stack.shift();
1345 | 		}
1346 | 		if ( fileName ) {
1347 | 			include = [];
1348 | 			for ( i = offset; i < stack.length; i++ ) {
1349 | 				if ( stack[ i ].indexOf( fileName ) !== -1 ) {
1350 | 					break;
1351 | 				}
1352 | 				include.push( stack[ i ] );
1353 | 			}
1354 | 			if ( include.length ) {
1355 | 				return include.join( "\n" );
1356 | 			}
1357 | 		}
1358 | 		return stack[ offset ];
1359 | 	} else if ( e.sourceURL ) {
1360 | 		// Safari, PhantomJS
1361 | 		// hopefully one day Safari provides actual stacktraces
1362 | 		// exclude useless self-reference for generated Error objects
1363 | 		if ( /qunit.js$/.test( e.sourceURL ) ) {
1364 | 			return;
1365 | 		}
1366 | 		// for actual exceptions, this is useful
1367 | 		return e.sourceURL + ":" + e.line;
1368 | 	}
1369 | }
1370 | function sourceFromStacktrace( offset ) {
1371 | 	try {
1372 | 		throw new Error();
1373 | 	} catch ( e ) {
1374 | 		return extractStacktrace( e, offset );
1375 | 	}
1376 | }
1377 | 
1378 | /**
1379 |  * Escape text for attribute or text content.
1380 |  */
1381 | function escapeText( s ) {
1382 | 	if ( !s ) {
1383 | 		return "";
1384 | 	}
1385 | 	s = s + "";
1386 | 	// Both single quotes and double quotes (for attributes)
1387 | 	return s.replace( /['"<>&]/g, function( s ) {
1388 | 		switch( s ) {
1389 | 			case '\'':
1390 | 				return '&#039;';
1391 | 			case '"':
1392 | 				return '&quot;';
1393 | 			case '<':
1394 | 				return '&lt;';
1395 | 			case '>':
1396 | 				return '&gt;';
1397 | 			case '&':
1398 | 				return '&amp;';
1399 | 		}
1400 | 	});
1401 | }
1402 | 
1403 | function synchronize( callback, last ) {
1404 | 	config.queue.push( callback );
1405 | 
1406 | 	if ( config.autorun && !config.blocking ) {
1407 | 		process( last );
1408 | 	}
1409 | }
1410 | 
1411 | function process( last ) {
1412 | 	function next() {
1413 | 		process( last );
1414 | 	}
1415 | 	var start = new Date().getTime();
1416 | 	config.depth = config.depth ? config.depth + 1 : 1;
1417 | 
1418 | 	while ( config.queue.length && !config.blocking ) {
1419 | 		if ( !defined.setTimeout || config.updateRate <= 0 || ( ( new Date().getTime() - start ) < config.updateRate ) ) {
1420 | 			config.queue.shift()();
1421 | 		} else {
1422 | 			window.setTimeout( next, 13 );
1423 | 			break;
1424 | 		}
1425 | 	}
1426 | 	config.depth--;
1427 | 	if ( last && !config.blocking && !config.queue.length && config.depth === 0 ) {
1428 | 		done();
1429 | 	}
1430 | }
1431 | 
1432 | function saveGlobal() {
1433 | 	config.pollution = [];
1434 | 
1435 | 	if ( config.noglobals ) {
1436 | 		for ( var key in window ) {
1437 | 			// in Opera sometimes DOM element ids show up here, ignore them
1438 | 			if ( !hasOwn.call( window, key ) || /^qunit-test-output/.test( key ) ) {
1439 | 				continue;
1440 | 			}
1441 | 			config.pollution.push( key );
1442 | 		}
1443 | 	}
1444 | }
1445 | 
1446 | function checkPollution() {
1447 | 	var newGlobals,
1448 | 		deletedGlobals,
1449 | 		old = config.pollution;
1450 | 
1451 | 	saveGlobal();
1452 | 
1453 | 	newGlobals = diff( config.pollution, old );
1454 | 	if ( newGlobals.length > 0 ) {
1455 | 		QUnit.pushFailure( "Introduced global variable(s): " + newGlobals.join(", ") );
1456 | 	}
1457 | 
1458 | 	deletedGlobals = diff( old, config.pollution );
1459 | 	if ( deletedGlobals.length > 0 ) {
1460 | 		QUnit.pushFailure( "Deleted global variable(s): " + deletedGlobals.join(", ") );
1461 | 	}
1462 | }
1463 | 
1464 | // returns a new Array with the elements that are in a but not in b
1465 | function diff( a, b ) {
1466 | 	var i, j,
1467 | 		result = a.slice();
1468 | 
1469 | 	for ( i = 0; i < result.length; i++ ) {
1470 | 		for ( j = 0; j < b.length; j++ ) {
1471 | 			if ( result[i] === b[j] ) {
1472 | 				result.splice( i, 1 );
1473 | 				i--;
1474 | 				break;
1475 | 			}
1476 | 		}
1477 | 	}
1478 | 	return result;
1479 | }
1480 | 
1481 | function extend( a, b ) {
1482 | 	for ( var prop in b ) {
1483 | 		if ( b[ prop ] === undefined ) {
1484 | 			delete a[ prop ];
1485 | 
1486 | 		// Avoid "Member not found" error in IE8 caused by setting window.constructor
1487 | 		} else if ( prop !== "constructor" || a !== window ) {
1488 | 			a[ prop ] = b[ prop ];
1489 | 		}
1490 | 	}
1491 | 
1492 | 	return a;
1493 | }
1494 | 
1495 | /**
1496 |  * @param {HTMLElement} elem
1497 |  * @param {string} type
1498 |  * @param {Function} fn
1499 |  */
1500 | function addEvent( elem, type, fn ) {
1501 | 	// Standards-based browsers
1502 | 	if ( elem.addEventListener ) {
1503 | 		elem.addEventListener( type, fn, false );
1504 | 	// IE
1505 | 	} else {
1506 | 		elem.attachEvent( "on" + type, fn );
1507 | 	}
1508 | }
1509 | 
1510 | /**
1511 |  * @param {Array|NodeList} elems
1512 |  * @param {string} type
1513 |  * @param {Function} fn
1514 |  */
1515 | function addEvents( elems, type, fn ) {
1516 | 	var i = elems.length;
1517 | 	while ( i-- ) {
1518 | 		addEvent( elems[i], type, fn );
1519 | 	}
1520 | }
1521 | 
1522 | function hasClass( elem, name ) {
1523 | 	return (" " + elem.className + " ").indexOf(" " + name + " ") > -1;
1524 | }
1525 | 
1526 | function addClass( elem, name ) {
1527 | 	if ( !hasClass( elem, name ) ) {
1528 | 		elem.className += (elem.className ? " " : "") + name;
1529 | 	}
1530 | }
1531 | 
1532 | function removeClass( elem, name ) {
1533 | 	var set = " " + elem.className + " ";
1534 | 	// Class name may appear multiple times
1535 | 	while ( set.indexOf(" " + name + " ") > -1 ) {
1536 | 		set = set.replace(" " + name + " " , " ");
1537 | 	}
1538 | 	// If possible, trim it for prettiness, but not neccecarily
1539 | 	elem.className = window.jQuery ? jQuery.trim( set ) : ( set.trim ? set.trim() : set );
1540 | }
1541 | 
1542 | function id( name ) {
1543 | 	return !!( typeof document !== "undefined" && document && document.getElementById ) &&
1544 | 		document.getElementById( name );
1545 | }
1546 | 
1547 | function registerLoggingCallback( key ) {
1548 | 	return function( callback ) {
1549 | 		config[key].push( callback );
1550 | 	};
1551 | }
1552 | 
1553 | // Supports deprecated method of completely overwriting logging callbacks
1554 | function runLoggingCallbacks( key, scope, args ) {
1555 | 	var i, callbacks;
1556 | 	if ( QUnit.hasOwnProperty( key ) ) {
1557 | 		QUnit[ key ].call(scope, args );
1558 | 	} else {
1559 | 		callbacks = config[ key ];
1560 | 		for ( i = 0; i < callbacks.length; i++ ) {
1561 | 			callbacks[ i ].call( scope, args );
1562 | 		}
1563 | 	}
1564 | }
1565 | 
1566 | // Test for equality any JavaScript type.
1567 | // Author: Philippe Rathé <prathe@gmail.com>
1568 | QUnit.equiv = (function() {
1569 | 
1570 | 	// Call the o related callback with the given arguments.
1571 | 	function bindCallbacks( o, callbacks, args ) {
1572 | 		var prop = QUnit.objectType( o );
1573 | 		if ( prop ) {
1574 | 			if ( QUnit.objectType( callbacks[ prop ] ) === "function" ) {
1575 | 				return callbacks[ prop ].apply( callbacks, args );
1576 | 			} else {
1577 | 				return callbacks[ prop ]; // or undefined
1578 | 			}
1579 | 		}
1580 | 	}
1581 | 
1582 | 	// the real equiv function
1583 | 	var innerEquiv,
1584 | 		// stack to decide between skip/abort functions
1585 | 		callers = [],
1586 | 		// stack to avoiding loops from circular referencing
1587 | 		parents = [],
1588 | 
1589 | 		getProto = Object.getPrototypeOf || function ( obj ) {
1590 | 			return obj.__proto__;
1591 | 		},
1592 | 		callbacks = (function () {
1593 | 
1594 | 			// for string, boolean, number and null
1595 | 			function useStrictEquality( b, a ) {
1596 | 				/*jshint eqeqeq:false */
1597 | 				if ( b instanceof a.constructor || a instanceof b.constructor ) {
1598 | 					// to catch short annotaion VS 'new' annotation of a
1599 | 					// declaration
1600 | 					// e.g. var i = 1;
1601 | 					// var j = new Number(1);
1602 | 					return a == b;
1603 | 				} else {
1604 | 					return a === b;
1605 | 				}
1606 | 			}
1607 | 
1608 | 			return {
1609 | 				"string": useStrictEquality,
1610 | 				"boolean": useStrictEquality,
1611 | 				"number": useStrictEquality,
1612 | 				"null": useStrictEquality,
1613 | 				"undefined": useStrictEquality,
1614 | 
1615 | 				"nan": function( b ) {
1616 | 					return isNaN( b );
1617 | 				},
1618 | 
1619 | 				"date": function( b, a ) {
1620 | 					return QUnit.objectType( b ) === "date" && a.valueOf() === b.valueOf();
1621 | 				},
1622 | 
1623 | 				"regexp": function( b, a ) {
1624 | 					return QUnit.objectType( b ) === "regexp" &&
1625 | 						// the regex itself
1626 | 						a.source === b.source &&
1627 | 						// and its modifers
1628 | 						a.global === b.global &&
1629 | 						// (gmi) ...
1630 | 						a.ignoreCase === b.ignoreCase &&
1631 | 						a.multiline === b.multiline &&
1632 | 						a.sticky === b.sticky;
1633 | 				},
1634 | 
1635 | 				// - skip when the property is a method of an instance (OOP)
1636 | 				// - abort otherwise,
1637 | 				// initial === would have catch identical references anyway
1638 | 				"function": function() {
1639 | 					var caller = callers[callers.length - 1];
1640 | 					return caller !== Object && typeof caller !== "undefined";
1641 | 				},
1642 | 
1643 | 				"array": function( b, a ) {
1644 | 					var i, j, len, loop;
1645 | 
1646 | 					// b could be an object literal here
1647 | 					if ( QUnit.objectType( b ) !== "array" ) {
1648 | 						return false;
1649 | 					}
1650 | 
1651 | 					len = a.length;
1652 | 					if ( len !== b.length ) {
1653 | 						// safe and faster
1654 | 						return false;
1655 | 					}
1656 | 
1657 | 					// track reference to avoid circular references
1658 | 					parents.push( a );
1659 | 					for ( i = 0; i < len; i++ ) {
1660 | 						loop = false;
1661 | 						for ( j = 0; j < parents.length; j++ ) {
1662 | 							if ( parents[j] === a[i] ) {
1663 | 								loop = true;// dont rewalk array
1664 | 							}
1665 | 						}
1666 | 						if ( !loop && !innerEquiv(a[i], b[i]) ) {
1667 | 							parents.pop();
1668 | 							return false;
1669 | 						}
1670 | 					}
1671 | 					parents.pop();
1672 | 					return true;
1673 | 				},
1674 | 
1675 | 				"object": function( b, a ) {
1676 | 					var i, j, loop,
1677 | 						// Default to true
1678 | 						eq = true,
1679 | 						aProperties = [],
1680 | 						bProperties = [];
1681 | 
1682 | 					// comparing constructors is more strict than using
1683 | 					// instanceof
1684 | 					if ( a.constructor !== b.constructor ) {
1685 | 						// Allow objects with no prototype to be equivalent to
1686 | 						// objects with Object as their constructor.
1687 | 						if ( !(( getProto(a) === null && getProto(b) === Object.prototype ) ||
1688 | 							( getProto(b) === null && getProto(a) === Object.prototype ) ) ) {
1689 | 								return false;
1690 | 						}
1691 | 					}
1692 | 
1693 | 					// stack constructor before traversing properties
1694 | 					callers.push( a.constructor );
1695 | 					// track reference to avoid circular references
1696 | 					parents.push( a );
1697 | 
1698 | 					for ( i in a ) { // be strict: don't ensures hasOwnProperty
1699 | 									// and go deep
1700 | 						loop = false;
1701 | 						for ( j = 0; j < parents.length; j++ ) {
1702 | 							if ( parents[j] === a[i] ) {
1703 | 								// don't go down the same path twice
1704 | 								loop = true;
1705 | 							}
1706 | 						}
1707 | 						aProperties.push(i); // collect a's properties
1708 | 
1709 | 						if (!loop && !innerEquiv( a[i], b[i] ) ) {
1710 | 							eq = false;
1711 | 							break;
1712 | 						}
1713 | 					}
1714 | 
1715 | 					callers.pop(); // unstack, we are done
1716 | 					parents.pop();
1717 | 
1718 | 					for ( i in b ) {
1719 | 						bProperties.push( i ); // collect b's properties
1720 | 					}
1721 | 
1722 | 					// Ensures identical properties name
1723 | 					return eq && innerEquiv( aProperties.sort(), bProperties.sort() );
1724 | 				}
1725 | 			};
1726 | 		}());
1727 | 
1728 | 	innerEquiv = function() { // can take multiple arguments
1729 | 		var args = [].slice.apply( arguments );
1730 | 		if ( args.length < 2 ) {
1731 | 			return true; // end transition
1732 | 		}
1733 | 
1734 | 		return (function( a, b ) {
1735 | 			if ( a === b ) {
1736 | 				return true; // catch the most you can
1737 | 			} else if ( a === null || b === null || typeof a === "undefined" ||
1738 | 					typeof b === "undefined" ||
1739 | 					QUnit.objectType(a) !== QUnit.objectType(b) ) {
1740 | 				return false; // don't lose time with error prone cases
1741 | 			} else {
1742 | 				return bindCallbacks(a, callbacks, [ b, a ]);
1743 | 			}
1744 | 
1745 | 			// apply transition with (1..n) arguments
1746 | 		}( args[0], args[1] ) && arguments.callee.apply( this, args.splice(1, args.length - 1 )) );
1747 | 	};
1748 | 
1749 | 	return innerEquiv;
1750 | }());
1751 | 
1752 | /**
1753 |  * jsDump Copyright (c) 2008 Ariel Flesler - aflesler(at)gmail(dot)com |
1754 |  * http://flesler.blogspot.com Licensed under BSD
1755 |  * (http://www.opensource.org/licenses/bsd-license.php) Date: 5/15/2008
1756 |  *
1757 |  * @projectDescription Advanced and extensible data dumping for Javascript.
1758 |  * @version 1.0.0
1759 |  * @author Ariel Flesler
1760 |  * @link {http://flesler.blogspot.com/2008/05/jsdump-pretty-dump-of-any-javascript.html}
1761 |  */
1762 | QUnit.jsDump = (function() {
1763 | 	function quote( str ) {
1764 | 		return '"' + str.toString().replace( /"/g, '\\"' ) + '"';
1765 | 	}
1766 | 	function literal( o ) {
1767 | 		return o + "";
1768 | 	}
1769 | 	function join( pre, arr, post ) {
1770 | 		var s = jsDump.separator(),
1771 | 			base = jsDump.indent(),
1772 | 			inner = jsDump.indent(1);
1773 | 		if ( arr.join ) {
1774 | 			arr = arr.join( "," + s + inner );
1775 | 		}
1776 | 		if ( !arr ) {
1777 | 			return pre + post;
1778 | 		}
1779 | 		return [ pre, inner + arr, base + post ].join(s);
1780 | 	}
1781 | 	function array( arr, stack ) {
1782 | 		var i = arr.length, ret = new Array(i);
1783 | 		this.up();
1784 | 		while ( i-- ) {
1785 | 			ret[i] = this.parse( arr[i] , undefined , stack);
1786 | 		}
1787 | 		this.down();
1788 | 		return join( "[", ret, "]" );
1789 | 	}
1790 | 
1791 | 	var reName = /^function (\w+)/,
1792 | 		jsDump = {
1793 | 			// type is used mostly internally, you can fix a (custom)type in advance
1794 | 			parse: function( obj, type, stack ) {
1795 | 				stack = stack || [ ];
1796 | 				var inStack, res,
1797 | 					parser = this.parsers[ type || this.typeOf(obj) ];
1798 | 
1799 | 				type = typeof parser;
1800 | 				inStack = inArray( obj, stack );
1801 | 
1802 | 				if ( inStack !== -1 ) {
1803 | 					return "recursion(" + (inStack - stack.length) + ")";
1804 | 				}
1805 | 				if ( type === "function" )  {
1806 | 					stack.push( obj );
1807 | 					res = parser.call( this, obj, stack );
1808 | 					stack.pop();
1809 | 					return res;
1810 | 				}
1811 | 				return ( type === "string" ) ? parser : this.parsers.error;
1812 | 			},
1813 | 			typeOf: function( obj ) {
1814 | 				var type;
1815 | 				if ( obj === null ) {
1816 | 					type = "null";
1817 | 				} else if ( typeof obj === "undefined" ) {
1818 | 					type = "undefined";
1819 | 				} else if ( QUnit.is( "regexp", obj) ) {
1820 | 					type = "regexp";
1821 | 				} else if ( QUnit.is( "date", obj) ) {
1822 | 					type = "date";
1823 | 				} else if ( QUnit.is( "function", obj) ) {
1824 | 					type = "function";
1825 | 				} else if ( typeof obj.setInterval !== undefined && typeof obj.document !== "undefined" && typeof obj.nodeType === "undefined" ) {
1826 | 					type = "window";
1827 | 				} else if ( obj.nodeType === 9 ) {
1828 | 					type = "document";
1829 | 				} else if ( obj.nodeType ) {
1830 | 					type = "node";
1831 | 				} else if (
1832 | 					// native arrays
1833 | 					toString.call( obj ) === "[object Array]" ||
1834 | 					// NodeList objects
1835 | 					( typeof obj.length === "number" && typeof obj.item !== "undefined" && ( obj.length ? obj.item(0) === obj[0] : ( obj.item( 0 ) === null && typeof obj[0] === "undefined" ) ) )
1836 | 				) {
1837 | 					type = "array";
1838 | 				} else if ( obj.constructor === Error.prototype.constructor ) {
1839 | 					type = "error";
1840 | 				} else {
1841 | 					type = typeof obj;
1842 | 				}
1843 | 				return type;
1844 | 			},
1845 | 			separator: function() {
1846 | 				return this.multiline ?	this.HTML ? "<br />" : "\n" : this.HTML ? "&nbsp;" : " ";
1847 | 			},
1848 | 			// extra can be a number, shortcut for increasing-calling-decreasing
1849 | 			indent: function( extra ) {
1850 | 				if ( !this.multiline ) {
1851 | 					return "";
1852 | 				}
1853 | 				var chr = this.indentChar;
1854 | 				if ( this.HTML ) {
1855 | 					chr = chr.replace( /\t/g, "   " ).replace( / /g, "&nbsp;" );
1856 | 				}
1857 | 				return new Array( this._depth_ + (extra||0) ).join(chr);
1858 | 			},
1859 | 			up: function( a ) {
1860 | 				this._depth_ += a || 1;
1861 | 			},
1862 | 			down: function( a ) {
1863 | 				this._depth_ -= a || 1;
1864 | 			},
1865 | 			setParser: function( name, parser ) {
1866 | 				this.parsers[name] = parser;
1867 | 			},
1868 | 			// The next 3 are exposed so you can use them
1869 | 			quote: quote,
1870 | 			literal: literal,
1871 | 			join: join,
1872 | 			//
1873 | 			_depth_: 1,
1874 | 			// This is the list of parsers, to modify them, use jsDump.setParser
1875 | 			parsers: {
1876 | 				window: "[Window]",
1877 | 				document: "[Document]",
1878 | 				error: function(error) {
1879 | 					return "Error(\"" + error.message + "\")";
1880 | 				},
1881 | 				unknown: "[Unknown]",
1882 | 				"null": "null",
1883 | 				"undefined": "undefined",
1884 | 				"function": function( fn ) {
1885 | 					var ret = "function",
1886 | 						// functions never have name in IE
1887 | 						name = "name" in fn ? fn.name : (reName.exec(fn) || [])[1];
1888 | 
1889 | 					if ( name ) {
1890 | 						ret += " " + name;
1891 | 					}
1892 | 					ret += "( ";
1893 | 
1894 | 					ret = [ ret, QUnit.jsDump.parse( fn, "functionArgs" ), "){" ].join( "" );
1895 | 					return join( ret, QUnit.jsDump.parse(fn,"functionCode" ), "}" );
1896 | 				},
1897 | 				array: array,
1898 | 				nodelist: array,
1899 | 				"arguments": array,
1900 | 				object: function( map, stack ) {
1901 | 					var ret = [ ], keys, key, val, i;
1902 | 					QUnit.jsDump.up();
1903 | 					keys = [];
1904 | 					for ( key in map ) {
1905 | 						keys.push( key );
1906 | 					}
1907 | 					keys.sort();
1908 | 					for ( i = 0; i < keys.length; i++ ) {
1909 | 						key = keys[ i ];
1910 | 						val = map[ key ];
1911 | 						ret.push( QUnit.jsDump.parse( key, "key" ) + ": " + QUnit.jsDump.parse( val, undefined, stack ) );
1912 | 					}
1913 | 					QUnit.jsDump.down();
1914 | 					return join( "{", ret, "}" );
1915 | 				},
1916 | 				node: function( node ) {
1917 | 					var len, i, val,
1918 | 						open = QUnit.jsDump.HTML ? "&lt;" : "<",
1919 | 						close = QUnit.jsDump.HTML ? "&gt;" : ">",
1920 | 						tag = node.nodeName.toLowerCase(),
1921 | 						ret = open + tag,
1922 | 						attrs = node.attributes;
1923 | 
1924 | 					if ( attrs ) {
1925 | 						for ( i = 0, len = attrs.length; i < len; i++ ) {
1926 | 							val = attrs[i].nodeValue;
1927 | 							// IE6 includes all attributes in .attributes, even ones not explicitly set.
1928 | 							// Those have values like undefined, null, 0, false, "" or "inherit".
1929 | 							if ( val && val !== "inherit" ) {
1930 | 								ret += " " + attrs[i].nodeName + "=" + QUnit.jsDump.parse( val, "attribute" );
1931 | 							}
1932 | 						}
1933 | 					}
1934 | 					ret += close;
1935 | 
1936 | 					// Show content of TextNode or CDATASection
1937 | 					if ( node.nodeType === 3 || node.nodeType === 4 ) {
1938 | 						ret += node.nodeValue;
1939 | 					}
1940 | 
1941 | 					return ret + open + "/" + tag + close;
1942 | 				},
1943 | 				// function calls it internally, it's the arguments part of the function
1944 | 				functionArgs: function( fn ) {
1945 | 					var args,
1946 | 						l = fn.length;
1947 | 
1948 | 					if ( !l ) {
1949 | 						return "";
1950 | 					}
1951 | 
1952 | 					args = new Array(l);
1953 | 					while ( l-- ) {
1954 | 						// 97 is 'a'
1955 | 						args[l] = String.fromCharCode(97+l);
1956 | 					}
1957 | 					return " " + args.join( ", " ) + " ";
1958 | 				},
1959 | 				// object calls it internally, the key part of an item in a map
1960 | 				key: quote,
1961 | 				// function calls it internally, it's the content of the function
1962 | 				functionCode: "[code]",
1963 | 				// node calls it internally, it's an html attribute value
1964 | 				attribute: quote,
1965 | 				string: quote,
1966 | 				date: quote,
1967 | 				regexp: literal,
1968 | 				number: literal,
1969 | 				"boolean": literal
1970 | 			},
1971 | 			// if true, entities are escaped ( <, >, \t, space and \n )
1972 | 			HTML: false,
1973 | 			// indentation unit
1974 | 			indentChar: "  ",
1975 | 			// if true, items in a collection, are separated by a \n, else just a space.
1976 | 			multiline: true
1977 | 		};
1978 | 
1979 | 	return jsDump;
1980 | }());
1981 | 
1982 | // from jquery.js
1983 | function inArray( elem, array ) {
1984 | 	if ( array.indexOf ) {
1985 | 		return array.indexOf( elem );
1986 | 	}
1987 | 
1988 | 	for ( var i = 0, length = array.length; i < length; i++ ) {
1989 | 		if ( array[ i ] === elem ) {
1990 | 			return i;
1991 | 		}
1992 | 	}
1993 | 
1994 | 	return -1;
1995 | }
1996 | 
1997 | /*
1998 |  * Javascript Diff Algorithm
1999 |  *  By John Resig (http://ejohn.org/)
2000 |  *  Modified by Chu Alan "sprite"
2001 |  *
2002 |  * Released under the MIT license.
2003 |  *
2004 |  * More Info:
2005 |  *  http://ejohn.org/projects/javascript-diff-algorithm/
2006 |  *
2007 |  * Usage: QUnit.diff(expected, actual)
2008 |  *
2009 |  * QUnit.diff( "the quick brown fox jumped over", "the quick fox jumps over" ) == "the  quick <del>brown </del> fox <del>jumped </del><ins>jumps </ins> over"
2010 |  */
2011 | QUnit.diff = (function() {
2012 | 	/*jshint eqeqeq:false, eqnull:true */
2013 | 	function diff( o, n ) {
2014 | 		var i,
2015 | 			ns = {},
2016 | 			os = {};
2017 | 
2018 | 		for ( i = 0; i < n.length; i++ ) {
2019 | 			if ( !hasOwn.call( ns, n[i] ) ) {
2020 | 				ns[ n[i] ] = {
2021 | 					rows: [],
2022 | 					o: null
2023 | 				};
2024 | 			}
2025 | 			ns[ n[i] ].rows.push( i );
2026 | 		}
2027 | 
2028 | 		for ( i = 0; i < o.length; i++ ) {
2029 | 			if ( !hasOwn.call( os, o[i] ) ) {
2030 | 				os[ o[i] ] = {
2031 | 					rows: [],
2032 | 					n: null
2033 | 				};
2034 | 			}
2035 | 			os[ o[i] ].rows.push( i );
2036 | 		}
2037 | 
2038 | 		for ( i in ns ) {
2039 | 			if ( !hasOwn.call( ns, i ) ) {
2040 | 				continue;
2041 | 			}
2042 | 			if ( ns[i].rows.length === 1 && hasOwn.call( os, i ) && os[i].rows.length === 1 ) {
2043 | 				n[ ns[i].rows[0] ] = {
2044 | 					text: n[ ns[i].rows[0] ],
2045 | 					row: os[i].rows[0]
2046 | 				};
2047 | 				o[ os[i].rows[0] ] = {
2048 | 					text: o[ os[i].rows[0] ],
2049 | 					row: ns[i].rows[0]
2050 | 				};
2051 | 			}
2052 | 		}
2053 | 
2054 | 		for ( i = 0; i < n.length - 1; i++ ) {
2055 | 			if ( n[i].text != null && n[ i + 1 ].text == null && n[i].row + 1 < o.length && o[ n[i].row + 1 ].text == null &&
2056 | 						n[ i + 1 ] == o[ n[i].row + 1 ] ) {
2057 | 
2058 | 				n[ i + 1 ] = {
2059 | 					text: n[ i + 1 ],
2060 | 					row: n[i].row + 1
2061 | 				};
2062 | 				o[ n[i].row + 1 ] = {
2063 | 					text: o[ n[i].row + 1 ],
2064 | 					row: i + 1
2065 | 				};
2066 | 			}
2067 | 		}
2068 | 
2069 | 		for ( i = n.length - 1; i > 0; i-- ) {
2070 | 			if ( n[i].text != null && n[ i - 1 ].text == null && n[i].row > 0 && o[ n[i].row - 1 ].text == null &&
2071 | 						n[ i - 1 ] == o[ n[i].row - 1 ]) {
2072 | 
2073 | 				n[ i - 1 ] = {
2074 | 					text: n[ i - 1 ],
2075 | 					row: n[i].row - 1
2076 | 				};
2077 | 				o[ n[i].row - 1 ] = {
2078 | 					text: o[ n[i].row - 1 ],
2079 | 					row: i - 1
2080 | 				};
2081 | 			}
2082 | 		}
2083 | 
2084 | 		return {
2085 | 			o: o,
2086 | 			n: n
2087 | 		};
2088 | 	}
2089 | 
2090 | 	return function( o, n ) {
2091 | 		o = o.replace( /\s+$/, "" );
2092 | 		n = n.replace( /\s+$/, "" );
2093 | 
2094 | 		var i, pre,
2095 | 			str = "",
2096 | 			out = diff( o === "" ? [] : o.split(/\s+/), n === "" ? [] : n.split(/\s+/) ),
2097 | 			oSpace = o.match(/\s+/g),
2098 | 			nSpace = n.match(/\s+/g);
2099 | 
2100 | 		if ( oSpace == null ) {
2101 | 			oSpace = [ " " ];
2102 | 		}
2103 | 		else {
2104 | 			oSpace.push( " " );
2105 | 		}
2106 | 
2107 | 		if ( nSpace == null ) {
2108 | 			nSpace = [ " " ];
2109 | 		}
2110 | 		else {
2111 | 			nSpace.push( " " );
2112 | 		}
2113 | 
2114 | 		if ( out.n.length === 0 ) {
2115 | 			for ( i = 0; i < out.o.length; i++ ) {
2116 | 				str += "<del>" + out.o[i] + oSpace[i] + "</del>";
2117 | 			}
2118 | 		}
2119 | 		else {
2120 | 			if ( out.n[0].text == null ) {
2121 | 				for ( n = 0; n < out.o.length && out.o[n].text == null; n++ ) {
2122 | 					str += "<del>" + out.o[n] + oSpace[n] + "</del>";
2123 | 				}
2124 | 			}
2125 | 
2126 | 			for ( i = 0; i < out.n.length; i++ ) {
2127 | 				if (out.n[i].text == null) {
2128 | 					str += "<ins>" + out.n[i] + nSpace[i] + "</ins>";
2129 | 				}
2130 | 				else {
2131 | 					// `pre` initialized at top of scope
2132 | 					pre = "";
2133 | 
2134 | 					for ( n = out.n[i].row + 1; n < out.o.length && out.o[n].text == null; n++ ) {
2135 | 						pre += "<del>" + out.o[n] + oSpace[n] + "</del>";
2136 | 					}
2137 | 					str += " " + out.n[i].text + nSpace[i] + pre;
2138 | 				}
2139 | 			}
2140 | 		}
2141 | 
2142 | 		return str;
2143 | 	};
2144 | }());
2145 | 
2146 | // for CommonJS enviroments, export everything
2147 | if ( typeof exports !== "undefined" ) {
2148 | 	extend( exports, QUnit );
2149 | }
2150 | 
2151 | // get at whatever the global object is, like window in browsers
2152 | }( (function() {return this;}.call()) ));
2153 | 


--------------------------------------------------------------------------------