CPString.j

Go to the documentation of this file.

/*
 * CPString.j
 * Foundation
 *
 * Created by Francisco Tolmasky.
 * Copyright 2008, 280 North, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */



@global CPInvalidArgumentException
@global CPRangeException

CPCaseInsensitiveSearch = 1;
CPLiteralSearch         = 2;
CPBackwardsSearch       = 4;
CPAnchoredSearch        = 8;
CPNumericSearch         = 64;
CPDiacriticInsensitiveSearch = 128;

var CPStringUIDs = new CFMutableDictionary(),

    CPStringRegexSpecialCharacters = [
      '/', '.', '*', '+', '?', '|', ', '^',
      '(', ')', '[', ']', '{', '}', '\\'
    ],
    CPStringRegexEscapeExpression = new RegExp("(\\" + CPStringRegexSpecialCharacters.join("|\\") + ")", 'g'),
    CPStringRegexTrimWhitespace = new RegExp("(^\\s+|\\s+$)", 'g');

@implementation CPString : CPObject
{
    id __doxygen__;
}

/*
    @ignore
*/
+ (id)alloc
{
    if ([self class] !== CPString)
       return [super alloc];

    return new String;
}

+ (id)string
{
    return [[self alloc] init];
}

+ (id)stringWithHash:(unsigned)aHash
{
    var hashString = parseInt(aHash, 10).toString(16);
    return "000000".substring(0, MAX(6 - hashString.length, 0)) + hashString;
}

+ (id)stringWithString:(CPString)aString
{
    if (!aString)
        [CPException raise:CPInvalidArgumentException
                    reason:"stringWithString: the string can't be 'nil'"];

    return [[self alloc] initWithString:aString];
}

- (id)initWithString:(CPString)aString
{
    if ([self class] === CPString)
        return String(aString);

    var result = new String(aString);

    result.isa = [self class];

    return result;
}

- (id)initWithFormat:(CPString)format, ...
{
    if (!format)
        [CPException raise:CPInvalidArgumentException
                    reason:"initWithFormat: the format can't be 'nil'"];

    self = ObjectiveJ.sprintf.apply(this, Array.prototype.slice.call(arguments, 2));
    return self;
}

+ (id)stringWithFormat:(CPString)format, ...
{
    if (!format)
        [CPException raise:CPInvalidArgumentException
                    reason:"initWithFormat: the format can't be 'nil'"];

    return ObjectiveJ.sprintf.apply(this, Array.prototype.slice.call(arguments, 2));
}

- (CPString)description
{
    return self;
}

- (int)length
{
    return self.length;
}

- (CPString)characterAtIndex:(CPUInteger)anIndex
{
    return self.charAt(anIndex);
}

// Combining strings

- (CPString)stringByAppendingFormat:(CPString)format, ...
{
    if (!format)
        [CPException raise:CPInvalidArgumentException reason:"initWithFormat: the format can't be 'nil'"];

    return self + ObjectiveJ.sprintf.apply(this, Array.prototype.slice.call(arguments, 2));
}

- (CPString)stringByAppendingString:(CPString)aString
{
    return self + aString;
}

- (CPString)stringByPaddingToLength:(unsigned)aLength withString:(CPString)aString startingAtIndex:(CPUInteger)anIndex
{
    if (self.length == aLength)
        return self;

    if (aLength < self.length)
        return self.substr(0, aLength);

    var string = self,
        substring = aString.substring(anIndex),
        difference = aLength - self.length;

    while ((difference -= substring.length) >= 0)
        string += substring;

    if (-difference < substring.length)
        string += substring.substring(0, -difference);

    return string;
}

//Dividing Strings
- (CPArray)componentsSeparatedByString:(CPString)aString
{
    return self.split(aString);
}

- (CPString)substringFromIndex:(unsigned)anIndex
{
    return self.substr(anIndex);
}

- (CPString)substringWithRange:(CPRange)aRange
{
    if (aRange.location < 0 || CPMaxRange(aRange) > self.length)
        [CPException raise:CPRangeException reason:"aRange out of bounds"];

    return self.substr(aRange.location, aRange.length);
}

- (CPString)substringToIndex:(unsigned)anIndex
{
    if (anIndex > self.length)
        [CPException raise:CPRangeException reason:"index out of bounds"];

    return self.substring(0, anIndex);
}

// Finding characters and substrings

- (CPRange)rangeOfString:(CPString)aString
{
   return [self rangeOfString:aString options:0];
}

- (CPRange)rangeOfString:(CPString)aString options:(int)aMask
{
    return [self rangeOfString:aString options:aMask range:nil];
}

- (CPRange)rangeOfString:(CPString)aString options:(int)aMask range:(CPrange)aRange
{
    // Searching for @"" always returns CPNotFound.
    if (!aString)
        return CPMakeRange(CPNotFound, 0);

    var string = (aRange == nil) ? self : [self substringWithRange:aRange],
        location = CPNotFound;

    if (aMask & CPCaseInsensitiveSearch)
    {
        string = string.toLowerCase();
        aString = aString.toLowerCase();
    }
    if (aMask & CPDiacriticInsensitiveSearch)
    {
        string = string.stripDiacritics();
        aString = aString.stripDiacritics();
    }

    if (aMask & CPBackwardsSearch)
    {
        location = string.lastIndexOf(aString);
        if (aMask & CPAnchoredSearch && location + aString.length != string.length)
            location = CPNotFound;
    }
    else if (aMask & CPAnchoredSearch)
        location = string.substr(0, aString.length).indexOf(aString) != CPNotFound ? 0 : CPNotFound;
    else
        location = string.indexOf(aString);

    if (location == CPNotFound)
        return CPMakeRange(CPNotFound, 0);

    return CPMakeRange(location + (aRange ? aRange.location : 0), aString.length);
}

//Replacing Substrings

- (CPString)stringByEscapingRegexControlCharacters
{
    return self.replace(CPStringRegexEscapeExpression, "\\$1");
}

- (CPString)stringByReplacingOccurrencesOfString:(CPString)target withString:(CPString)replacement
{
    return self.replace(new RegExp([target stringByEscapingRegexControlCharacters], "g"), replacement);
}

/*
    Returns a new string in which all occurrences of a target string in a specified range of the receiver
    are replaced by another given string.
    @param target The string to replace
    @param replacement the string with which to replace the \c target.
    @param options A mask of options to use when comparing \c target with the receiver. Pass 0 to specify no options
    @param searchRange The range in the receiver in which to search for \c target.
*/

- (CPString)stringByReplacingOccurrencesOfString:(CPString)target withString:(CPString)replacement options:(int)options range:(CPRange)searchRange
{
    var start = self.substring(0, searchRange.location),
        stringSegmentToSearch = self.substr(searchRange.location, searchRange.length),
        end = self.substring(searchRange.location + searchRange.length, self.length),
        target = [target stringByEscapingRegexControlCharacters],
        regExp;

    if (options & CPCaseInsensitiveSearch)
        regExp = new RegExp(target, "gi");
    else
        regExp = new RegExp(target, "g");

    return start + '' + stringSegmentToSearch.replace(regExp, replacement) + '' + end;
}

/*
   Returns a new string in which the characters in a specified range of the receiver
   are replaced by a given string.
   @param range A range of characters in the receiver.
   @param replacement The string with which to replace the characters in \c range.
*/

- (CPString)stringByReplacingCharactersInRange:(CPRange)range withString:(CPString)replacement
{
    return '' + self.substring(0, range.location) + replacement + self.substring(range.location + range.length, self.length);
}

- (CPString)stringByTrimmingWhitespace
{
    return self.replace(CPStringRegexTrimWhitespace, "");
}

// Identifying and comparing strings

- (CPComparisonResult)compare:(CPString)aString
{
    return [self compare:aString options:nil];
}

/*
    Compares the receiver to the specified string.
    @param aString the string with which to compare
    @return the result of the comparison
*/
- (CPComparisonResult)caseInsensitiveCompare:(CPString)aString
{
    return [self compare:aString options:CPCaseInsensitiveSearch];
}

// This is for speed
var CPStringNull = [CPNull null];

- (CPComparisonResult)compare:(CPString)aString options:(int)aMask
{
    if (aString === nil)
        return CPOrderedDescending;

    if (aString === CPStringNull)
        [CPException raise:CPInvalidArgumentException reason:"compare: argument can't be 'CPNull'"];

    var lhs = self,
        rhs = aString;

    if (aMask & CPCaseInsensitiveSearch)
    {
        lhs = lhs.toLowerCase();
        rhs = rhs.toLowerCase();
    }

    if (aMask & CPDiacriticInsensitiveSearch)
    {
        lhs = lhs.stripDiacritics();
        rhs = rhs.stripDiacritics();
    }

    if (lhs < rhs)
        return CPOrderedAscending;

    if (lhs > rhs)
        return CPOrderedDescending;

    return CPOrderedSame;
}

- (CPComparisonResult)compare:(CPString)aString options:(int)aMask range:(CPRange)range
{
    var lhs = [self substringWithRange:range],
        rhs = aString;

    return [lhs compare:rhs options:aMask];
}

- (BOOL)hasPrefix:(CPString)aString
{
    return aString && aString != "" && self.indexOf(aString) == 0;
}

- (BOOL)hasSuffix:(CPString)aString
{
    return aString && aString != "" && self.length >= aString.length && self.lastIndexOf(aString) == (self.length - aString.length);
}

- (BOOL)isEqual:(id)anObject
{
    if (self === anObject)
        return YES;

    if (!anObject || ![anObject isKindOfClass:[CPString class]])
        return NO;

    return [self isEqualToString:anObject];
}


- (BOOL)isEqualToString:(CPString)aString
{
    return self == String(aString);
}

- (CPString)UID
{
    var UID = CPStringUIDs.valueForKey(self);

    if (!UID)
    {
        UID = objj_generateObjectUID();
        CPStringUIDs.setValueForKey(self, UID);
    }

    return UID + "";
}

- (CPString)commonPrefixWithString:(CPString)aString
{
    return [self commonPrefixWithString: aString options: 0];
}

- (CPString)commonPrefixWithString:(CPString)aString options:(int)aMask
{
    var len = 0, // length of common prefix
        lhs = self,
        rhs = aString,
        min = MIN([lhs length], [rhs length]);

    if (aMask & CPCaseInsensitiveSearch)
    {
        lhs = [lhs lowercaseString];
        rhs = [rhs lowercaseString];
    }

    for (; len < min; len++)
    {
        if ([lhs characterAtIndex:len] !== [rhs characterAtIndex:len])
            break;
    }

    return [self substringToIndex:len];
}

- (CPString)capitalizedString
{
    var parts = self.split(/\b/g), // split on word boundaries
        i = 0,
        count = parts.length;

    for (; i < count; i++)
    {
        if (i == 0 || (/\s$/).test(parts[i - 1])) // only capitalize if previous token was whitespace
            parts[i] = parts[i].substring(0, 1).toUpperCase() + parts[i].substring(1).toLowerCase();
        else
            parts[i] = parts[i].toLowerCase();
    }
    return parts.join("");
}

- (CPString)lowercaseString
{
    return self.toLowerCase();
}

- (CPString)uppercaseString
{
    return self.toUpperCase();
}

- (CPString)stripDiacritics
{
    return self.stripDiacritics();
}

- (double)doubleValue
{
    return parseFloat(self, 10);
}
- (BOOL)boolValue
{
    var replaceRegExp = new RegExp("^\\s*[\\+,\\-]?0*");
    return RegExp("^[Y,y,t,T,1-9]").test(self.replace(replaceRegExp, ''));
}

- (float)floatValue
{
    return parseFloat(self, 10);
}

- (int)intValue
{
    return parseInt(self, 10);
}

- (int)integerValue
{
    return parseInt(self, 10);
}

- (CPArray)pathComponents
{
    if (self.length === 0)
        return [""];

    if (self === "/")
        return ["/"];

    var result = self.split('/');

    if (result[0] === "")
        result[0] = "/";

    var index = result.length - 1;

    if (index > 0)
    {
        if (result[index] === "")
            result[index] = "/";

        while (index--)
        {
            while (result[index] === "")
                result.splice(index--, 1);
        }
    }

    return result;
}

+ (CPString)pathWithComponents:(CPArray)components
{
    var size = components.length,
        result = "",
        i = -1,
        firstRound = true,
        firstIsSlash = false;

    while (++i < size)
    {
        var component = components[i],
            lenMinusOne = component.length - 1;

        if (lenMinusOne >= 0 && (component !== "/" || firstRound))  // Skip "" and "/" (not first time)
        {
            if (lenMinusOne > 0 && component.indexOf("/",lenMinusOne) === lenMinusOne) // Ends with "/"
                component = component.substring(0, lenMinusOne);

            if (firstRound)
            {
                if (component === "/")
                    firstIsSlash = true;
                firstRound = false;
            }
            else if (!firstIsSlash)
                result += "/";
            else
                firstIsSlash = false;

            result += component;
        }
    }
    return result;
}

- (CPString)pathExtension
{
    if (self.lastIndexOf('.') === CPNotFound)
        return "";

    return self.substr(self.lastIndexOf('.') + 1);
}

- (CPString)lastPathComponent
{
    var components = [self pathComponents],
        lastIndex = components.length - 1,
        lastComponent = components[lastIndex];

    return lastIndex > 0 && lastComponent === "/" ? components[lastIndex - 1] : lastComponent;
}

- (CPString)stringByAppendingPathComponent:(CPString)aString
{
    var components = [self pathComponents],
        addComponents = aString && aString !== "/" ? [aString pathComponents] : [];

    return [CPString pathWithComponents:components.concat(addComponents)];
}

- (CPString)stringByAppendingPathExtension:(CPString)ext
{
    if (ext.indexOf('/') >= 0 || self.length === 0 || self === "/")  // Can't handle these
        return self;

    var components = [self pathComponents],
        last = components.length - 1;

    if (last > 0 && components[last] === "/")
        components.splice(last--, 1);

    components[last] = components[last] + "." + ext;

    return [CPString pathWithComponents:components];
}

- (CPString)stringByDeletingLastPathComponent
{
    if (self.length === 0)
        return "";
    else if (self === "/")
        return "/";

    var components = [self pathComponents],
        last = components.length - 1;

    if (components[last] === "/")
        last--;

    components.splice(last, components.length - last);

    return [CPString pathWithComponents:components];
}

- (CPString)stringByDeletingPathExtension
{
    var extension = [self pathExtension];

    if (extension === "")
        return self;
    else if (self.lastIndexOf('.') < 1)
        return self;

    return self.substr(0, [self length] - (extension.length + 1));
}

- (CPString)stringByStandardizingPath
{
    // FIXME: Expand tildes etc. in CommonJS?
    return [[CPURL URLWithString:self] absoluteString];
}

@end


@implementation CPString (JSON)

+ (CPString)JSONFromObject:(JSObject)anObject
{
    return JSON.stringify(anObject);
}

- (JSObject)objectFromJSON
{
    return JSON.parse(self);
}

@end


@implementation CPString (UUID)

+ (CPString)UUID
{
    var g = @"",
        i = 0;

    for (; i < 32; i++)
        g += FLOOR(RAND() * 0xF).toString(0xF);

    return g;
}

@end

var diacritics = [[192,198],[200,203],[204,207],[210,214],[217,220],[224,230],
                 [231,231],[232,235],[236,239],[242,246],[249,252]], // Basic Latin ; Latin-1 Supplement.
    normalized = [65,69,73,79,85,97,99,101,105,111,117];

String.prototype.stripDiacritics = function()
{
    var output = "";

    for (var indexSource = 0; indexSource < this.length; indexSource++)
    {
        var code = this.charCodeAt(indexSource);

        for (var i = 0; i < diacritics.length; i++)
        {
            var drange = diacritics[i];

            if (code >= drange[0] && code <= drange[drange.length - 1])
            {
                code = normalized[i];
                break;
            }
        }

        output += String.fromCharCode(code);
    }

    return output;
};

String.prototype.isa = CPString;