gistfile1.js

var $break = { };
Object.extend = function(destination, source) {
  for (var property in source)
    destination[property] = source[property];
  return destination;
};
Object.extend(Object, {
  inspect: function(object) {
    try {
      if (Object.isUndefined(object)) return 'undefined';
      if (object === null) return 'null';
      return object.inspect ? object.inspect() : object.toString();
    } catch (e) {
      if (e instanceof RangeError) return '...';
      throw e;
    }
  },

  toJSON: function(object) {
    var type = typeof object;
    switch (type) {
      case 'undefined':
      case 'function':
      case 'unknown': return;
      case 'boolean': return object.toString();
    }

    if (object === null) return 'null';
    if (object.toJSON) return object.toJSON();
    if (Object.isElement(object)) return;

    var results = [];
    for (var property in object) {
      var value = Object.toJSON(object[property]);
      if (!Object.isUndefined(value))
        results.push(property.toJSON() + ': ' + value);
    }

    return '{' + results.join(', ') + '}';
  },

  toQueryString: function(object) {
    return $H(object).toQueryString();
  },

  toHTML: function(object) {
    return object && object.toHTML ? object.toHTML() : String.interpret(object);
  },

  keys: function(object) {
    var keys = [];
    for (var property in object)
      keys.push(property);
    return keys;
  },

  values: function(object) {
    var values = [];
    for (var property in object)
      values.push(object[property]);
    return values;
  },

  clone: function(object) {
    return Object.extend({ }, object);
  },

  isElement: function(object) {
    return object && object.nodeType == 1;
  },

  isArray: function(object) {
    return object && object.constructor === Array;
  },

  isHash: function(object) {
    return object instanceof Hash;
  },

  isFunction: function(object) {
    return typeof object == "function";
  },

  isString: function(object) {
    return typeof object == "string";
  },

  isNumber: function(object) {
    return typeof object == "number";
  },

  isUndefined: function(object) {
    return typeof object == "undefined";
  }
});
(function($) {
  $.enumerable = {
    each: function(iterator) {
      var index = 0;
      try {
        this._each(function(value) {
          iterator(value, index++);
        });
      } catch (e) {
        if (e != $break) throw e;
      }
      return this;
    },

    eachSlice: function(number, iterator) {
      var index = -number, slices = [], array = this.toArray();
      while ((index += number) < array.length)
        slices.push(array.slice(index, index+number));
      return slices.collect(iterator);
    },

    all: function(iterator) {
      var result = true;
      this.each(function(value, index) {
        result = result && !!iterator(value, index);
        if (!result) throw $break;
      });
      return result;
    },

    any: function(iterator) {
      var result = false;
      this.each(function(value, index) {
        if (result = !!iterator(value, index))
          throw $break;
      });
      return result;
    },

    collect: function(iterator) {
      var results = [];
      this.each(function(value, index) {
        results.push(iterator(value, index));
      });
      return results;
    },

    detect: function(iterator) {
      var result;
      this.each(function(value, index) {
        if (iterator(value, index)) {
          result = value;
          throw $break;
        }
      });
      return result;
    },

    findAll: function(iterator) {
      var results = [];
      this.each(function(value, index) {
        if (iterator(value, index))
          results.push(value);
      });
      return results;
    },

    grep: function(filter, iterator) {
      var results = [];

      if (Object.isString(filter))
        filter = new RegExp(filter);

      this.each(function(value, index) {
        if (filter.match(value))
          results.push(iterator(value, index));
      });
      return results;
    },

    include: function(object) {
      if (Object.isFunction(this.indexOf))
        if (this.indexOf(object) != -1) return true;

      var found = false;
      this.each(function(value) {
        if (value == object) {
          found = true;
          throw $break;
        }
      });
      return found;
    },

    inGroupsOf: function(number, fillWith) {
      fillWith = Object.isUndefined(fillWith) ? null : fillWith;
      return this.eachSlice(number, function(slice) {
        while(slice.length < number) slice.push(fillWith);
        return slice;
      });
    },

    inject: function(memo, iterator) {
      this.each(function(value, index) {
        memo = iterator(memo, value, index);
      });
      return memo;
    },

    max: function(iterator) {
      var result;
      this.each(function(value, index) {
        value = iterator(value, index);
        if (result == null || value >= result)
          result = value;
      });
      return result;
    },

    min: function(iterator) {
      var result;
      this.each(function(value, index) {
        value = iterator(value, index);
        if (result == null || value < result)
          result = value;
      });
      return result;
    },

    partition: function(iterator) {
      var trues = [], falses = [];
      this.each(function(value, index) {
        (iterator(value, index) ?
          trues : falses).push(value);
      });
      return [trues, falses];
    },

    pluck: function(property) {
      var results = [];
      this.each(function(value) {
        results.push(value[property]);
      });
      return results;
    },

    reject: function(iterator) {
      var results = [];
      this.each(function(value, index) {
        if (!iterator(value, index))
          results.push(value);
      });
      return results;
    },

    sortBy: function(iterator) {
      return this.map(function(value, index) {
        return {value: value, criteria: iterator(value, index)};
      }).sort(function(left, right) {
        var a = left.criteria, b = right.criteria;
        return a < b ? -1 : a > b ? 1 : 0;
      }).pluck('value');
    },

    toArray: function() {
      return this.map();
    },

    size: function() {
      return this.toArray().length;
    }
  }
  $.extend($.enumerable, {
    map:     $.enumerable.collect,
    find:    $.enumerable.detect,
    select:  $.enumerable.findAll,
    filter:  $.enumerable.findAll,
    member:  $.enumerable.include,
    entries: $.enumerable.toArray,
    every:   $.enumerable.all,
    some:    $.enumerable.any
  });
})(jQuery);

(function($){
  $.hash = {};
  $.extend($.hash, $.enumerable);
  
  $.extend($.hash, {
    init: function() {
      $.extend(this, $.enumerable);
      console.log(this.inspect());
      this._object = {};
      return this;
    },
    _each: function(iterator) {
      for (var key in this._object) {
        var value = this._object[key], pair = [key, value];
        pair.key = key;
        pair.value = value;
        iterator(pair);
      }
    },
    set: function(key, value) {
      return this._object[key] = value;
    },
    get: function(key) {
      return this._object[key];
    },
    keys: function() {
      return this.pluck('key');
    },
    values: function() {
      return this.pluck('value');
    },
    unset: function(key) {
      if (typeof key == 'unction') {
        var removed = [];
        $.each(this, function(k, v) {
          if (callback(k, v)) { 
            removed.push([k,v]);
            this.unset(k); 
          }
        })
        return removed;
      } else {
        var value = this.get(key);
        delete this._object[key];
        return value;
      }
    },
    index: function(value) {
      var match = this.detect(function(pair) {
        return pair.value === value;
      });
      return match && match.key;
    },
    sort: function() {
      var results = $.extend({}, $.hash);
      var sortedKeys = this.keys().sort();
      var _this = this;
      $.each(sortedKeys, function(idx, val) {
        results[val] = _this[val];
      });
      return results;
    },
    inspect: function() {
      return '#<Hash:{' + this.map(function(pair) {
        return pair.map(Object.inspect).join(': ');
      }).join(', ') + '}>';
    }
  });
})(jQuery);