lsd_rails 0.1

data/Packages/mootools-more/Docs/Request/Request.Queue.md

@@ -0,0 +1,337 @@
+Class: Request.Queue {#Request-Queue}
+=====================================
+
+A controller class for [Request][] instances (and its subclasses) that stacks up request calls so that only a fixed amount of requests are sent at a time.
+
+### Tutorial/Demo
+
+* [Online Tutorial/Demo](http://www.clientcide.com/wiki/cnet-libraries/06-request/02-request.queue)
+
+### Implements
+
+* [Options][], [Events][]
+
+Request.Queue Method: constructor
+---------------------------------
+
+### Syntax
+
+	new Request.Queue(options);
+
+### Arguments
+
+1. options - (*object*) an object with key/value options
+
+### Options
+
+* stopOnFailure - (*boolean*, defaults to *true*) If *false*, the next request on the stack will be called when there is an error or exception. Otherwise any queued requests are held until you call the *resume* method.
+* autoAdvance - (*boolean*, defaults to *true*) If *true* any queued requests will be called one after the other until there are no more left. If *false* you must call the *runNext* method yourself.
+* concurrent - (*number*, defaults to *1*) The number of concurrent requests you wish to allow.
+
+### Events
+
+All of the events supplied to the [Request][] class are supported with the difference that the class first passes the name of the request in the [Request.Queue][] class followed by the [Request][] instance itself. So, for instance, if *onComplete* passes the response text and then the response xml for [Request][], then the *onComplete* passes first the name of the instance, the instance of [Request][], followed by the response text and then the response xml.
+
+* onRequest
+* onSuccess
+* onComplete
+* onCancel
+* onException
+* onFailure
+
+In addition to these events there is an *onEnd* event that is fired when all the requests have finished.
+
+### Example
+
+	var myRequests = {
+		r1: new Request({
+			url: '/foo1.php', data: { foo1: 'bar1'},
+			onComplete: function(text, xml){
+				console.log('myRequests.r1: ', text, xml);
+			}
+		}),
+		r2: new Request({
+			url: '/foo2.php', data: { foo2: 'bar2'},
+			onComplete: function(text, xml){
+				console.log('myRequests.r2: ', text, xml);
+			}
+		})
+	};
+	var myQueue = new Request.Queue({
+		requests: myRequests,
+		onComplete: function(name, instance, text, xml){
+			console.log('queue: ' + name + ' response: ', text, xml);
+		}
+	});
+
+	myRequests.r1.send();
+	myRequests.r2.send(); //sends when above request completes
+	myRequests.r1.send(); //sends when above request completes
+	etc.
+
+In the above example, when each request completes, it will first log out the 'myRequests.rq: <text>, <xml>' message from the *onComplete* event specified in each request instance. Then it will log the 'queue: r1/r2 response: <text>, <xml>' message from the *onComplete* method in the [Request.Queue][] event specified in its options.
+
+Request.Queue Method: addRequest {#Request-Queue:addRequest}
+------------------------------------------------------
+
+Adds an instance of [Request][] (or its subclasses) to the Request.Queue for management.
+
+### Syntax
+
+	myRequestQueue.addRequest(name, request);
+
+### Arguments
+
+1. name - (*string*) The name you want to associate with this request
+2. request - (*object*) An instance of [Request][] or one of its subclasses (such as [Request.HTML][]).
+
+### Example
+
+	var foo = new Request();
+	myRequestQueue.addRequest('fooRequest', foo);
+
+This allows you to refer to that instance within the queue in other methods listed below.
+
+### Returns
+
+* *object* - This instance of Request.Queue.
+
+Request.Queue Method: addRequests {#Request-Queue:addRequests}
+------------------------------------------------------
+
+Adds several requests at once (see [addRequest][]).
+
+### Syntax
+
+	myRequestQueue.addRequests(requests);
+
+### Arguments
+
+1. requests - (*object*) an object of key/values where the keys are the names for each instance of request and the values are the instances.
+
+### Example
+
+	var foo = new Request();
+	var bar = new Request();
+	myRequestQueue.addRequests({
+		req1: foo,
+		req2: bar
+	});
+
+This allows you to refer to specific instances with other methods of the class.
+
+Request.Queue Method: getName {#Request-Queue:getName}
+------------------------------------------------------
+
+Given an instance of [Request][] this method returns the name to which it is registered.
+
+### Syntax
+
+	myRequestQueue.getName(request);
+
+### Arguments
+
+1. request - (*object*) an instance of [Request][] or one of its subclasses.
+
+### Example
+
+	var foo = new Request();
+	myRequestQueue.addRequest('fooRequest', foo);
+	myRequestQueue.getName(foo); //fooRequest
+
+### Returns
+
+* mixed - If the name is found, it returns that name (a *string*), else it returns *null* if the Queue is not managing that instance.
+
+Request.Queue Method: removeRequest {#Request-Queue:removeRequest}
+------------------------------------------------------
+
+Removes an instance of [Request][] or one of its subclasses from the queue management. Any queued or running requests from that instance are retained (see [clear][]).
+
+### Syntax
+
+	myRequestQueue.removeRequest(request);
+
+### Arguments
+
+1. request - (*mixed*) You can pass in either the instance of [Request][] to drop or the name under which it's registered.
+
+### Example
+
+	var foo = new Request();
+	myRequestQueue.addRequest('fooRequest', foo);
+	myRequestQueue.removeRequest(foo);
+	//OR
+	myRequestQueue.removeRequest('fooRequest');
+
+Request.Queue Method: getRunnning {#Request-Queue:getRunning}
+------------------------------------------------------
+
+Returns any instances of [Request][] that are currently running (but not necessarily any instances that are queued to run).
+
+### Syntax
+
+	myRequestQueue.getRunning();
+
+### Returns
+
+* *object* - An object of [Request][] instances that have open requests.
+
+Request.Queue Method: send {#Request-Queue:send}
+------------------------------------------------------
+
+Sends a request using a specified instance.
+
+### Syntax
+
+	myRequestQueue.send(name, options);
+
+### Arguments
+
+1. name - (*string*) the name of the instance of [Request][] with which you registered it.
+2. options - (*objects*) the options to be passed to that instance's *send* method.
+
+### Example
+
+	var foo = new Request();
+	myRequestQueue.addRequest('fooRequest', foo);
+	myRequestQueue.send('fooRequest', {data: {some:'thing'}});
+
+### Notes
+
+There's really no reason to use this method. You should just call the *send* method that exists on the request instance instead. Request.Queue will handle the queuing automatically.
+
+### Returns
+
+* *object* - This instance of Request.Queue.
+
+Request.Queue Method: hasNext {#Request-Queue:hasNext}
+------------------------------------------------------
+
+Determines if there is a request in the queue.
+
+### Syntax
+
+	myRequestQueue.hasNext([name]);
+
+### Arguments
+
+1. name - (*string*, optional) If specified, will search the queue for any queued requests for a specific request.
+
+### Example
+
+	var foo = new Request();
+	myRequestQueue.addRequest('fooRequest', foo);
+	foo.send({data: {some:'thing'}}); //runs immediately
+	foo.send({data: {something:'else'}}); //is queued until above request returns
+	myRequestQueue.hasNext(); //true
+	myRequestQueue.hasNext('fooRequest'); //true
+	myRequestQueue.hasNext('barRequest'); //false
+
+### Returns
+
+* boolean - Returns *true* if there are any requests that match the specified name. If the name is not specified, it returns *true* if there are any requests queued at all.
+
+Request.Queue Method: runNext {#Request-Queue:runNext}
+------------------------------------------------------
+
+Runs the next request in the queue. If the option "autoAdvance" is set to *true* (the default) you don't really need to call this method.
+
+### Syntax
+
+	myRequestQueue.runNext([name]);
+
+### Arguments
+
+1. name - (*string*, optional) If specified, the queue will be searched for the next queued request for the specified instance of [Request][], otherwise the next available request in the queue will run.
+
+### Returns
+
+* *object* - This instance of Request.Queue.
+
+Request.Queue Method: runAll {#Request-Queue:runAll}
+------------------------------------------------------
+
+Runs all queued requests at once.
+
+### Syntax
+
+	myRequestQueue.runAll()
+
+### Returns
+
+* *object* - This instance of Request.Queue.
+
+
+Request.Queue Method: resume {#Request-Queue:resume}
+------------------------------------------------------
+
+If the option *stopOnFailure* is set to *true* (the default), then all subsequent requests will be queued and will remain so until you tell the class to resume requests.
+
+### Syntax
+
+	myRequestQueue.resume()
+
+### Returns
+
+* *object* - This instance of Request.Queue.
+
+Request.Queue Method: clear {#Request-Queue:clear}
+------------------------------------------------------
+
+Clears the request queue.
+
+### Syntax
+
+	myRequestQueue.clear([name])
+
+### Arguments
+
+1. name - (*string*, optional) If specified, only the requests queued for a specific instance of [Request][] will be removed.
+
+### Example
+
+	myRequestQueue.clear('foo'); //any pending requests for the 'foo' request are removed
+	myRequestQueue.clear(); //all pending requests are cleared
+
+### Returns
+
+* *object* - This instance of Request.Queue.
+
+Request.Queue Method: cancel {#Request-Queue:cancel}
+------------------------------------------------------
+
+Cancels a running request for the specified instance of [Request][].
+
+### Syntax
+
+	myRequestQueue.cancel(name);
+
+### Arguments
+
+1. name - (*string*) The name of the instance of Request as you registered it.
+
+### Example
+
+	var foo = new Request();
+	myRequestQueue.addRequest('fooRequest', foo);
+	foo.send({data: {some:'thing'}}); //runs immediately
+	foo.send({data: {something:'else'}}); //is queued until above request returns
+	myRequestQueue.cancel('foo'); //cancels the currently running request for *foo*
+	//SAME AS foo.cancel()
+
+### Notes
+
+This method isn't really meant to be used. As illustrated above, you can just call the *cancel* method on the request instance instead. Note that it does not cancel pending requests from that instance. In the example above, as soon as we cancel the first request the second one will fire.
+
+### Returns
+
+* *object* - This instance of Request.Queue.
+
+[Request]: /core/Request/Request
+[Request.HTML]: /core/Request/Request.HTML
+[Request.Queue]: #Request-Queue
+[addRequest]: #Request-Queue:addRequest
+[clear]: #Request-Queue:clear
+[Options]: /core/Class/Class.Extras#Options
+[Events]: /core/Class/Class.Extras#Events

data/Packages/mootools-more/Docs/Types/Array.Extras.md

@@ -0,0 +1,193 @@
+Type: Array {#Array}
+======================
+
+A collection of useful methods to extend Arrays.
+
+### See Also
+
+* [Array][]
+
+
+Array Method: min {#Array:min}
+-------------------------------------
+
+Calls Math.min on the array and returns its lowest value.
+
+### Syntax
+
+	myArray.min();
+
+### Example
+
+	[1, 2, 3].min();
+	//returns 1
+
+### Returns
+
+* (*number*) the lowest number in the array
+
+
+Array Method: max {#Array:max}
+-------------------------------------
+
+Calls Math.max on the array and returns its highest value.
+
+### Syntax
+
+	myArray.max();
+
+### Example
+
+	[1, 2, 3].max();
+	//returns 3
+
+### Returns
+
+* (*number*) the highest number in the array
+
+Array Method: average {#Array:average}
+-------------------------------------
+
+Calculates the average value of the array.
+
+### Syntax
+
+	myArray.average();
+
+### Example
+
+	[1, 2, 3].average();
+	//returns 2
+
+### Returns
+
+* (*number*) the average value of the array
+
+Array Method: shuffle {#Array:shuffle}
+-------------------------------------
+
+Randomizes the array (altering it).
+
+### Syntax
+
+	myArray.shuffle();
+
+### Example
+
+	[1, 2, 3].shuffle();
+
+### Returns
+
+* (*array*) the array.
+
+### Note
+
+Calling this method alters the array; it doesn't just return a new array with the same contents shuffled. It does, however, return itself.
+
+Array Method: sum {#Array:sum}
+-------------------------------------
+
+Sums up all values in an array.
+
+### Syntax
+
+	myArray.sum();
+
+### Example
+
+	$$('ul.menu li').getWidth().sum();
+	//returns the width of all li elements inside ul.menu as a sum
+
+### Returns
+
+* (*number*) a number containing the sum of all values in the given array
+
+Array Method: unique {#Array:unique}
+-------------------------------------
+
+Returns a new array without duplicate values.
+
+### Syntax
+
+	myArrayWithoutDupes = myArray.unique();
+
+### Example
+
+	var fruits = ['apple', 'lemon', 'pear', 'lemon', 'apple'].unique();
+	//fruits == ['apple', 'lemon', 'pear']
+
+### Returns
+
+* (*array*) a new array without duplicates.
+
+Array Method: reduce {#Array:reduce}
+-------------------------------------
+
+Apply a function against an accumulator and each value of the array (from left-to-right) as to reduce it to a single value.
+
+### Syntax
+
+	result = myArray.reduce(fn[, value]);
+
+### Arguments
+1. fn - (*function*) Function to execute on each value in the array.
+2. value - (*mixed*) Value to use as the first argument to the first call of the `fn`
+
+#### Signature:
+
+	fn(previousValue, currentValue, index, array)
+
+
+### Example
+
+	[0, 1, 2, 3, 4].reduce(function(a, b){
+		return a + b;
+	}); // returns 10
+
+	[0, 1, 2, 3, 4].reduce(function(a, b){
+		return a + b;
+	}, 20); // returns 30
+
+### Returns
+
+* (*mixed*) Returns the reduced single value of the array.
+
+### See also:
+- [MDC Array.reduce][]
+
+Array Method: reduceRight {#Array:reduceRight}
+----------------------------------------------
+
+Apply a function simultaneously against two values of the array (from right-to-left) as to reduce it to a single value.
+
+### Syntax
+
+	result = myArray.reduceRight(fn[, value]);
+
+### Arguments
+1. fn - (*function*) Function to execute on each value in the array.
+2. value - (*mixed*) Value to use as the first argument to the first call of the `fn`
+
+#### Signature:
+
+	fn(previousValue, currentValue, index, array)
+
+
+### Example
+
+	var flattened = [[0, 1], [2, 3], [4, 5]].reduceRight(function(a, b) {
+		return a.concat(b);
+	}, []);
+	// flattened is [4, 5, 2, 3, 0, 1]
+
+### Returns
+
+* (*mixed*) Returns the reduced single value of the array.
+
+### See also:
+- [MDC Array.reduceRight][]
+
+
+[Array]: /core/Types/Array
+[MDC Array.reduce]: https://developer.mozilla.org/En/Core_JavaScript_1.5_Reference/Global_Objects/Array/Reduce
+[MDC Array.reduceRight]: https://developer.mozilla.org/En/Core_JavaScript_1.5_Reference/Global_Objects/Array/ReduceRight

data/Packages/mootools-more/Docs/Types/Date.Extras.md

@@ -0,0 +1,97 @@
+Type Date {#Date}
+===================
+
+Extends the *Date* Type to include more powerful parsing and formatting functions; this is a further extention and depends on *[Date.js][]*.
+
+### Authors
+
+* Nicholas Barthelemy - https://svn.nbarthelemy.com/date-js/
+* Harald Kirshner - mail [at] digitarald.de ; http://digitarald.de
+* Aaron Newton - aaron [dot] newton [at] cnet [dot] com
+* Scott Kyle - scott [at] appden.com; http://appden.com
+
+### Tutorial/Demo
+
+* [Online Tutorial/Demo][]
+
+[Online Tutorial/Demo]: http://www.clientcide.com/wiki/cnet-libraries/03-native/01-date.extras
+
+### License
+
+MIT-style license
+	Extra Date Parsers: {#Date:parsers}
+-----------------------------------
+
+In addition to the two default parsers included in *[Date.js][]*, *Date.Extras.js* includes some additional parsers.
+
+### Examples
+
+	Date.parse('today') //"Mon Dec 10 2007 00:00:00 GMT-0800 (Pacific Standard Time)"
+	Date.parse('tomorrow') //"Tue Dec 11 2007 00:00:00 GMT-0800 (Pacific Standard Time)"
+	Date.parse('yesterday') //"Sun Dec 09 2007 00:00:00 GMT-0800 (Pacific Standard Time)"
+	Date.parse('next monday') //"Mon Dec 17 2007 00:00:00 GMT-0800 (Pacific Standard Time)"
+	Date.parse('last wednesday') //"Wed Dec 05 2007 00:00:00 GMT-0800 (Pacific Standard Time)"
+
+### See Also
+
+- [Date:parse][]
+
+Date Method: timeDiff {#Date:timeDiff}
+--------------------------------------
+
+Returns the difference between two dates in a compact format.
+
+### Syntax
+
+	date.timeDiff([to, separator]);
+
+### Arguments
+
+1. to - (*date*) the date to compare to; defaults to the current time.
+2. separator - (*string*, defaults to ':') the string used to separate the values.
+
+### Example
+
+	var example = new Date();
+	example.timeDiff(); //0s
+	example.decrement('minute');
+	example.timeDiff(); //1m:0s
+	example.decrement('hour');
+	example.timeDiff(); //1h:1m:0s
+	example.increment('hour', 2);
+	example.timeDiff(); //3h:1m:0s
+
+### Returns
+
+* (*string*) the compact representation of the differences in the times.
+
+Date Method: timeDiffInWords {#Date:timeDiffInWords}
+--------------------------------------------------
+
+### Syntax
+
+	date.timeDiffInWords([to]);
+
+### Arguments
+
+1. to - (*date*, optional) an optional date to use for the differential. Defaults to the current date/time.
+
+### Example
+
+	var example = new Date();
+	example.timeDiffInWords(); //less than a minute ago
+	example.decrement('hour');
+	example.timeDiffInWords(); //about an hour ago
+	example.increment('hour', 2);
+	example.timeDiffInWords(); //about an hour from now
+
+### Returns
+
+* (*string*) the friendly version of the duration since the date
+
+### Note
+
+This method is now an alias for the old *Date.timeAgoInWords*.
+
+[Date.js]: /more/Types/Date
+[Date:parse]: /more/Types/Date#Date:parse