/*
Script: String.js
        Contains String prototypes.

License:
        MIT-style license.
*/

/*
Class: String
        A collection of The String Object prototype methods.
*/

String.extend({

        /*
        Property: test
                Tests a string with a regular expression.

        Arguments:
                regex - a string or regular expression object, the regular expression you want to match the string with
                params - optional, if first parameter is a string, any parameters you want to pass to the regex ('g' has no effect)

        Returns:
                true if a match for the regular expression is found in the string, false if not.
                See <http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Objects:RegExp:test>

        Example:
                >"I like cookies".test("cookie"); // returns true
                >"I like cookies".test("COOKIE", "i") // ignore case, returns true
                >"I like cookies".test("cake"); // returns false
        */

        test: function(regex, params){
                return (($type(regex) == 'string') ? new RegExp(regex, params) : regex).test(this);
        },

        /*
        Property: toInt
                parses a string to an integer.

        Returns:
                either an int or "NaN" if the string is not a number.

        Example:
                >var value = "10px".toInt(); // value is 10
        */

        toInt: function(){
                return parseInt(this, 10);
        },

        /*
        Property: toFloat
                parses a string to an float.

        Returns:
                either a float or "NaN" if the string is not a number.

        Example:
                >var value = "10.848".toFloat(); // value is 10.848
        */

        toFloat: function(){
                return parseFloat(this);
        },

        /*
        Property: camelCase
                Converts a hiphenated string to a camelcase string.

        Example:
                >"I-like-cookies".camelCase(); //"ILikeCookies"

        Returns:
                the camel cased string
        */

        camelCase: function(){
                return this.replace(/-\D/g, function(match){
                        return match.charAt(1).toUpperCase();
                });
        },

        /*
        Property: hyphenate
                Converts a camelCased string to a hyphen-ated string.

        Example:
                >"ILikeCookies".hyphenate(); //"I-like-cookies"
        */

        hyphenate: function(){
                return this.replace(/\w[A-Z]/g, function(match){
                        return (match.charAt(0) + '-' + match.charAt(1).toLowerCase());
                });
        },

        /*
        Property: capitalize
                Converts the first letter in each word of a string to Uppercase.

        Example:
                >"i like cookies".capitalize(); //"I Like Cookies"

        Returns:
                the capitalized string
        */

        capitalize: function(){
                return this.replace(/\b[a-z]/g, function(match){
                        return match.toUpperCase();
                });
        },

        /*
        Property: trim
                Trims the leading and trailing spaces off a string.

        Example:
                >"    i like cookies     ".trim() //"i like cookies"

        Returns:
                the trimmed string
        */

        trim: function(){
                return this.replace(/^\s+|\s+$/g, '');
        },

        /*
        Property: clean
                trims (<String.trim>) a string AND removes all the double spaces in a string.

        Returns:
                the cleaned string

        Example:
                >" i      like     cookies      \n\n".clean() //"i like cookies"
        */

        clean: function(){
                return this.replace(/\s{2,}/g, ' ').trim();
        },

        /*
        Property: rgbToHex
                Converts an RGB value to hexidecimal. The string must be in the format of "rgb(255,255,255)" or "rgba(255,255,255,1)";

        Arguments:
                array - boolean value, defaults to false. Use true if you want the array ['FF','33','00'] as output instead of "#FF3300"

        Returns:
                hex string or array. returns "transparent" if the output is set as string and the fourth value of rgba in input string is 0.

        Example:
                >"rgb(17,34,51)".rgbToHex(); //"#112233"
                >"rgba(17,34,51,0)".rgbToHex(); //"transparent"
                >"rgb(17,34,51)".rgbToHex(true); //['11','22','33']
        */

        rgbToHex: function(array){
                var rgb = this.match(/\d{1,3}/g);
                return (rgb) ? rgb.rgbToHex(array) : false;
        },

        /*
        Property: hexToRgb
                Converts a hexidecimal color value to RGB. Input string must be the hex color value (with or without the hash). Also accepts triplets ('333');

        Arguments:
                array - boolean value, defaults to false. Use true if you want the array [255,255,255] as output instead of "rgb(255,255,255)";

        Returns:
                rgb string or array.

        Example:
                >"#112233".hexToRgb(); //"rgb(17,34,51)"
                >"#112233".hexToRgb(true); //[17,34,51]
        */

        hexToRgb: function(array){
                var hex = this.match(/^#?(\w{1,2})(\w{1,2})(\w{1,2})$/);
                return (hex) ? hex.slice(1).hexToRgb(array) : false;
        },

        /*
        Property: contains
                checks if the passed in string is contained in the String. also accepts an optional second parameter, to check if the string is contained in a list of separated values.

        Example:
                >'a b c'.contains('c', ' '); //true
                >'a bc'.contains('bc'); //true
                >'a bc'.contains('b', ' '); //false
        */

        contains: function(string, s){
                return (s) ? (s + this + s).indexOf(s + string + s) > -1 : this.indexOf(string) > -1;
        },

        /*
        Property: escapeRegExp
                Returns string with escaped regular expression characters

        Example:
                >var search = 'animals.sheeps[1]'.escapeRegExp(); // search is now 'animals\.sheeps\[1\]'

        Returns:
                Escaped string
        */

        escapeRegExp: function(){
                return this.replace(/([.*+?^${}()|[\]\/\\])/g, '\\$1');
        },

        replaceToString: function(search, replace){        	    var pos = 0, str = new String(this);
                while ((pos = str.indexOf(search, pos)) > -1)
                {
                   str = str.substr(0, pos) + replace + str.substr(pos + search.length);
                   pos += replace.length;
                }
                return str;        }

});