An element in the DOM can also be selected and inserted after another element:
$('.container').after($('h2'));If an element selected this way is inserted elsewhere, it will be moved rather than cloned:
+If an element selected this way is inserted into a single location elsewhere in the DOM, it will be moved rather than cloned:
<div class="container">
<div class="inner">Hello</div>
<div class="inner">Goodbye</div>
@@ -95,4 +95,4 @@ $('p').first().after($newdiv1, [newdiv2, existingdiv1]);
You can also select an element on the page and insert it into another:
$('.container').append($('h2'));
- If an element selected this way is inserted elsewhere, it will be moved into the target (not cloned):
+ If an element selected this way is inserted into a single location elsewhere in the DOM, it will be moved into the target (not cloned):
<div class="container">
<div class="inner">Hello</div>
<div class="inner">Goodbye</div>
@@ -100,4 +100,4 @@ $('body').append($newdiv1, [newdiv2, existingdiv1]);
We can also select an element on the page and insert it into another:
$('h2').appendTo($('.container'));
- If an element selected this way is inserted elsewhere, it will be moved into the target (not cloned):
+ If an element selected this way is inserted into a single location elsewhere in the DOM, it will be moved into the target (not cloned):
<div class="container">
<div class="inner">Hello</div>
<div class="inner">Goodbye</div>
@@ -55,4 +55,4 @@
You can also select an element on the page and insert it before another:
$('.container').before($('h2'));
- If an element selected this way is inserted elsewhere, it will be moved before the target (not cloned):
+ If an element selected this way is inserted into a single location elsewhere in the DOM, it will be moved before the target (not cloned):
<h2>Greetings</h2>
<div class="container">
<div class="inner">Hello</div>
@@ -80,4 +80,4 @@ $('p').first().before($newdiv1, [newdiv2, existingdiv1]);
We can also select an element on the page and insert it after another:
$('h2').insertAfter($('.container'));
- If an element selected this way is inserted elsewhere, it will be moved after the target (not cloned):
+ If an element selected this way is inserted into a single location elsewhere in the DOM, it will be moved after the target (not cloned):
<div class="container">
<div class="inner">Hello</div>
<div class="inner">Goodbye</div>
@@ -44,4 +44,4 @@
We can also select an element on the page and insert it before another:
$('h2').insertBefore($('.container'));
- If an element selected this way is inserted elsewhere, it will be moved before the target (not cloned):
+ If an element selected this way is inserted into a single location elsewhere in the DOM, it will be moved before the target (not cloned):
<h2>Greetings</h2>
<div class="container">
<div class="inner">Hello</div>
@@ -44,4 +44,4 @@
You can also select an element on the page and insert it into another:
$('.container').prepend($('h2'));
- If a single element selected this way is inserted elsewhere, it will be moved into the target (not cloned):
+ If a single element selected this way is inserted into a single location elsewhere in the DOM, it will be moved into the target (not cloned):
<div class="container">
<h2>Greetings</h2>
<div class="inner">Hello</div>
@@ -84,4 +84,4 @@ $('body').prepend($newdiv1, [newdiv2, existingdiv1]);
We can also select an element on the page and insert it into another:
$('h2').prependTo($('.container'));
- If an element selected this way is inserted elsewhere, it will be moved into the target (not cloned):
+ If an element selected this way is inserted into a single location elsewhere in the DOM, it will be moved into the target (not cloned):
<div class="container">
<h2>Greetings</h2>
<div class="inner">Hello</div>
@@ -50,4 +50,4 @@
Date: Fri, 19 Oct 2012 09:07:41 -0400
Subject: [PATCH 002/998] fixes 139 - With/Without example
---
entries/andSelf.xml | 32 +++++++++++++++++++++++---------
1 file changed, 23 insertions(+), 9 deletions(-)
diff --git a/entries/andSelf.xml b/entries/andSelf.xml
index c44f26b3..67e2f1c3 100644
--- a/entries/andSelf.xml
+++ b/entries/andSelf.xml
@@ -26,19 +26,33 @@
Find all divs, and all the paragraphs inside of them, and give them both class names. Notice the div doesn't have the yellow background color since it didn't use .andSelf().
After andSelf()
+
+ First Paragraph
+ Second Paragraph
+
+
+]]>
Date: Sun, 21 Oct 2012 14:37:40 -0400
Subject: [PATCH 003/998] Add Version 1.8 to list of categories.
---
categories.xml | 8 ++++++++
1 file changed, 8 insertions(+)
diff --git a/categories.xml b/categories.xml
index fa18b86d..d23dfa1b 100644
--- a/categories.xml
+++ b/categories.xml
@@ -365,6 +365,14 @@
]]>
+
+
Date: Sun, 21 Oct 2012 14:38:06 -0400
Subject: [PATCH 004/998] Add -index signature to :eq() selector
---
entries/eq-selector.xml | 43 +++++++++++++++++++++++++++++++++++------
1 file changed, 37 insertions(+), 6 deletions(-)
diff --git a/entries/eq-selector.xml b/entries/eq-selector.xml
index f312b6b0..06f56f4f 100644
--- a/entries/eq-selector.xml
+++ b/entries/eq-selector.xml
@@ -1,18 +1,25 @@
:eq() Selector
- :eq(index)
+ :eq(index)
1.0
Zero-based index of the element to match.
+
+ :eq(-index)
+ 1.8
+
+ Zero-based index of the element to match, counting backwards from the last element.
+
+
Select the element at index n within the matched set.
The index-related selectors (:eq(), :lt(), :gt(), :even, :odd) filter the set of elements that have matched the expressions that precede them. They narrow the set down based on the order of the elements within this matched set. For example, if elements are first selected with a class selector (.myclass) and four elements are returned, these elements are given indices 0 through 3 for the purposes of these selectors.
Note that since JavaScript arrays use 0-based indexing, these selectors reflect that fact. This is why $('.myclass:eq(1)') selects the second element in the document with the class myclass, rather than the first. In contrast, :nth-child(n) uses 1-based indexing to conform to the CSS specification.
- Unlike the .eq(index) method, the :eq(index) selector does not accept a negative value for index. For example, while $('li').eq(-1) selects the last li element, $('li:eq(-1)') selects nothing.
+ Prior to jQuery 1.8, the :eq(index) selector did not accept a negative value for index (though the .eq(index) method did).
@@ -28,16 +35,16 @@
160
Apply three different styles to list items to demonstrate that :eq() is designed to select a single element while :nth-child() or :eq() within a looping construct such as .each() can select multiple elements.
+
+ Add a class to List 2, item 2 by targeting the second to last <li>
+
From 2f66d1d763173b1c85f637aec7839e778161fdde Mon Sep 17 00:00:00 2001
From: Karl Swedberg
Date: Sun, 21 Oct 2012 17:44:20 -0400
Subject: [PATCH 005/998] Add note to global ajax event method about effect of
`global:false`
* Fixes #138
---
entries/ajaxComplete.xml | 1 +
entries/ajaxError.xml | 1 +
entries/ajaxSend.xml | 1 +
entries/ajaxStart.xml | 1 +
entries/ajaxStop.xml | 1 +
entries/ajaxSuccess.xml | 1 +
notes.xsl | 3 +++
7 files changed, 9 insertions(+)
diff --git a/entries/ajaxComplete.xml b/entries/ajaxComplete.xml
index f8a9b5d3..0a321e36 100644
--- a/entries/ajaxComplete.xml
+++ b/entries/ajaxComplete.xml
@@ -35,6 +35,7 @@
}
});
+
Show a message when an Ajax request completes.
Register a handler to be called when Ajax requests complete. This is an AjaxEvent.
Whenever an Ajax request completes, jQuery triggers the ajaxComplete event. Any and all handlers that have been registered with the .ajaxComplete() method are executed at this time.
- To observe this method in action, we can set up a basic Ajax load request:
+ To observe this method in action, set up a basic Ajax load request:
<div class="trigger">Trigger</div>
<div class="result"></div>
<div class="log"></div>
- We can attach our event handler to any element:
- $('.log').ajaxComplete(function() {
- $(this).text('Triggered ajaxComplete handler.');
+ Attach the event handler to the document:
+ $(document).ajaxComplete(function() {
+ $( ".log" ).text( "Triggered ajaxComplete handler." );
});
- Now, we can make an Ajax request using any jQuery method:
- $('.trigger').click(function() {
- $('.result').load('ajax/test.html');
+ Now, make an Ajax request using any jQuery method:
+ $( ".trigger" ).click(function() {
+ $( ".result" ).load( "ajax/test.html" );
});
When the user clicks the element with class trigger and the Ajax request completes, the log message is displayed.
- Note: Because .ajaxComplete() is implemented as a method of jQuery object instances, we can use the this keyword as we do here to refer to the selected elements within the callback function.
- All ajaxComplete handlers are invoked, regardless of what Ajax request was completed. If we must differentiate between the requests, we can use the parameters passed to the handler. Each time an ajaxComplete handler is executed, it is passed the event object, the XMLHttpRequest object, and the settings object that was used in the creation of the request. For example, we can restrict our callback to only handling events dealing with a particular URL:
- Note: You can get the returned ajax contents by looking at xhr.responseXML or xhr.responseHTML for xml and html respectively.
- $('.log').ajaxComplete(function(e, xhr, settings) {
- if (settings.url == 'ajax/test.html') {
- $(this).text('Triggered ajaxComplete handler. The result is ' +
- xhr.responseHTML);
+ Note: Because .ajaxComplete() is implemented as a method of jQuery object instances, you can use the this keyword to refer to the selected elements within the callback function. As of jQuery 1.8, however, the .ajaxComplete() method should only be attached to document.
+ All ajaxComplete handlers are invoked, regardless of what Ajax request was completed. If you must differentiate between the requests, use the parameters passed to the handler. Each time an ajaxComplete handler is executed, it is passed the event object, the XMLHttpRequest object, and the settings object that was used in the creation of the request. For example, you can restrict the callback to only handling events dealing with a particular URL:
+ $(document).ajaxComplete(function(event, xhr, settings) {
+ if ( settings.url === "ajax/test.html" ) {
+ $( ".log" ).text( "Triggered ajaxComplete handler. The result is " +
+ xhr.responseHTML );
}
});
+ Note: You can get the returned ajax contents by looking at xhr.responseXML or xhr.responseHTML for xml and html respectively.
Show a message when an Ajax request completes.
-
<button class="trigger">Trigger</button>
<div class="result"></div>
<div class="log"></div>
- Attach the event handler to any element:
- $("div.log").ajaxError(function() {
- $(this).text( "Triggered ajaxError handler." );
+ Attach the event handler to the document:
+ $(document).ajaxError(function() {
+ $( "div.log" ).text( "Triggered ajaxError handler." );
});
Now, make an Ajax request using any jQuery method:
- $("button.trigger").click(function() {
- $("div.result").load( "ajax/missing.html" );
+ $( "button.trigger" ).click(function() {
+ $( "div.result" ).load( "ajax/missing.html" );
});
When the user clicks the button and the Ajax request fails, because the requested file is missing, the log message is displayed.
- Note: Because .ajaxError() is implemented as a method of jQuery object instances, you can use the this keyword within the callback function to refer to the selected elements.
- All ajaxError handlers are invoked, regardless of what Ajax request was completed. To differentiate between the requests, you can use the parameters passed to the handler. Each time an ajaxError handler is executed, it is passed the event object, the jqXHR object (prior to jQuery 1.5, the XHR object), and the settings object that was used in the creation of the request. If the request failed because JavaScript raised an exception, the exception object is passed to the handler as a fourth parameter. For example, to restrict the error callback to only handling events dealing with a particular URL:
- $( "div.log" ).ajaxError(function(e, jqxhr, settings, exception) {
+ Note: Because .ajaxError() is implemented as a method of jQuery object instances, you can use the this keyword within the callback function to refer to the selected elements. As of jQuery 1.8, however, the .ajaxError() method should only be attached to document.
+ All ajaxError handlers are invoked, regardless of what Ajax request was completed. To differentiate between the requests, use the parameters passed to the handler. Each time an ajaxError handler is executed, it is passed the event object, the jqXHR object (prior to jQuery 1.5, the XHR object), and the settings object that was used in the creation of the request. If the request failed because JavaScript raised an exception, the exception object is passed to the handler as a fourth parameter. For example, to restrict the error callback to only handling events dealing with a particular URL:
+ $( document ).ajaxError(function(event, jqxhr, settings, exception) {
if ( settings.url == "ajax/missing.html" ) {
- $(this).text( "Triggered ajaxError handler." );
+ $( "div.log" ).text( "Triggered ajaxError handler." );
}
});
Show a message when an Ajax request fails.
-
Attach a function to be executed before an Ajax request is sent. This is an Ajax Event.
Whenever an Ajax request is about to be sent, jQuery triggers the ajaxSend event. Any and all handlers that have been registered with the .ajaxSend() method are executed at this time.
- To observe this method in action, we can set up a basic Ajax load request:
+ To observe this method in action, set up a basic Ajax load request:
<div class="trigger">Trigger</div>
<div class="result"></div>
<div class="log"></div>
- We can attach our event handler to any element:
- $('.log').ajaxSend(function() {
- $(this).text('Triggered ajaxSend handler.');
+ Attach the event handler to the document:
+ $(document).ajaxSend(function() {
+ $( ".log" ).text( "Triggered ajaxSend handler." );
});
- Now, we can make an Ajax request using any jQuery method:
- $('.trigger').click(function() {
- $('.result').load('ajax/test.html');
+ Now, make an Ajax request using any jQuery method:
+ $( ".trigger" ).click(function() {
+ $( ".result" ).load( "ajax/test.html" );
});
When the user clicks the element with class trigger and the Ajax request is about to begin, the log message is displayed.
- Note: Because .ajaxSend() is implemented as a method of jQuery instances, we can use the this keyword as we do here to refer to the selected elements within the callback function.
- All ajaxSend handlers are invoked, regardless of what Ajax request is to be sent. If we must differentiate between the requests, we can use the parameters passed to the handler. Each time an ajaxSend handler is executed, it is passed the event object, the jqXHR object (in version 1.4, XMLHttpRequestobject), and the settings object that was used in the creation of the Ajax request. For example, we can restrict our callback to only handling events dealing with a particular URL:
- $('.log').ajaxSend(function(e, jqxhr, settings) {
- if (settings.url == 'ajax/test.html') {
- $(this).text('Triggered ajaxSend handler.');
+ Note: Because .ajaxSend() is implemented as a method of jQuery instances, you can use the this keyword to refer to the selected elements within the callback function. As of jQuery 1.8, however, the .ajaxSend() method should only be attached to document.
+ All ajaxSend handlers are invoked, regardless of what Ajax request is to be sent. If you must differentiate between the requests, use the parameters passed to the handler. Each time an ajaxSend handler is executed, it is passed the event object, the jqXHR object (in version 1.4, XMLHttpRequestobject), and the settings object that was used in the creation of the Ajax request. For example, you can restrict the callback to only handling events dealing with a particular URL:
+ $(document).ajaxSend(function(event, jqxhr, settings) {
+ if ( settings.url == "ajax/test.html" ) {
+ $( ".log" ).text( "Triggered ajaxSend handler." );
}
});
Show a message before an Ajax request is sent.
-
The function to be invoked.
- Register a handler to be called when the first Ajax request begins. This is an Ajax Event.
+ Register a handler to be called when the first Ajax request begins. This is an Ajax Event.
Whenever an Ajax request is about to be sent, jQuery checks whether there are any other outstanding Ajax requests. If none are in progress, jQuery triggers the ajaxStart event. Any and all handlers that have been registered with the .ajaxStart() method are executed at this time.
- To observe this method in action, we can set up a basic Ajax load request:
+ To observe this method in action, set up a basic Ajax load request:
<div class="trigger">Trigger</div>
<div class="result"></div>
<div class="log"></div>
- We can attach our event handler to any element:
- $('.log').ajaxStart(function() {
- $(this).text('Triggered ajaxStart handler.');
+ Attach the event handler to any element:
+ $(document).ajaxStart(function() {
+ $( ".log" ).text( "Triggered ajaxStart handler." );
});
- Now, we can make an Ajax request using any jQuery method:
- $('.trigger').click(function() {
- $('.result').load('ajax/test.html');
+ Now, make an Ajax request using any jQuery method:
+ $( ".trigger" ).click(function() {
+ $( ".result" ).load("ajax/test.html");
});
When the user clicks the element with class trigger and the Ajax request is sent, the log message is displayed.
- Note: Because .ajaxStart() is implemented as a method of jQuery object instances, we can use the this keyword as we do here to refer to the selected elements within the callback function.
+ Note: Because .ajaxStart() is implemented as a method of jQuery object instances, you can use the this keyword to refer to the selected elements within the callback function. As of jQuery 1.8, however, the .ajaxStart() method should only be attached to document.
Show a loading message whenever an Ajax request starts (and none is already active).
-
.ajaxStop()
- Register a handler to be called when all Ajax requests have completed. This is an Ajax Event.
+ Register a handler to be called when all Ajax requests have completed. This is an Ajax Event.
1.0
@@ -10,26 +10,26 @@
Whenever an Ajax request completes, jQuery checks whether there are any other outstanding Ajax requests. If none remain, jQuery triggers the ajaxStop event. Any and all handlers that have been registered with the .ajaxStop() method are executed at this time. The ajaxStop event is also triggered if the last outstanding Ajax request is cancelled by returning false within the beforeSend callback function.
- To observe this method in action, we can set up a basic Ajax load request:
+ To observe this method in action, set up a basic Ajax load request:
<div class="trigger">Trigger</div>
<div class="result"></div>
<div class="log"></div>
- We can attach our event handler to any element:
- $('.log').ajaxStop(function() {
- $(this).text('Triggered ajaxStop handler.');
+ Attach the event handler to the document:
+ $( ".log" ).ajaxStop(function() {
+ $(this).text( "Triggered ajaxStop handler." );
});
- Now, we can make an Ajax request using any jQuery method:
- $('.trigger').click(function() {
- $('.result').load('ajax/test.html');
+ Now, make an Ajax request using any jQuery method:
+ $( ".trigger" ).click(function() {
+ $( ".result" ).load( "ajax/test.html" );
});
When the user clicks the element with class trigger and the Ajax request completes, the log message is displayed.
- Because .ajaxStop() is implemented as a method of jQuery object instances, we can use the this keyword as we do here to refer to the selected elements within the callback function.
+ Because .ajaxStop() is implemented as a method of jQuery object instances, you can use the this keyword to refer to the selected elements within the callback function. As of jQuery 1.8, however, the .ajaxStop() method should only be attached to document.
Hide a loading message after all the Ajax requests have stopped.
-
The function to be invoked.
- Attach a function to be executed whenever an Ajax request completes successfully. This is an Ajax Event.
+ Attach a function to be executed whenever an Ajax request completes successfully. This is an Ajax Event.
Whenever an Ajax request completes successfully, jQuery triggers the ajaxSuccess event. Any and all handlers that have been registered with the .ajaxSuccess() method are executed at this time.
- To observe this method in action, we can set up a basic Ajax load request:
+ To observe this method in action, set up a basic Ajax load request:
<div class="trigger">Trigger</div>
<div class="result"></div>
<div class="log"></div>
- We can attach our event handler to any element:
- $('.log').ajaxSuccess(function() {
- $(this).text('Triggered ajaxSuccess handler.');
+ Attach the event handler to any element:
+ $(document).ajaxSuccess(function() {
+ $( ".log" ).text( "Triggered ajaxSuccess handler." );
});
- Now, we can make an Ajax request using any jQuery method:
- $('.trigger').click(function() {
- $('.result').load('ajax/test.html');
+ Now, make an Ajax request using any jQuery method:
+ $( ".trigger" ).on("click", function() {
+ $( ".result" ).load( "ajax/test.html" );
});
When the user clicks the element with class trigger and the Ajax request completes successfully, the log message is displayed.
- Note: Because .ajaxSuccess() is implemented as a method of jQuery object instances, we can use the this keyword as we do here to refer to the selected elements within the callback function.
- All ajaxSuccess handlers are invoked, regardless of what Ajax request was completed. If we must differentiate between the requests, we can use the parameters passed to the handler. Each time an ajaxSuccess handler is executed, it is passed the event object, the XMLHttpRequest object, and the settings object that was used in the creation of the request. For example, we can restrict our callback to only handling events dealing with a particular URL:
- Note: You can get the returned ajax contents by looking at xhr.responseXML or xhr.responseText for xml and html respectively.
- $('.log').ajaxSuccess(function(e, xhr, settings) {
- if (settings.url == 'ajax/test.html') {
- $(this).text('Triggered ajaxSuccess handler. The ajax response was:'
- + xhr.responseText );
+ Note: Because .ajaxSuccess() is implemented as a method of jQuery object instances, use the this keyword to refer to the selected elements within the callback function. As of jQuery 1.8, however, the .ajaxSuccess() method should only be attached to document.
+ All ajaxSuccess handlers are invoked, regardless of what Ajax request was completed. If you must differentiate between the requests, you can use the parameters passed to the handler. Each time an ajaxSuccess handler is executed, it is passed the event object, the XMLHttpRequest object, and the settings object that was used in the creation of the request. For example, you can restrict the callback to only handling events dealing with a particular URL:
+ $(document).ajaxSuccess(function(event, xhr, settings) {
+ if ( settings.url == "ajax/test.html" ) {
+ $( ".log" ).text( "Triggered ajaxSuccess handler. The ajax response was: " +
+ xhr.responseText );
}
});
+ Note: You can get the returned ajax contents by looking at xhr.responseXML or xhr.responseText for xml and html respectively.
Show a message when an Ajax request completes successfully.
-
Date: Sun, 21 Oct 2012 20:23:53 -0400
Subject: [PATCH 007/998] Fix grunt lint, move use-strict into function where
it needs to be
---
grunt.js | 3 +--
1 file changed, 1 insertion(+), 2 deletions(-)
diff --git a/grunt.js b/grunt.js
index 17b522c7..41456718 100644
--- a/grunt.js
+++ b/grunt.js
@@ -1,7 +1,6 @@
/*jshint node:true */
-"use strict";
-
module.exports = function( grunt ) {
+"use strict";
var entryFiles = grunt.file.expandFiles( "entries/*.xml" );
From aca4122984fdd5631509f44faf44635c52b6e54b Mon Sep 17 00:00:00 2001
From: Karl Swedberg
Date: Sun, 21 Oct 2012 20:50:16 -0400
Subject: [PATCH 008/998] Emphasize that $.extend() cannot take false as first
arg. Fixes #121
---
entries/jQuery.extend.xml | 11 ++++++-----
1 file changed, 6 insertions(+), 5 deletions(-)
diff --git a/entries/jQuery.extend.xml b/entries/jQuery.extend.xml
index fe88f2a6..2007fa65 100644
--- a/entries/jQuery.extend.xml
+++ b/entries/jQuery.extend.xml
@@ -30,11 +30,12 @@
Merge the contents of two or more objects together into the first object.
- When we supply two or more objects to $.extend(), properties from all of the objects are added to the target object.
- If only one argument is supplied to $.extend(), this means the target argument was omitted. In this case, the jQuery object itself is assumed to be the target. By doing this, we can add new functions to the jQuery namespace. This can be useful for plugin authors wishing to add new methods to JQuery.
- Keep in mind that the target object (first argument) will be modified, and will also be returned from $.extend(). If, however, we want to preserve both of the original objects, we can do so by passing an empty object as the target:
+ When two or more objects are supplied to $.extend(), properties from all of the objects are added to the target object.
+ If only one argument is supplied to $.extend(), this means the target argument was omitted. In this case, the jQuery object itself is assumed to be the target. By doing this, you can add new functions to the jQuery namespace. This can be useful for plugin authors wishing to add new methods to JQuery.
+ Keep in mind that the target object (first argument) will be modified, and will also be returned from $.extend(). If, however, you want to preserve both of the original objects, you can do so by passing an empty object as the target:
var object = $.extend({}, object1, object2);
- The merge performed by $.extend() is not recursive by default; if a property of the first object is itself an object or array, it will be completely overwritten by a property with the same key in the second object. The values are not merged. This can be seen in the example below by examining the value of banana. However, by passing true for the first function argument, objects will be recursively merged. (Passing false for the first argument is not supported.)
+ The merge performed by $.extend() is not recursive by default; if a property of the first object is itself an object or array, it will be completely overwritten by a property with the same key in the second object. The values are not merged. This can be seen in the example below by examining the value of banana. However, by passing true for the first function argument, objects will be recursively merged.
+ Warning: Passing false for the first argument is not supported.
Undefined properties are not copied. However, properties inherited from the object's prototype will be copied over. Properties that are an object constructed via new MyCustomObject(args), or built-in JavaScript types such as Date or RegExp, are not re-constructed and will appear as plain Objects in the resulting object or array.
On a deep extend, Object and Array are extended, but object wrappers on primitive types such as String, Boolean, and Number are not.
For needs that fall outside of this behavior, write a custom extend method instead.
@@ -134,4 +135,4 @@ $("#log").append( "settings -- " + printObj(settings) + "" );
Date: Sun, 21 Oct 2012 21:09:18 -0400
Subject: [PATCH 009/998] jQuery.when(): Add "or Promise". Fixes #145
---
entries/jQuery.when.xml | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/entries/jQuery.when.xml b/entries/jQuery.when.xml
index deb6e852..30dde8ff 100644
--- a/entries/jQuery.when.xml
+++ b/entries/jQuery.when.xml
@@ -13,7 +13,7 @@
$.when( $.ajax("test.aspx") ).then(function(data, textStatus, jqXHR){
alert( jqXHR.status ); // alerts 200
});
- If a single argument is passed to jQuery.when and it is not a Deferred, it will be treated as a resolved Deferred and any doneCallbacks attached will be executed immediately. The doneCallbacks are passed the original argument. In this case any failCallbacks you might set are never called since the Deferred is never rejected. For example:
+ If a single argument is passed to jQuery.when and it is not a Deferred or a Promise, it will be treated as a resolved Deferred and any doneCallbacks attached will be executed immediately. The doneCallbacks are passed the original argument. In this case any failCallbacks you might set are never called since the Deferred is never rejected. For example:
$.when( { testing: 123 } ).done(
function(x) { alert(x.testing); } /* alerts "123" */
);
From 375c308e690ed24805f829db46985db7b69fe362 Mon Sep 17 00:00:00 2001
From: Dave Methvin
Date: Fri, 26 Oct 2012 12:00:36 -0300
Subject: [PATCH 010/998] Clarify return value when a selector is used
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
See http://bugs.jquery.com/ticket/12792 .
---
entries/index.xml | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/entries/index.xml b/entries/index.xml
index cc7b2cd9..416253c8 100644
--- a/entries/index.xml
+++ b/entries/index.xml
@@ -21,7 +21,7 @@
Return Values
If no argument is passed to the .index() method, the return value is an integer indicating the position of the first element within the jQuery object relative to its sibling elements.
If .index() is called on a collection of elements and a DOM element or jQuery object is passed in, .index() returns an integer indicating the position of the passed element relative to the original collection.
- If a selector string is passed as an argument, .index() returns an integer indicating the position of the original element relative to the elements matched by the selector. If the element is not found, .index() will return -1.
+ If a selector string is passed as an argument, .index() returns an integer indicating the position of the first element within the jQuery object relative to the elements matched by the selector. If the element is not found, .index() will return -1.
Detail
The complementary operation to .get(), which accepts an index and returns a DOM node, .index() can take a DOM node and returns an index. Suppose we have a simple unordered list on the page:
From 69ed47a2ee6c58690480f0d1bd0a36d75215f2a1 Mon Sep 17 00:00:00 2001
From: Karl Swedberg
Date: Sat, 27 Oct 2012 12:06:16 -0400
Subject: [PATCH 011/998] Fix typo in live.xml
---
entries/live.xml | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/entries/live.xml b/entries/live.xml
index a3ae5d05..2ba3a9b1 100644
--- a/entries/live.xml
+++ b/entries/live.xml
@@ -1,5 +1,5 @@
-
+
.live()
Attach an event handler for all elements which match the current selector, now and in the future.
@@ -139,4 +139,4 @@ $("p").live({
\ No newline at end of file
+
From a10920825e369712b4fcc6cd156dfa89beda7528 Mon Sep 17 00:00:00 2001
From: Karl Swedberg
Date: Thu, 1 Nov 2012 14:40:40 -0400
Subject: [PATCH 012/998] Plain object or function makes hide/show/toggle an
animation
Fixes #167
---
entries/hide.xml | 4 ++--
entries/show.xml | 4 ++--
entries/toggle.xml | 4 ++--
3 files changed, 6 insertions(+), 6 deletions(-)
diff --git a/entries/hide.xml b/entries/hide.xml
index 831af958..99a08409 100644
--- a/entries/hide.xml
+++ b/entries/hide.xml
@@ -26,7 +26,7 @@
$('.target').hide();
The matched elements will be hidden immediately, with no animation. This is roughly equivalent to calling .css('display', 'none'), except that the value of the display property is saved in jQuery's data cache so that display can later be restored to its initial value. If an element has a display value of inline, then is hidden and shown, it will once again be displayed inline.
- When a duration is provided, .hide() becomes an animation method. The .hide() method animates the width, height, and opacity of the matched elements simultaneously. When these properties reach 0, the display style property is set to none to ensure that the element no longer affects the layout of the page.
+ When a duration, a plain object, or a "complete" function is provided, .hide() becomes an animation method. The .hide() method animates the width, height, and opacity of the matched elements simultaneously. When these properties reach 0, the display style property is set to none to ensure that the element no longer affects the layout of the page.
Durations are given in milliseconds; higher values indicate slower animations, not faster ones. The strings 'fast' and 'slow' can be supplied to indicate durations of 200 and 600 milliseconds, respectively.
Note that .hide() is fired immediately and will override the animation queue if no duration or a duration of 0 is specified.
As of jQuery 1.4.3, an optional string naming an easing function may be used. Easing functions specify the speed at which the animation progresses at different points within the animation. The only easing implementations in the jQuery library are the default, called swing, and one that progresses at a constant pace, called linear. More easing functions are available with the use of plug-ins, most notably the jQuery UI suite.
@@ -125,4 +125,4 @@ $("div").click(function () {
Note: If using !important in your styles, such as
display: none !important,
it is necessary to override the style using .css('display', 'block !important') should you wish for .show() to function correctly.
- When a duration is provided, .show() becomes an animation method. The .show() method animates the width, height, and opacity of the matched elements simultaneously.
+ When a duration, a plain object, or a "complete" function is provided, .show() becomes an animation method. The .show() method animates the width, height, and opacity of the matched elements simultaneously.
Durations are given in milliseconds; higher values indicate slower animations, not faster ones. The strings 'fast' and 'slow' can be supplied to indicate durations of 200 and 600 milliseconds, respectively.
As of jQuery 1.4.3, an optional string naming an easing function may be used. Easing functions specify the speed at which the animation progresses at different points within the animation. The only easing implementations in the jQuery library are the default, called swing, and one that progresses at a constant pace, called linear. More easing functions are available with the use of plug-ins, most notably the jQuery UI suite.
If supplied, the callback is fired once the animation is complete. This can be useful for stringing different animations together in sequence. The callback is not sent any arguments, but this is set to the DOM element being animated. If multiple elements are animated, it is important to note that the callback is executed once per matched element, not once for the animation as a whole.
@@ -131,4 +131,4 @@ $("form").submit(function () {
With no parameters, the .toggle() method simply toggles the visibility of elements:
$('.target').toggle();
The matched elements will be revealed or hidden immediately, with no animation, by changing the CSS display property. If the element is initially displayed, it will be hidden; if hidden, it will be shown. The display property is saved and restored as needed. If an element has a display value of inline, then is hidden and shown, it will once again be displayed inline.
- When a duration is provided, .toggle() becomes an animation method. The .toggle() method animates the width, height, and opacity of the matched elements simultaneously. When these properties reach 0 after a hiding animation, the display style property is set to none to ensure that the element no longer affects the layout of the page.
+ When a duration, a plain object, or a single "complete" function is provided, .toggle() becomes an animation method. The .toggle() method animates the width, height, and opacity of the matched elements simultaneously. When these properties reach 0 after a hiding animation, the display style property is set to none to ensure that the element no longer affects the layout of the page.
Durations are given in milliseconds; higher values indicate slower animations, not faster ones. The strings 'fast' and 'slow' can be supplied to indicate durations of 200 and 600 milliseconds, respectively.
As of jQuery 1.4.3, an optional string naming an easing function may be used. Easing functions specify the speed at which the animation progresses at different points within the animation. The only easing implementations in the jQuery library are the default, called swing, and one that progresses at a constant pace, called linear. More easing functions are available with the use of plug-ins, most notably the jQuery UI suite.
If supplied, the callback is fired once the animation is complete. This can be useful for stringing different animations together in sequence. The callback is not sent any arguments, but this is set to the DOM element being animated. If multiple elements are animated, it is important to note that the callback is executed once per matched element, not once for the animation as a whole.
@@ -120,4 +120,4 @@ $("p").toggle( flip++ % 2 == 0 );
Date: Thu, 1 Nov 2012 14:44:33 -0400
Subject: [PATCH 013/998] Add Ajax_Events page and change hrefs to point to it
* They were pointing to http://docs.jquery.com/Ajax_Events
* Fixes #165
---
entries/ajaxComplete.xml | 2 +-
entries/ajaxError.xml | 2 +-
entries/ajaxSend.xml | 2 +-
entries/ajaxStart.xml | 2 +-
entries/ajaxStop.xml | 2 +-
entries/ajaxSuccess.xml | 2 +-
entries/jQuery.ajax.xml | 10 ++++----
pages/Ajax_Events.html | 52 ++++++++++++++++++++++++++++++++++++++++
8 files changed, 63 insertions(+), 11 deletions(-)
create mode 100644 pages/Ajax_Events.html
diff --git a/entries/ajaxComplete.xml b/entries/ajaxComplete.xml
index de519d4f..8064a68c 100644
--- a/entries/ajaxComplete.xml
+++ b/entries/ajaxComplete.xml
@@ -7,7 +7,7 @@
The function to be invoked.
- Register a handler to be called when Ajax requests complete. This is an AjaxEvent.
+ Register a handler to be called when Ajax requests complete. This is an AjaxEvent.
Whenever an Ajax request completes, jQuery triggers the ajaxComplete event. Any and all handlers that have been registered with the .ajaxComplete() method are executed at this time.
To observe this method in action, set up a basic Ajax load request:
diff --git a/entries/ajaxError.xml b/entries/ajaxError.xml
index cd4c5b28..c0e3c5c7 100644
--- a/entries/ajaxError.xml
+++ b/entries/ajaxError.xml
@@ -7,7 +7,7 @@
The function to be invoked.
- Register a handler to be called when Ajax requests complete with an error. This is an Ajax Event.
+ Register a handler to be called when Ajax requests complete with an error. This is an Ajax Event.
Whenever an Ajax request completes with an error, jQuery triggers the ajaxError event. Any and all handlers that have been registered with the .ajaxError() method are executed at this time.
To observe this method in action, set up a basic Ajax load request.
diff --git a/entries/ajaxSend.xml b/entries/ajaxSend.xml
index b59bdfcc..3639b44f 100644
--- a/entries/ajaxSend.xml
+++ b/entries/ajaxSend.xml
@@ -7,7 +7,7 @@
The function to be invoked.
- Attach a function to be executed before an Ajax request is sent. This is an Ajax Event.
+ Attach a function to be executed before an Ajax request is sent. This is an Ajax Event.
Whenever an Ajax request is about to be sent, jQuery triggers the ajaxSend event. Any and all handlers that have been registered with the .ajaxSend() method are executed at this time.
To observe this method in action, set up a basic Ajax load request:
diff --git a/entries/ajaxStart.xml b/entries/ajaxStart.xml
index afe3247f..5097dcec 100644
--- a/entries/ajaxStart.xml
+++ b/entries/ajaxStart.xml
@@ -7,7 +7,7 @@
The function to be invoked.
- Register a handler to be called when the first Ajax request begins. This is an Ajax Event.
+ Register a handler to be called when the first Ajax request begins. This is an Ajax Event.
Whenever an Ajax request is about to be sent, jQuery checks whether there are any other outstanding Ajax requests. If none are in progress, jQuery triggers the ajaxStart event. Any and all handlers that have been registered with the .ajaxStart() method are executed at this time.
To observe this method in action, set up a basic Ajax load request:
diff --git a/entries/ajaxStop.xml b/entries/ajaxStop.xml
index 502c6e82..e8e947de 100644
--- a/entries/ajaxStop.xml
+++ b/entries/ajaxStop.xml
@@ -1,7 +1,7 @@
.ajaxStop()
- Register a handler to be called when all Ajax requests have completed. This is an Ajax Event.
+ Register a handler to be called when all Ajax requests have completed. This is an Ajax Event.
1.0
diff --git a/entries/ajaxSuccess.xml b/entries/ajaxSuccess.xml
index 7e60e9a5..9a9d7eed 100644
--- a/entries/ajaxSuccess.xml
+++ b/entries/ajaxSuccess.xml
@@ -7,7 +7,7 @@
The function to be invoked.
- Attach a function to be executed whenever an Ajax request completes successfully. This is an Ajax Event.
+ Attach a function to be executed whenever an Ajax request completes successfully. This is an Ajax Event.
Whenever an Ajax request completes successfully, jQuery triggers the ajaxSuccess event. Any and all handlers that have been registered with the .ajaxSuccess() method are executed at this time.
To observe this method in action, set up a basic Ajax load request:
diff --git a/entries/jQuery.ajax.xml b/entries/jQuery.ajax.xml
index 9db343ea..75370a48 100644
--- a/entries/jQuery.ajax.xml
+++ b/entries/jQuery.ajax.xml
@@ -24,7 +24,7 @@
A pre-request callback function that can be used to modify the jqXHR (in jQuery 1.4.x, XMLHTTPRequest) object before it is sent. Use this to set custom headers, etc. The jqXHR and settings maps are passed as arguments. This is an Ajax Event. Returning false in the beforeSend function will cancel the request. As of jQuery 1.5, the beforeSend option will be called regardless of the type of request.
+ A pre-request callback function that can be used to modify the jqXHR (in jQuery 1.4.x, XMLHTTPRequest) object before it is sent. Use this to set custom headers, etc. The jqXHR and settings maps are passed as arguments. This is an Ajax Event. Returning false in the beforeSend function will cancel the request. As of jQuery 1.5, the beforeSend option will be called regardless of the type of request.
If set to false, it will force requested pages not to be cached by the browser. Note: Setting cache to false will only work correctly with HEAD and GET requests. It works by appending "_={timestamp}" to the GET parameters. The parameter is not needed for other types of requests, except in IE8 when a POST is made to a URL that has already been requested by a GET.
@@ -32,7 +32,7 @@
A function to be called when the request finishes (after success and error callbacks are executed). The function gets passed two arguments: The jqXHR (in jQuery 1.4.x, XMLHTTPRequest) object and a string categorizing the status of the request ("success", "notmodified", "error", "timeout", "abort", or "parsererror"). As of jQuery 1.5, the complete setting can accept an array of functions. Each function will be called in turn. This is an Ajax Event.
+ A function to be called when the request finishes (after success and error callbacks are executed). The function gets passed two arguments: The jqXHR (in jQuery 1.4.x, XMLHTTPRequest) object and a string categorizing the status of the request ("success", "notmodified", "error", "timeout", "abort", or "parsererror"). As of jQuery 1.5, the complete setting can accept an array of functions. Each function will be called in turn. This is an Ajax Event.
A map of string/regular-expression pairs that determine how jQuery will parse the response, given its content type.
@@ -72,10 +72,10 @@
A function to be called if the request fails. The function receives three arguments: The jqXHR (in jQuery 1.4.x, XMLHttpRequest) object, a string describing the type of error that occurred and an optional exception object, if one occurred. Possible values for the second argument (besides null) are "timeout", "error", "abort", and "parsererror". When an HTTP error occurs, errorThrown receives the textual portion of the HTTP status, such as "Not Found" or "Internal Server Error." As of jQuery 1.5, the error setting can accept an array of functions. Each function will be called in turn. Note: This handler is not called for cross-domain script and JSONP requests. This is an Ajax Event.
+ A function to be called if the request fails. The function receives three arguments: The jqXHR (in jQuery 1.4.x, XMLHttpRequest) object, a string describing the type of error that occurred and an optional exception object, if one occurred. Possible values for the second argument (besides null) are "timeout", "error", "abort", and "parsererror". When an HTTP error occurs, errorThrown receives the textual portion of the HTTP status, such as "Not Found" or "Internal Server Error." As of jQuery 1.5, the error setting can accept an array of functions. Each function will be called in turn. Note: This handler is not called for cross-domain script and JSONP requests. This is an Ajax Event.
- Whether to trigger global Ajax event handlers for this request. The default is true. Set to false to prevent the global handlers like ajaxStart or ajaxStop from being triggered. This can be used to control various Ajax Events.
+ Whether to trigger global Ajax event handlers for this request. The default is true. Set to false to prevent the global handlers like ajaxStart or ajaxStop from being triggered. This can be used to control various Ajax Events.
A map of additional header key/value pairs to send along with the request. This setting is set before the beforeSend function is called; therefore, any values in the headers setting can be overwritten from within the beforeSend function.
@@ -121,7 +121,7 @@
A function to be called if the request succeeds. The function gets passed three arguments: The data returned from the server, formatted according to the dataType parameter; a string describing the status; and the jqXHR (in jQuery 1.4.x, XMLHttpRequest) object. As of jQuery 1.5, the success setting can accept an array of functions. Each function will be called in turn. This is an Ajax Event.
+ A function to be called if the request succeeds. The function gets passed three arguments: The data returned from the server, formatted according to the dataType parameter; a string describing the status; and the jqXHR (in jQuery 1.4.x, XMLHttpRequest) object. As of jQuery 1.5, the success setting can accept an array of functions. Each function will be called in turn. This is an Ajax Event.
Set a timeout (in milliseconds) for the request. This will override any global timeout set with $.ajaxSetup(). The timeout period starts at the point the $.ajax call is made; if several other requests are in progress and the browser has no connections available, it is possible for a request to time out before it can be sent. In jQuery 1.4.x and below, the XMLHttpRequest object will be in an invalid state if the request times out; accessing any object members may throw an exception. In Firefox 3.0+ only, script and JSONP requests cannot be cancelled by a timeout; the script will run even if it arrives after the timeout period.
diff --git a/pages/Ajax_Events.html b/pages/Ajax_Events.html
new file mode 100644
index 00000000..04b8f0b8
--- /dev/null
+++ b/pages/Ajax_Events.html
@@ -0,0 +1,52 @@
+
+Ajax requests produce a number of different events that you can subscribe to. Here's a full list of the events and in what order they are broadcast.
+There are two types of events:
+Local Events
+These are callbacks that you can subscribe to within the Ajax request object, like so:
+ $.ajax({
+ beforeSend: function(){
+ // Handle the beforeSend event
+ },
+ complete: function(){
+ // Handle the complete event
+ }
+ // ......
+ });
+
+Global Events
+These events are broadcast to all elements in the DOM, triggering any handlers which may be listening. You can listen for these events like so:
+ $("#loading").bind("ajaxSend", function(){
+ $(this).show();
+ }).bind("ajaxComplete", function(){
+ $(this).hide();
+ });
+
+Global events can be disabled for a particular Ajax request by passing in the global option, like so:
+ $.ajax({
+ url: "test.html",
+ global: false,
+ // ...
+ });
+
+Events
+This is the full list of Ajax events that are broadcast, and in the order in which they are broadcast. The indented events are broadcast for each and every Ajax request (unless a global option has been set). The ajaxStart and ajaxStop events are events that relate to all Ajax requests together.
+
+
+ - ajaxStart (Global Event)
This event is broadcast if an Ajax request is started and no other Ajax requests are currently running.
+
+ - beforeSend (Local Event)
This event, which is triggered before an Ajax request is started, allows you to modify the XMLHttpRequest object (setting additional headers, if need be.)
+ - ajaxSend (Global Event)
This global event is also triggered before the request is run.
+ - success (Local Event)
This event is only called if the request was successful (no errors from the server, no errors with the data).
+ - ajaxSuccess (Global Event)
This event is also only called if the request was successful.
+ - error (Local Event)
This event is only called if an error occurred with the request (you can never have both an error and a success callback with a request).
+ - ajaxError (Global Event)
This global event behaves the same as the local error event.
+ - complete (Local Event)
This event is called regardless of if the request was successful, or not. You will always receive a complete callback, even for synchronous requests.
+ - ajaxComplete (Global Event)
This event behaves the same as the complete event and will be triggered every time an Ajax request finishes.
+
+
+ - ajaxStop (Global Event)
This global event is triggered if there are no more Ajax requests being processed.
+
From 2c02411b808260ab4a6e00ca4115a9a39df9ab8e Mon Sep 17 00:00:00 2001
From: Karl Swedberg
Date: Sun, 4 Nov 2012 16:05:28 -0500
Subject: [PATCH 014/998] Update $.proxy to show signatures w/ additional args
* Refers to #80. Not closing until reviewed.
* Note: Use of "slash-star" comments is necessary because
of the way we convert code in html to demos.
---
entries/jQuery.proxy.xml | 119 ++++++++++++++++++++++++++++++++-------
1 file changed, 100 insertions(+), 19 deletions(-)
diff --git a/entries/jQuery.proxy.xml b/entries/jQuery.proxy.xml
index eaf60c9a..1eae430f 100644
--- a/entries/jQuery.proxy.xml
+++ b/entries/jQuery.proxy.xml
@@ -19,11 +19,37 @@
The name of the function whose context will be changed (should be a property of the context object).
+
+ 1.6
+
+ The function whose context will be changed.
+
+
+ The object to which the context (this) of the function should be set.
+
+
+ Any number of arguments to be passed to the function referenced in the function argument.
+
+
+
+ 1.6
+
+ The object to which the context of the function should be set.
+
+
+ The name of the function whose context will be changed (should be a property of the context object).
+
+
+ Any number of arguments to be passed to the function named in the name argument.
+
+
+
Takes a function and returns a new one that will always have a particular context.
This method is most useful for attaching event handlers to an element where the context is pointing back to a different object. Additionally, jQuery makes sure that even if you bind the function returned from jQuery.proxy() it will still unbind the correct function if passed the original.
Be aware, however, that jQuery's event binding subsystem assigns a unique id to each event handling function in order to track it when it is used to specify the function to be unbound. The function represented by jQuery.proxy() is seen as a single function by the event subsystem, even when it is used to bind different contexts. To avoid unbinding the wrong handler, use a unique event namespace for binding and unbinding (e.g., "click.myproxy1") rather than specifying the proxied function during unbinding.
+ As of jQuery 1.6, any number of additional arguments may supplied to $.proxy(), and they will be passed to the function whose context will be changed.
Change the context of functions bound to a click handler using the "function, context" signature. Unbind the first handler after first click.
@@ -35,13 +61,13 @@
var me = {
type: "zombie",
test: function(event) {
- // Without proxy, `this` would refer to the event target
- // use event.target to reference that element.
+ /* Without proxy, `this` would refer to the event target */
+ /* use event.target to reference that element. */
var element = event.target;
$(element).css("background-color", "red");
- // With proxy, `this` refers to the me object encapsulating
- // this function.
+ /* With proxy, `this` refers to the me object encapsulating */
+ /* this function. */
$("#log").append( "Hello " + this.type + "
" );
$("#test").unbind("click", this.test);
}
@@ -54,22 +80,26 @@ var you = {
}
};
-// execute you.test() in the context of the `you` object
-// no matter where it is called
-// i.e. the `this` keyword will refer to `you`
+/* execute you.test() in the context of the `you` object */
+/* no matter where it is called */
+/* i.e. the `this` keyword will refer to `you` */
var youClick = $.proxy( you.test, you );
-// attach click handlers to #test
+/* attach click handlers to #test */
$("#test")
- // this === "zombie"; handler unbound after first click
- .click( $.proxy( me.test, me ) )
- // this === "person"
- .click( youClick )
- // this === "zombie"
- .click( $.proxy( you.test, me ) )
- // this === "
@@ -83,14 +113,65 @@ $("#test")
name: "John",
test: function() {
$("#log").append( this.name );
- $("#test").unbind("click", obj.test);
+ $("#test").off("click", obj.test);
}
};
- $("#test").click( jQuery.proxy( obj, "test" ) );
+ $("#test").on( "click", jQuery.proxy( obj, "test" ) );
]]>
+
+
+ Change the context of a function bound to the click handler,
+
+
+
Date: Mon, 5 Nov 2012 08:44:13 -0500
Subject: [PATCH 015/998] Add double negation example to "Boolean Default"
Closes #170
---
pages/Types.html | 1 +
1 file changed, 1 insertion(+)
diff --git a/pages/Types.html b/pages/Types.html
index 27aef4c8..c4f1bdb8 100644
--- a/pages/Types.html
+++ b/pages/Types.html
@@ -144,6 +144,7 @@ Boolean Default
If a number is zero, it defaults to false:
!0 // true
+!!0 // false (Double negation: Since "not 0" is true, negating that makes it false)
!1 // false
!-1 // false
From 71eaf6bf4b39f2dfa3c23667784c770dad28d81b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B6rn=20Zaefferer?=
Date: Fri, 9 Nov 2012 12:20:06 +0100
Subject: [PATCH 016/998] Add check-modules tasks
---
grunt.js | 3 ++-
package.json | 3 ++-
2 files changed, 4 insertions(+), 2 deletions(-)
diff --git a/grunt.js b/grunt.js
index 41456718..ea16b469 100644
--- a/grunt.js
+++ b/grunt.js
@@ -7,6 +7,7 @@ var entryFiles = grunt.file.expandFiles( "entries/*.xml" );
grunt.loadNpmTasks( "grunt-clean" );
grunt.loadNpmTasks( "grunt-wordpress" );
grunt.loadNpmTasks( "grunt-jquery-content" );
+grunt.loadNpmTasks( "grunt-check-modules" );
grunt.initConfig({
clean: {
@@ -37,7 +38,7 @@ grunt.initConfig({
grunt.registerTask( "default", "build-wordpress" );
grunt.registerTask( "build", "build-pages build-xml-entries build-xml-categories build-xml-full build-resources" );
-grunt.registerTask( "build-wordpress", "clean lint xmllint build" );
+grunt.registerTask( "build-wordpress", "check-modules clean lint xmllint build" );
grunt.registerTask( "tidy", "xmllint xmltidy" );
};
diff --git a/package.json b/package.json
index 59e5f079..1fe35340 100644
--- a/package.json
+++ b/package.json
@@ -24,7 +24,8 @@
"grunt": "0.3.x",
"grunt-clean": "0.3.0",
"grunt-wordpress": "1.0.3",
- "grunt-jquery-content": "0.5.x"
+ "grunt-jquery-content": "0.5.x",
+ "grunt-check-modules": "0.1.0"
},
"devDependencies": {},
"keywords": []
From fd728e9182d18ceb7e506415139b83efb73f0e46 Mon Sep 17 00:00:00 2001
From: Karl Swedberg
Date: Fri, 9 Nov 2012 18:57:45 -0500
Subject: [PATCH 017/998] More double negation
---
pages/Types.html | 16 +++++++++++-----
1 file changed, 11 insertions(+), 5 deletions(-)
diff --git a/pages/Types.html b/pages/Types.html
index c4f1bdb8..4a2ac57d 100644
--- a/pages/Types.html
+++ b/pages/Types.html
@@ -24,9 +24,12 @@
In this case, "x defaulted to false" is printed.
To keep the examples short, the invert-operator is used to show a boolean context: +
To keep the examples short, the invert ("not") operator and double-negation are used to show a boolean context:
-!x // true
+
+var x = "";
+!x // true
+!!x // false (Double negation: Since "not (empty string)" is true, negating that makes it false)
On to the actual types.
@@ -125,6 +128,7 @@ Boolean Default
An empty string defaults to false:
!"" // true
+!!"" // false
!"hello" // false
!"true" // false
!new Boolean( false ) // false
@@ -144,7 +148,7 @@ Boolean Default
If a number is zero, it defaults to false:
!0 // true
-!!0 // false (Double negation: Since "not 0" is true, negating that makes it false)
+!!0 // false
!1 // false
!-1 // false
@@ -217,8 +221,8 @@ Float
Boolean
A boolean in JavaScript can be either true or false:
-if ( true ) console.log( "always!" )
-if ( false ) console.log( "never!" )
+if ( true ) console.log( "always!" );
+if ( false ) console.log( "never!" );
Object
Everything in JavaScript is an object, though some are more objective (haha). The easiest way to create an object is the object literal:
@@ -281,6 +285,7 @@
Boolean default
An object, no matter if it has properties or not, never defaults to false:
!{} // false
+!!{} // true
Prototype
All objects have a prototype property. Whenever the interpreter looks for a property, it also checks the prototype. jQuery uses that extensively to add methods to jQuery instances.
@@ -369,6 +374,7 @@
Boolean Default
An array, no matter if it has elements or not, never defaults to false:
![] // false
+!![] // true
Array<Type> Notation
In the jQuery API you'll often find the notation of Array<Type>:
From 0f0498233071b3ad4b210639a1937640ce24bbf4 Mon Sep 17 00:00:00 2001
From: Corey Frang
Date: Fri, 9 Nov 2012 19:05:53 -0500
Subject: [PATCH 018/998] Remove bad advice
---
entries/jQuery.xml | 14 --------------
1 file changed, 14 deletions(-)
diff --git a/entries/jQuery.xml b/entries/jQuery.xml
index e316b922..fb7319ef 100644
--- a/entries/jQuery.xml
+++ b/entries/jQuery.xml
@@ -187,20 +187,6 @@ $( "", {
}).appendTo( "body" );
The name "class" must be quoted in the map since it is a JavaScript reserved word, and "className" cannot be used since it is not the correct attribute name.
- Note: Internet Explorer will not allow you to create an input or button element and change its type; you must specify the type using "<input type="checkbox" />", for example. A demonstration of this can be seen below:
- Unsupported in IE:
-
-$( "<input />", {
- type: "text",
- name: "test"
-}).appendTo( "body" );
-
- Supported workaround:
-
-$( "<input type="text" />" ).attr({
- name: "test"
-}).appendTo( "body" );
-
Create a div element (and all of its contents) dynamically and append it to the body element. Internally, an element is created and its innerHTML property set to the given markup.
From a360c373bf88dc75991adac9c7e9bd0a24967466 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Scott=20Gonz=C3=A1lez?=
Date: Wed, 14 Nov 2012 10:36:13 -0500
Subject: [PATCH 019/998] Upgrade grunt-jquery-content to 0.5.12.
---
package.json | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/package.json b/package.json
index 1fe35340..77a6ff93 100644
--- a/package.json
+++ b/package.json
@@ -24,7 +24,7 @@
"grunt": "0.3.x",
"grunt-clean": "0.3.0",
"grunt-wordpress": "1.0.3",
- "grunt-jquery-content": "0.5.x",
+ "grunt-jquery-content": "0.5.12",
"grunt-check-modules": "0.1.0"
},
"devDependencies": {},
From 53039c86606fd5f2cb41459c6168cd492d19ec79 Mon Sep 17 00:00:00 2001
From: Karl Swedberg
Date: Mon, 19 Nov 2012 14:03:19 -0500
Subject: [PATCH 020/998] Fix attribute selectors category.
Closes #177
---
categories.xml | 10 ++++++----
1 file changed, 6 insertions(+), 4 deletions(-)
diff --git a/categories.xml b/categories.xml
index d23dfa1b..bf85a73c 100644
--- a/categories.xml
+++ b/categories.xml
@@ -211,9 +211,9 @@
]]>
, will select Some text but not Some text.
- Attribute values in selector expressions must follow the rules for W3C CSS selectors, in general that means anything other than a simple identifier should be surrounded by quotation marks.
+ The CSS specification allows elements to be identified by their attributes. While not supported by some older browsers for the purpose of styling documents, jQuery allows you to employ them regardless of the browser being used.
+ When using any of the following attribute selectors, you should account for attributes that have multiple, space-separated values. Since these selectors see attribute values as a single string, this selector, for example, $("a[rel='nofollow']"), will select <a href="example.html" rel="nofollow">Some text</a> but not <a href="example.html" rel="nofollow foe">Some text</a>.
+ Attribute values in selector expressions must follow the rules for W3C CSS selectors; in general, that means anything other than a valid identifier should be surrounded by quotation marks.
- double quotes inside single quotes:
$('a[rel="nofollow self"]')
- single quotes inside double quotes:
$("a[rel='nofollow self']")
@@ -221,8 +221,10 @@
- escaped double quotes inside double quotes:
$("a[rel=\"nofollow self\"]")
The variation you choose is generally a matter of style or convenience.
+
Note: In jQuery 1.3 [@attr] style selectors were removed (they were previously deprecated in jQuery 1.2). Simply remove the "@" symbol from your selectors in order to make them work again.
- ]]>
+ ]]>
+
Date: Fri, 30 Nov 2012 06:21:16 -0500
Subject: [PATCH 021/998] Upgrade to grunt-jquery-content 0.7.0 and
grunt-wordpress 1.0.5.
---
package.json | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/package.json b/package.json
index 77a6ff93..dbd7a90b 100644
--- a/package.json
+++ b/package.json
@@ -23,8 +23,8 @@
"dependencies": {
"grunt": "0.3.x",
"grunt-clean": "0.3.0",
- "grunt-wordpress": "1.0.3",
- "grunt-jquery-content": "0.5.12",
+ "grunt-wordpress": "1.0.5",
+ "grunt-jquery-content": "0.7.0",
"grunt-check-modules": "0.1.0"
},
"devDependencies": {},
From 148020ba15e3338298b6fd458e47cf04e8e3b369 Mon Sep 17 00:00:00 2001
From: Dave Mayo
Date: Sun, 2 Dec 2012 13:40:20 -0500
Subject: [PATCH 022/998] Provisionally fixes #173 - fixes desc and typo, but
andSelf/addBack issue needs addressing
---
entries/andSelf.xml | 10 +++++++---
1 file changed, 7 insertions(+), 3 deletions(-)
diff --git a/entries/andSelf.xml b/entries/andSelf.xml
index 67e2f1c3..dc47098f 100644
--- a/entries/andSelf.xml
+++ b/entries/andSelf.xml
@@ -6,7 +6,7 @@
Add the previous set of elements on the stack to the current set.
- As described in the discussion for .end(), jQuery objects maintain aninternal stack that keeps track of changes to the matched set of elements. When one of the DOM traversal methods is called, the new set of elements is pushed onto the stack. If the previous set of elements is desired as well, .andSelf() can help.
+ As described in the discussion for .end(), jQuery objects maintain an internal stack that keeps track of changes to the matched set of elements. When one of the DOM traversal methods is called, the new set of elements is pushed onto the stack. If the previous set of elements is desired as well, .andSelf() can help.
Consider a page with a simple list on it:
<ul>
@@ -24,10 +24,14 @@
First, the initial selector locates item 3, initializing the stack with the set containing just this item. The call to .nextAll() then pushes the set of items 4 and 5 onto the stack. Finally, the .andSelf() invocation merges these two sets together, creating a jQuery object that points to all three items in document order: {[<li.third-item>,<li>,<li> ]}.
- Find all divs, and all the paragraphs inside of them, and give them both class names. Notice the div doesn't have the yellow background color since it didn't use .andSelf().
+ The .andSelf() method causes the previous set of DOM elements in the traversal stack to be added to the current set. In the first example, the top stack contains the set resulting from .find("p"). In the second example, .andSelf() adds the previous set of elements on the stack — in this case $("div.after-andself") — to the current set, selecting both the div and its enclosed paragraphs.
+
+ .addBack()
+
+ 1.6
+
+ A string containing a selector expression to match the current set of elements against.
+
+
+ Add the previous set of elements on the stack to the current set, optionally filtered by a selector.
+
+ As described in the discussion for .end(), jQuery objects maintain an internal stack that keeps track of changes to the matched set of elements. When one of the DOM traversal methods is called, the new set of elements is pushed onto the stack. If the previous set of elements is desired as well, .addBack() can help.
+ Consider a page with a simple list on it:
+
+<ul>
+ <li>list item 1</li>
+ <li>list item 2</li>
+ <li class="third-item">list item 3</li>
+ <li>list item 4</li>
+ <li>list item 5</li>
+</ul>
+
+ The result of the following code is a red background behind items 3, 4 and 5:
+ $('li.third-item').nextAll().addBack()
+ .css('background-color', 'red');
+
+ First, the initial selector locates item 3, initializing the stack with the set containing just this item. The call to .nextAll() then pushes the set of items 4 and 5 onto the stack. Finally, the .addBack() invocation merges these two sets together, creating a jQuery object that points to all three items in document order: {[<li.third-item>,<li>,<li> ]}.
+
+
+ The .addBack() method causes the previous set of DOM elements in the traversal stack to be added to the current set. In the first example, the top stack contains the set resulting from .find("p"). In the second example, .addBack() adds the previous set of elements on the stack — in this case $("div.after-addback") — to the current set, selecting both the div and its enclosed paragraphs.
+
+
diff --git a/entries/andSelf.xml b/entries/andSelf.xml
index dc47098f..d85b2e88 100644
--- a/entries/andSelf.xml
+++ b/entries/andSelf.xml
@@ -1,11 +1,12 @@
-
+
.andSelf()
1.2
Add the previous set of elements on the stack to the current set.
+ Note: This function has been deprecated and is now an alias for .addBack(), which should be used with jQuery 1.8 and later.
As described in the discussion for .end(), jQuery objects maintain an internal stack that keeps track of changes to the matched set of elements. When one of the DOM traversal methods is called, the new set of elements is pushed onto the stack. If the previous set of elements is desired as well, .andSelf() can help.
Consider a page with a simple list on it:
From 8237b684d1a0e2370296edb6511751bfcffa92fb Mon Sep 17 00:00:00 2001
From: Karl Swedberg
Date: Sat, 15 Dec 2012 14:30:56 -0500
Subject: [PATCH 024/998] Change "map" to "object" or "plain object" as
appropriate. Closes #181
---
entries/animate.xml | 12 ++++++------
entries/attr.xml | 4 ++--
entries/bind.xml | 10 +++++-----
entries/blur.xml | 4 ++--
entries/change.xml | 4 ++--
entries/click.xml | 4 ++--
entries/css.xml | 4 ++--
entries/dblclick.xml | 4 ++--
entries/delegate.xml | 6 +++---
entries/die.xml | 2 +-
entries/error.xml | 4 ++--
entries/event.data.xml | 2 +-
entries/focus.xml | 4 ++--
entries/focusin.xml | 4 ++--
entries/focusout.xml | 4 ++--
entries/jQuery.ajax.xml | 20 ++++++++++----------
entries/jQuery.ajaxTransport.xml | 6 +++---
entries/jQuery.browser.xml | 2 +-
entries/jQuery.each.xml | 16 ++++++++--------
entries/jQuery.get.xml | 6 +++---
entries/jQuery.getJSON.xml | 6 +++---
entries/jQuery.map.xml | 2 +-
entries/jQuery.noConflict.xml | 2 +-
entries/jQuery.post.xml | 6 +++---
entries/jQuery.xml | 6 +++---
entries/keydown.xml | 4 ++--
entries/keypress.xml | 4 ++--
entries/keyup.xml | 4 ++--
entries/live.xml | 8 ++++----
entries/load-event.xml | 4 ++--
entries/load.xml | 6 +++---
entries/mousedown.xml | 4 ++--
entries/mouseenter.xml | 4 ++--
entries/mouseleave.xml | 4 ++--
entries/mousemove.xml | 4 ++--
entries/mouseout.xml | 4 ++--
entries/mouseover.xml | 4 ++--
entries/mouseup.xml | 4 ++--
entries/off.xml | 4 ++--
entries/on.xml | 10 +++++-----
entries/one.xml | 6 +++---
entries/prop.xml | 2 +-
entries/resize.xml | 4 ++--
entries/scroll.xml | 4 ++--
entries/select.xml | 4 ++--
entries/submit.xml | 4 ++--
entries/undelegate.xml | 4 ++--
entries/unload.xml | 4 ++--
48 files changed, 124 insertions(+), 124 deletions(-)
diff --git a/entries/animate.xml b/entries/animate.xml
index 9c161392..e67347ff 100644
--- a/entries/animate.xml
+++ b/entries/animate.xml
@@ -5,7 +5,7 @@
1.0
- A map of CSS properties that the animation will move toward.
+ An object of CSS properties and values that the animation will move toward.
1.0
- A map of CSS properties that the animation will move toward.
+ An object of CSS properties and values that the animation will move toward.
- The .animate() method allows us to create animation effects on any numeric CSS property. The only required parameter is a map of CSS properties. This map is similar to the one that can be sent to the .css() method, except that the range of properties is more restrictive.
+ The .animate() method allows us to create animation effects on any numeric CSS property. The only required parameter is a plain object of CSS properties. This object is similar to the one that can be sent to the .css() method, except that the range of properties is more restrictive.
Animation Properties and Values
All animated properties should be animated to a single numeric value, except as noted below; most properties that are non-numeric cannot be animated using basic jQuery functionality (For example, width, height, or left can be animated but background-color cannot be, unless the jQuery.Color() plugin is used). Property values are treated as a number of pixels unless otherwise specified. The units em and % can be specified where applicable.
In addition to style properties, some non-style properties such as scrollTop and scrollLeft, as well as custom properties, can be animated.
@@ -100,7 +100,7 @@
$(this).after('<div>Animation complete.</div>');
});
});
- In the second version of .animate(), the options map can include the specialEasing property, which is itself a map of CSS properties and their corresponding easing functions. For example, to simultaneously animate the width using the linear easing function and the height using the easeOutBounce easing function:
+ In the second version of .animate(), the options object can include the specialEasing property, which is itself an object of CSS properties and their corresponding easing functions. For example, to simultaneously animate the width using the linear easing function and the height using the easeOutBounce easing function:
$('#clickme').click(function() {
$('#book').animate({
width: 'toggle',
@@ -290,7 +290,7 @@ div {
}, { duration: "slow", easing: "easein" });]]>
- Animate all paragraphs and execute a callback function when the animation is complete. The first argument is a map of CSS properties, the second specifies that the animation should take 1000 milliseconds to complete, the third states the easing type, and the fourth argument is an anonymous callback function.
+ Animate all paragraphs and execute a callback function when the animation is complete. The first argument is an object of CSS properties, the second specifies that the animation should take 1000 milliseconds to complete, the third states the easing type, and the fourth argument is an anonymous callback function.
1: 97
- If a map is used as the collection, the callback is passed a key-value pair each time:
- var map = {
- 'flammable': 'inflammable',
- 'duh': 'no duh'
+ If an object is used as the collection, the callback is passed a key-value pair each time:
+ var obj = {
+ "flammable": "inflammable",
+ "duh": "no duh"
};
-$.each(map, function(key, value) {
- alert(key + ': ' + value);
+$.each( obj, function( key, value ) {
+ alert( key + ": " + value );
});
Once again, this produces two messages:
@@ -79,4 +79,4 @@ $.each(map, function(key, value) {
A string containing the URL to which the request is sent.
-
- A map or string that is sent to the server with the request.
+
+ A plain object or string that is sent to the server with the request.
A callback function that is executed if the request succeeds.
@@ -91,4 +91,4 @@ alert("Data Loaded: " + data);
A string containing the URL to which the request is sent.
- A map or string that is sent to the server with the request.
+ A plain object or string that is sent to the server with the request.
A callback function that is executed if the request succeeds.
@@ -23,7 +23,7 @@
success: callback
});
- Data that is sent to the server is appended to the URL as a query string. If the value of the data parameter is an object (map), it is converted to a string and url-encoded before it is appended to the URL.
+ Data that is sent to the server is appended to the URL as a query string. If the value of the data parameter is a plain object, it is converted to a string and url-encoded before it is appended to the URL.
Most implementations will specify a success handler:
$.getJSON('ajax/test.json', function(data) {
var items = [];
@@ -107,4 +107,4 @@ $.getJSON("http://api.flickr.com/services/feeds/photos_public.gne?jsoncallback=?
- Maps the original array to a new one; each element is squared.
+ Map the original array to a new one; each element is squared.
If necessary, you can free up the jQuery name as well by passing true as an argument to the method. This is rarely necessary, and if you must do this (for example, if you need to use multiple versions of the jQuery library on the same page), you need to consider that most plug-ins rely on the presence of the jQuery variable and may not operate correctly in this situation.
- Maps the original object that was referenced by $ back to $.
+ Map the original object that was referenced by $ back to $.