yellow-brick-road 0.1.2 → 0.2.0

data/test/dummy/tmp/cache/assets/CF6/9D0/sprockets%2F34b7199e9d33994c8ec7a442d60ca985

@@ -0,0 +1,173 @@
+o: ActiveSupport::Cache::Entry	:@compressedF:@expires_in0:@created_atf1325549268.219309:@value{	I"length:EFiI"digest;
+F"%6c9c6de4d95a1566338ea1406209605aI"source;
+FI"// Copyright 2006 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/**
+ * @fileoverview Utility for fast string concatenation.
+ */
+
+
+goog.provide('goog.string.StringBuffer');
+
+goog.require('goog.userAgent.jscript');
+
+
+
+/**
+ * Utility class to facilitate much faster string concatenation in IE,
+ * using Array.join() rather than the '+' operator.  For other browsers
+ * we simply use the '+' operator.
+ *
+ * @param {Object|number|string|boolean=} opt_a1 Optional first initial item
+ *     to append.
+ * @param {...Object|number|string|boolean} var_args Other initial items to
+ *     append, e.g., new goog.string.StringBuffer('foo', 'bar').
+ * @constructor
+ */
+goog.string.StringBuffer = function(opt_a1, var_args) {
+  /**
+   * Internal buffer for the string to be concatenated.
+   * @type {string|Array}
+   * @private
+   */
+  this.buffer_ = goog.userAgent.jscript.HAS_JSCRIPT ? [] : '';
+
+  if (opt_a1 != null) {
+    this.append.apply(this, arguments);
+  }
+};
+
+
+/**
+ * Sets the contents of the string buffer object, replacing what's currently
+ * there.
+ *
+ * @param {string} s String to set.
+ */
+goog.string.StringBuffer.prototype.set = function(s) {
+  this.clear();
+  this.append(s);
+};
+
+
+if (goog.userAgent.jscript.HAS_JSCRIPT) {
+  /**
+   * Length of internal buffer (faster than calling buffer_.length).
+   * Only used if buffer_ is an array.
+   * @type {number}
+   * @private
+   */
+  goog.string.StringBuffer.prototype.bufferLength_ = 0;
+
+  /**
+   * Appends one or more items to the buffer.
+   *
+   * Calling this with null, undefined, or empty arguments is an error.
+   *
+   * @param {Object|number|string|boolean} a1 Required first string.
+   * @param {Object|number|string|boolean=} opt_a2 Optional second string.
+   * @param {...Object|number|string|boolean} var_args Other items to append,
+   *     e.g., sb.append('foo', 'bar', 'baz').
+   * @return {goog.string.StringBuffer} This same StringBuffer object.
+   */
+  goog.string.StringBuffer.prototype.append = function(a1, opt_a2, var_args) {
+    // IE version.
+
+    if (opt_a2 == null) { // second argument is undefined (null == undefined)
+      // Array assignment is 2x faster than Array push.  Also, use a1
+      // directly to avoid arguments instantiation, another 2x improvement.
+      this.buffer_[this.bufferLength_++] = a1;
+    } else {
+      this.buffer_.push.apply(/** @type {Array} */ (this.buffer_), arguments);
+      this.bufferLength_ = this.buffer_.length;
+    }
+    return this;
+  };
+} else {
+
+  /**
+   * Appends one or more items to the buffer.
+   *
+   * Calling this with null, undefined, or empty arguments is an error.
+   *
+   * @param {Object|number|string|boolean} a1 Required first string.
+   * @param {Object|number|string|boolean=} opt_a2 Optional second string.
+   * @param {...Object|number|string|boolean} var_args Other items to append,
+   *     e.g., sb.append('foo', 'bar', 'baz').
+   * @return {goog.string.StringBuffer} This same StringBuffer object.
+   * @suppress {duplicate}
+   */
+  goog.string.StringBuffer.prototype.append = function(a1, opt_a2, var_args) {
+    // W3 version.
+
+    // Use a1 directly to avoid arguments instantiation for single-arg case.
+    this.buffer_ += a1;
+    if (opt_a2 != null) { // second argument is undefined (null == undefined)
+      for (var i = 1; i < arguments.length; i++) {
+        this.buffer_ += arguments[i];
+      }
+    }
+    return this;
+  };
+}
+
+
+/**
+ * Clears the internal buffer.
+ */
+goog.string.StringBuffer.prototype.clear = function() {
+  if (goog.userAgent.jscript.HAS_JSCRIPT) {
+     this.buffer_.length = 0;  // Reuse the array to avoid creating new object.
+     this.bufferLength_ = 0;
+   } else {
+     this.buffer_ = '';
+   }
+};
+
+
+/**
+ * Returns the length of the current contents of the buffer.  In IE, this is
+ * O(n) where n = number of appends, so to avoid quadratic behavior, do not call
+ * this after every append.
+ *
+ * @return {number} the length of the current contents of the buffer.
+ */
+goog.string.StringBuffer.prototype.getLength = function() {
+   return this.toString().length;
+};
+
+
+/**
+ * Returns the concatenated string.
+ *
+ * @return {string} The concatenated string.
+ */
+goog.string.StringBuffer.prototype.toString = function() {
+  if (goog.userAgent.jscript.HAS_JSCRIPT) {
+    var str = this.buffer_.join('');
+    // Given a string with the entire contents, simplify the StringBuffer by
+    // setting its contents to only be this string, rather than many fragments.
+    this.clear();
+    if (str) {
+      this.append(str);
+    }
+    return str;
+  } else {
+    return /** @type {string} */ (this.buffer_);
+  }
+};
+;
+FI"
+F"%823b8d430427543b670a3eb589ceb8e1

data/test/dummy/tmp/cache/assets/CFA/A90/sprockets%2F901ba405a6d6747f6412ed4d0e0ac620

@@ -0,0 +1,256 @@
+o: ActiveSupport::Cache::Entry	:@compressedF:@expires_in0:@created_atf1325549267.947605:@value{I"
+class:EFI"BundledAsset;
+FI"id;
+F"%63b9d027b59e7be971ed4a60289d3001I"logical_path;
+FI" closure/goog/dom/classes.js;
+TI"
+F"
�/Users/ali/.rvm/gems/ruby-1.9.3-p0/bundler/gems/closure-library-wrapper-b30bab11ab83/vendor/closure-library/closure/goog/dom/classes.jsI"content_type;
+FI"application/javascript;
+FI"
+mtime;
+FI"2012-01-03T00:06:51+00:00;
+FI"	body;
+FI"%// Copyright 2006 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/**
+ * @fileoverview Utilities for adding, removing and setting classes.
+ *
+ */
+
+
+
+goog.provide('goog.dom.classes');
+
+goog.require('goog.array');
+
+
+/**
+ * Sets the entire class name of an element.
+ * @param {Node} element DOM node to set class of.
+ * @param {string} className Class name(s) to apply to element.
+ */
+goog.dom.classes.set = function(element, className) {
+  element.className = className;
+};
+
+
+/**
+ * Gets an array of class names on an element
+ * @param {Node} element DOM node to get class of.
+ * @return {Array} Class names on {@code element}.
+ */
+goog.dom.classes.get = function(element) {
+  var className = element.className;
+  // Some types of elements don't have a className in IE (e.g. iframes).
+  // Furthermore, in Firefox, className is not a string when the element is
+  // an SVG element.
+  return className && typeof className.split == 'function' ?
+      className.split(/\s+/) : [];
+};
+
+
+/**
+ * Adds a class or classes to an element. Does not add multiples of class names.
+ * @param {Node} element DOM node to add class to.
+ * @param {...string} var_args Class names to add.
+ * @return {boolean} Whether class was added (or all classes were added).
+ */
+goog.dom.classes.add = function(element, var_args) {
+  var classes = goog.dom.classes.get(element);
+  var args = goog.array.slice(arguments, 1);
+
+  var b = goog.dom.classes.add_(classes, args);
+  element.className = classes.join(' ');
+
+  return b;
+};
+
+
+/**
+ * Removes a class or classes from an element.
+ * @param {Node} element DOM node to remove class from.
+ * @param {...string} var_args Class name(s) to remove.
+ * @return {boolean} Whether all classes in {@code var_args} were found and
+ *     removed.
+ */
+goog.dom.classes.remove = function(element, var_args) {
+  var classes = goog.dom.classes.get(element);
+  var args = goog.array.slice(arguments, 1);
+
+  var b = goog.dom.classes.remove_(classes, args);
+  element.className = classes.join(' ');
+
+  return b;
+};
+
+
+/**
+ * Helper method for {@link goog.dom.classes.add} and
+ * {@link goog.dom.classes.addRemove}. Adds one or more classes to the supplied
+ * classes array.
+ * @param {Array.<string>} classes All class names for the element, will be
+ *     updated to have the classes supplied in {@code args} added.
+ * @param {Array.<string>} args Class names to add.
+ * @return {boolean} Whether all classes in were added.
+ * @private
+ */
+goog.dom.classes.add_ = function(classes, args) {
+  var rv = 0;
+  for (var i = 0; i < args.length; i++) {
+    if (!goog.array.contains(classes, args[i])) {
+      classes.push(args[i]);
+      rv++;
+    }
+  }
+  return rv == args.length;
+};
+
+
+/**
+ * Helper method for {@link goog.dom.classes.remove} and
+ * {@link goog.dom.classes.addRemove}. Removes one or more classes from the
+ * supplied classes array.
+ * @param {Array.<string>} classes All class names for the element, will be
+ *     updated to have the classes supplied in {@code args} removed.
+ * @param {Array.<string>} args Class names to remove.
+ * @return {boolean} Whether all classes in were found and removed.
+ * @private
+ */
+goog.dom.classes.remove_ = function(classes, args) {
+  var rv = 0;
+  for (var i = 0; i < classes.length; i++) {
+    if (goog.array.contains(args, classes[i])) {
+      goog.array.splice(classes, i--, 1);
+      rv++;
+    }
+  }
+  return rv == args.length;
+};
+
+
+/**
+ * Switches a class on an element from one to another without disturbing other
+ * classes. If the fromClass isn't removed, the toClass won't be added.
+ * @param {Node} element DOM node to swap classes on.
+ * @param {string} fromClass Class to remove.
+ * @param {string} toClass Class to add.
+ * @return {boolean} Whether classes were switched.
+ */
+goog.dom.classes.swap = function(element, fromClass, toClass) {
+  var classes = goog.dom.classes.get(element);
+
+  var removed = false;
+  for (var i = 0; i < classes.length; i++) {
+    if (classes[i] == fromClass) {
+      goog.array.splice(classes, i--, 1);
+      removed = true;
+    }
+  }
+
+  if (removed) {
+    classes.push(toClass);
+    element.className = classes.join(' ');
+  }
+
+  return removed;
+};
+
+
+/**
+ * Adds zero or more classes to an element and removes zero or more as a single
+ * operation. Unlike calling {@link goog.dom.classes.add} and
+ * {@link goog.dom.classes.remove} separately, this is more efficient as it only
+ * parses the class property once.
+ *
+ * If a class is in both the remove and add lists, it will be added. Thus,
+ * you can use this instead of {@link goog.dom.classes.swap} when you have
+ * more than two class names that you want to swap.
+ *
+ * @param {Node} element DOM node to swap classes on.
+ * @param {string|Array.<string>|null} classesToRemove Class or classes to
+ *     remove, if null no classes are removed.
+ * @param {string|Array.<string>|null} classesToAdd Class or classes to add, if
+ *     null no classes are added.
+ */
+goog.dom.classes.addRemove = function(element, classesToRemove, classesToAdd) {
+  var classes = goog.dom.classes.get(element);
+  if (goog.isString(classesToRemove)) {
+    goog.array.remove(classes, classesToRemove);
+  } else if (goog.isArray(classesToRemove)) {
+    goog.dom.classes.remove_(classes, classesToRemove);
+  }
+
+  if (goog.isString(classesToAdd) &&
+      !goog.array.contains(classes, classesToAdd)) {
+    classes.push(classesToAdd);
+  } else if (goog.isArray(classesToAdd)) {
+    goog.dom.classes.add_(classes, classesToAdd);
+  }
+
+  element.className = classes.join(' ');
+};
+
+
+/**
+ * Returns true if an element has a class.
+ * @param {Node} element DOM node to test.
+ * @param {string} className Class name to test for.
+ * @return {boolean} Whether element has the class.
+ */
+goog.dom.classes.has = function(element, className) {
+  return goog.array.contains(goog.dom.classes.get(element), className);
+};
+
+
+/**
+ * Adds or removes a class depending on the enabled argument.
+ * @param {Node} element DOM node to add or remove the class on.
+ * @param {string} className Class name to add or remove.
+ * @param {boolean} enabled Whether to add or remove the class (true adds,
+ *     false removes).
+ */
+goog.dom.classes.enable = function(element, className, enabled) {
+  if (enabled) {
+    goog.dom.classes.add(element, className);
+  } else {
+    goog.dom.classes.remove(element, className);
+  }
+};
+
+
+/**
+ * Removes a class if an element has it, and adds it the element doesn't have
+ * it.  Won't affect other classes on the node.
+ * @param {Node} element DOM node to toggle class on.
+ * @param {string} className Class to toggle.
+ * @return {boolean} True if class was added, false if it was removed
+ *     (in other words, whether element has the class after this function has
+ *     been called).
+ */
+goog.dom.classes.toggle = function(element, className) {
+  var add = !goog.dom.classes.has(element, className);
+  goog.dom.classes.enable(element, className, add);
+  return add;
+};
+;
+FI"asset_paths;
+F["
�/Users/ali/.rvm/gems/ruby-1.9.3-p0/bundler/gems/closure-library-wrapper-b30bab11ab83/vendor/closure-library/closure/goog/dom/classes.jsI"dependency_paths;
+F[{I"	path;
+F"
�/Users/ali/.rvm/gems/ruby-1.9.3-p0/bundler/gems/closure-library-wrapper-b30bab11ab83/vendor/closure-library/closure/goog/dom/classes.jsI"
+mtime;
+FIu:	Time
+T:offsetiI"hexdigest;
+F"%afe16d90ef6698eeee0daf89e1735ef6I"
+F"%46dde6621c301f4928e3b34efee9e3b5

data/test/dummy/tmp/cache/assets/CFC/E70/sprockets%2F8ee639668b5f0e629fbe0d62d1394689

@@ -0,0 +1,173 @@
+o: ActiveSupport::Cache::Entry	:@compressedF:@expires_in0:@created_atf1325538162.4182222:@value{	I"length:EFiI"digest;
+F"%6c9c6de4d95a1566338ea1406209605aI"source;
+FI"// Copyright 2006 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/**
+ * @fileoverview Utility for fast string concatenation.
+ */
+
+
+goog.provide('goog.string.StringBuffer');
+
+goog.require('goog.userAgent.jscript');
+
+
+
+/**
+ * Utility class to facilitate much faster string concatenation in IE,
+ * using Array.join() rather than the '+' operator.  For other browsers
+ * we simply use the '+' operator.
+ *
+ * @param {Object|number|string|boolean=} opt_a1 Optional first initial item
+ *     to append.
+ * @param {...Object|number|string|boolean} var_args Other initial items to
+ *     append, e.g., new goog.string.StringBuffer('foo', 'bar').
+ * @constructor
+ */
+goog.string.StringBuffer = function(opt_a1, var_args) {
+  /**
+   * Internal buffer for the string to be concatenated.
+   * @type {string|Array}
+   * @private
+   */
+  this.buffer_ = goog.userAgent.jscript.HAS_JSCRIPT ? [] : '';
+
+  if (opt_a1 != null) {
+    this.append.apply(this, arguments);
+  }
+};
+
+
+/**
+ * Sets the contents of the string buffer object, replacing what's currently
+ * there.
+ *
+ * @param {string} s String to set.
+ */
+goog.string.StringBuffer.prototype.set = function(s) {
+  this.clear();
+  this.append(s);
+};
+
+
+if (goog.userAgent.jscript.HAS_JSCRIPT) {
+  /**
+   * Length of internal buffer (faster than calling buffer_.length).
+   * Only used if buffer_ is an array.
+   * @type {number}
+   * @private
+   */
+  goog.string.StringBuffer.prototype.bufferLength_ = 0;
+
+  /**
+   * Appends one or more items to the buffer.
+   *
+   * Calling this with null, undefined, or empty arguments is an error.
+   *
+   * @param {Object|number|string|boolean} a1 Required first string.
+   * @param {Object|number|string|boolean=} opt_a2 Optional second string.
+   * @param {...Object|number|string|boolean} var_args Other items to append,
+   *     e.g., sb.append('foo', 'bar', 'baz').
+   * @return {goog.string.StringBuffer} This same StringBuffer object.
+   */
+  goog.string.StringBuffer.prototype.append = function(a1, opt_a2, var_args) {
+    // IE version.
+
+    if (opt_a2 == null) { // second argument is undefined (null == undefined)
+      // Array assignment is 2x faster than Array push.  Also, use a1
+      // directly to avoid arguments instantiation, another 2x improvement.
+      this.buffer_[this.bufferLength_++] = a1;
+    } else {
+      this.buffer_.push.apply(/** @type {Array} */ (this.buffer_), arguments);
+      this.bufferLength_ = this.buffer_.length;
+    }
+    return this;
+  };
+} else {
+
+  /**
+   * Appends one or more items to the buffer.
+   *
+   * Calling this with null, undefined, or empty arguments is an error.
+   *
+   * @param {Object|number|string|boolean} a1 Required first string.
+   * @param {Object|number|string|boolean=} opt_a2 Optional second string.
+   * @param {...Object|number|string|boolean} var_args Other items to append,
+   *     e.g., sb.append('foo', 'bar', 'baz').
+   * @return {goog.string.StringBuffer} This same StringBuffer object.
+   * @suppress {duplicate}
+   */
+  goog.string.StringBuffer.prototype.append = function(a1, opt_a2, var_args) {
+    // W3 version.
+
+    // Use a1 directly to avoid arguments instantiation for single-arg case.
+    this.buffer_ += a1;
+    if (opt_a2 != null) { // second argument is undefined (null == undefined)
+      for (var i = 1; i < arguments.length; i++) {
+        this.buffer_ += arguments[i];
+      }
+    }
+    return this;
+  };
+}
+
+
+/**
+ * Clears the internal buffer.
+ */
+goog.string.StringBuffer.prototype.clear = function() {
+  if (goog.userAgent.jscript.HAS_JSCRIPT) {
+     this.buffer_.length = 0;  // Reuse the array to avoid creating new object.
+     this.bufferLength_ = 0;
+   } else {
+     this.buffer_ = '';
+   }
+};
+
+
+/**
+ * Returns the length of the current contents of the buffer.  In IE, this is
+ * O(n) where n = number of appends, so to avoid quadratic behavior, do not call
+ * this after every append.
+ *
+ * @return {number} the length of the current contents of the buffer.
+ */
+goog.string.StringBuffer.prototype.getLength = function() {
+   return this.toString().length;
+};
+
+
+/**
+ * Returns the concatenated string.
+ *
+ * @return {string} The concatenated string.
+ */
+goog.string.StringBuffer.prototype.toString = function() {
+  if (goog.userAgent.jscript.HAS_JSCRIPT) {
+    var str = this.buffer_.join('');
+    // Given a string with the entire contents, simplify the StringBuffer by
+    // setting its contents to only be this string, rather than many fragments.
+    this.clear();
+    if (str) {
+      this.append(str);
+    }
+    return str;
+  } else {
+    return /** @type {string} */ (this.buffer_);
+  }
+};
+;
+FI"
+F"%86edd9edee449acc435e63971d4584a9