// MooTools: the javascript framework.
// Load this file's selection again by visiting: http://mootools.net/more/98f0420495fa7ed52fb3dc6d680108a9 
// Or build this file again with packager using: packager build More/Hash More/Hash.Extras
/*
---

script: More.js

name: More

description: MooTools More

license: MIT-style license

authors:
  - Guillermo Rauch
  - Thomas Aylott
  - Scott Kyle
  - Arian Stolwijk
  - Tim Wienk
  - Christoph Pojer
  - Aaron Newton
  - Jacob Thornton

requires:
  - Core/MooTools

provides: [MooTools.More]

...
*/

MooTools.More = {
        'version': '1.4.0.1',
        'build': 'a4244edf2aa97ac8a196fc96082dd35af1abab87'
};


/*
---

name: Hash

description: Contains Hash Prototypes. Provides a means for overcoming the JavaScript practical impossibility of extending native Objects.

license: MIT-style license.

requires:
  - Core/Object
  - /MooTools.More

provides: [Hash]

...
*/

(function(){

if (this.Hash) return;

var Hash = this.Hash = new Type('Hash', function(object){
        if (typeOf(object) == 'hash') object = Object.clone(object.getClean());
        for (var key in object) this[key] = object[key];
        return this;
});

this.$H = function(object){
        return new Hash(object);
};

Hash.implement({

        forEach: function(fn, bind){
                Object.forEach(this, fn, bind);
        },

        getClean: function(){
                var clean = {};
                for (var key in this){
                        if (this.hasOwnProperty(key)) clean[key] = this[key];
                }
                return clean;
        },

        getLength: function(){
                var length = 0;
                for (var key in this){
                        if (this.hasOwnProperty(key)) length++;
                }
                return length;
        }

});

Hash.alias('each', 'forEach');

Hash.implement({

        has: Object.prototype.hasOwnProperty,

        keyOf: function(value){
                return Object.keyOf(this, value);
        },

        hasValue: function(value){
                return Object.contains(this, value);
        },

        extend: function(properties){
                Hash.each(properties || {}, function(value, key){
                        Hash.set(this, key, value);
                }, this);
                return this;
        },

        combine: function(properties){
                Hash.each(properties || {}, function(value, key){
                        Hash.include(this, key, value);
                }, this);
                return this;
        },

        erase: function(key){
                if (this.hasOwnProperty(key)) delete this[key];
                return this;
        },

        get: function(key){
                return (this.hasOwnProperty(key)) ? this[key] : null;
        },

        set: function(key, value){
                if (!this[key] || this.hasOwnProperty(key)) this[key] = value;
                return this;
        },

        empty: function(){
                Hash.each(this, function(value, key){
                        delete this[key];
                }, this);
                return this;
        },

        include: function(key, value){
                if (this[key] == undefined) this[key] = value;
                return this;
        },

        map: function(fn, bind){
                return new Hash(Object.map(this, fn, bind));
        },

        filter: function(fn, bind){
                return new Hash(Object.filter(this, fn, bind));
        },

        every: function(fn, bind){
                return Object.every(this, fn, bind);
        },

        some: function(fn, bind){
                return Object.some(this, fn, bind);
        },

        getKeys: function(){
                return Object.keys(this);
        },

        getValues: function(){
                return Object.values(this);
        },

        toQueryString: function(base){
                return Object.toQueryString(this, base);
        }

});

Hash.alias({indexOf: 'keyOf', contains: 'hasValue'});


})();



/*
---

script: Object.Extras.js

name: Object.Extras

description: Extra Object generics, like getFromPath which allows a path notation to child elements.

license: MIT-style license

authors:
  - Aaron Newton

requires:
  - Core/Object
  - /MooTools.More

provides: [Object.Extras]

...
*/

(function(){

var defined = function(value){
        return value != null;
};

var hasOwnProperty = Object.prototype.hasOwnProperty;

Object.extend({

        getFromPath: function(source, parts){
                if (typeof parts == 'string') parts = parts.split('.');
                for (var i = 0, l = parts.length; i < l; i++){
                        if (hasOwnProperty.call(source, parts[i])) source = source[parts[i]];
                        else return null;
                }
                return source;
        },

        cleanValues: function(object, method){
                method = method || defined;
                for (var key in object) if (!method(object[key])){
                        delete object[key];
                }
                return object;
        },

        erase: function(object, key){
                if (hasOwnProperty.call(object, key)) delete object[key];
                return object;
        },

        run: function(object){
                var args = Array.slice(arguments, 1);
                for (var key in object) if (object[key].apply){
                        object[key].apply(object, args);
                }
                return object;
        }

});

})();


/*
---

script: Hash.Extras.js

name: Hash.Extras

description: Extends the Hash Type to include getFromPath which allows a path notation to child elements.

license: MIT-style license

authors:
  - Aaron Newton

requires:
  - /Hash
  - /Object.Extras

provides: [Hash.Extras]

...
*/

Hash.implement({

        getFromPath: function(notation){
                return Object.getFromPath(this, notation);
        },

        cleanValues: function(method){
                return new Hash(Object.cleanValues(this, method));
        },

        run: function(){
                Object.run(arguments);
        }

});