CPUserDefaults.j

Go to the documentation of this file.

/*
 * CPUserDefaults.j
 * Foundation
 *
 * Created by Nicholas Small.
 * Copyright 2010, 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 CPApp

CPArgumentDomain        = @"CPArgumentDomain";
CPApplicationDomain     = [[[CPBundle mainBundle] infoDictionary] objectForKey:@"CPBundleIdentifier"] || @"CPApplicationDomain";
CPGlobalDomain          = @"CPGlobalDomain";
CPLocaleDomain          = @"CPLocaleDomain";
CPRegistrationDomain    = @"CPRegistrationDomain";

CPUserDefaultsDidChangeNotification = @"CPUserDefaultsDidChangeNotification";

var StandardUserDefaults;

@implementation CPUserDefaults : CPObject
{
    CPDictionary            _domains;
    CPDictionary            _stores;

    CPDictionary            _searchList;
    BOOL                    _searchListNeedsReload;
}

+ (id)standardUserDefaults
{
    if (!StandardUserDefaults)
        StandardUserDefaults = [[CPUserDefaults alloc] init];

    return StandardUserDefaults;
}

+ (void)resetStandardUserDefaults
{
    if (StandardUserDefaults)
        [StandardUserDefaults synchronize];

    StandardUserDefaults = nil;
}

/*
    @ignore
*/
- (id)init
{
    self = [super init];

    if (self)
    {
        _domains = @{};
        [self _setupArgumentsDomain];

        var defaultStore = [CPUserDefaultsLocalStore supportsLocalStorage] ? CPUserDefaultsLocalStore : CPUserDefaultsCookieStore;

        _stores = @{};
        [self setPersistentStoreClass:defaultStore forDomain:CPGlobalDomain reloadData:YES];
        [self setPersistentStoreClass:defaultStore forDomain:CPApplicationDomain reloadData:YES];
    }

    return self;
}

/*
    @ignore
*/
- (void)_setupArgumentsDomain
{
    var args = [CPApp namedArguments],
        keys = [args allKeys],
        count = [keys count],
        i = 0;

    for (; i < count; i++)
    {
        var key = keys[i];
        [self setObject:[args objectForKey:key] forKey:key inDomain:CPArgumentDomain];
    }
}

- (id)objectForKey:(CPString)aKey
{
    if (_searchListNeedsReload)
        [self _reloadSearchList];

    return [_searchList objectForKey:aKey];
}

- (void)setObject:(id)anObject forKey:(CPString)aKey
{
    [self setObject:anObject forKey:aKey inDomain:CPApplicationDomain];
}

- (id)objectForKey:(CPString)aKey inDomain:(CPString)aDomain
{
    var domain = [_domains objectForKey:aDomain];

    if (!domain)
        return nil;

    return [domain objectForKey:aKey];
}

- (void)setObject:(id)anObject forKey:(CPString)aKey inDomain:(CPString)aDomain
{
    if (!aKey || !aDomain)
        return;

    var domain = [_domains objectForKey:aDomain];
    if (!domain)
    {
        domain = @{};
        [_domains setObject:domain forKey:aDomain];
    }

    [domain setObject:anObject forKey:aKey];
    _searchListNeedsReload = YES;
    [self domainDidChange:aDomain];
}

- (void)removeObjectForKey:(CPString)aKey
{
    [self removeObjectForKey:aKey inDomain:CPApplicationDomain];
}

- (void)removeObjectForKey:(CPString)aKey inDomain:(CPString)aDomain
{
    if (!aKey || !aDomain)
        return;

    var domain = [_domains objectForKey:aDomain];
    if (!domain)
        return;

    [domain removeObjectForKey:aKey];
    _searchListNeedsReload = YES;
    [self domainDidChange:aDomain];
}

- (void)registerDefaults:(CPDictionary)aDictionary
{
    var keys = [aDictionary allKeys],
        count = [keys count],
        i = 0;

    for (; i < count; i++)
    {
        var key = keys[i];
        [self setObject:[aDictionary objectForKey:key] forKey:key inDomain:CPRegistrationDomain];
    }
}

- (void)registerDefaultsFromContentsOfFile:(CPURL)aURL
{
    var contents = [CPURLConnection sendSynchronousRequest:[CPURLRequest requestWithURL:aURL] returningResponse:nil],
        data = [CPData dataWithRawString:[contents rawString]],
        plist = [data plistObject];

    [self registerDefaults:plist];
}

/*
    @ignore
*/
- (void)_reloadSearchList
{
    _searchListNeedsReload = NO;

    var dicts = [CPRegistrationDomain, CPGlobalDomain, CPApplicationDomain, CPArgumentDomain],
        count = [dicts count],
        i = 0;

    _searchList = @{};

    for (; i < count; i++)
    {
        var domain = [_domains objectForKey:dicts[i]];
        if (!domain)
            continue;

        var keys = [domain allKeys],
            keysCount = [keys count],
            j = 0;

        for (; j < keysCount; j++)
        {
            var key = keys[j];
            [_searchList setObject:[domain objectForKey:key] forKey:key];
        }
    }
}

// Synchronization

- (CPArray)volatileDomainNames
{
    return [CPArgumentDomain, CPLocaleDomain, CPRegistrationDomain];
}

- (CPArray)persistentDomainNames
{
    return [CPGlobalDomain, CPApplicationDomain];
}

- (CPUserDefaultsStore)persistentStoreForDomain:(CPString)aDomain
{
    return [_stores objectForKey:aDomain];
}

- (CPUserDefaultsStore)setPersistentStoreClass:(Class)aStoreClass forDomain:(CPString)aDomain reloadData:(BOOL)aFlag
{
    var currentStore = [_stores objectForKey:aDomain];
    if (currentStore && [currentStore class] === aStoreClass)
        return currentStore;

    var store = [[aStoreClass alloc] init];
    [store setDomain:aDomain];
    [_stores setObject:store forKey:aDomain];

    if (aFlag)
        [self reloadDataFromStoreForDomain:aDomain];

    return store;
}

- (void)reloadDataFromStoreForDomain:(CPString)aDomain
{
    var data = [[self persistentStoreForDomain:aDomain] data],
        domain = data ? [CPKeyedUnarchiver unarchiveObjectWithData:data] : nil;

    if (domain === nil)
        [_domains removeObjectForKey:aDomain];
    else
        [_domains setObject:domain forKey:aDomain];

    _searchListNeedsReload = YES;
}

- (void)domainDidChange:(CPString)aDomain
{
    if (aDomain === CPGlobalDomain || aDomain === CPApplicationDomain)
        [[CPRunLoop currentRunLoop] performSelector:@selector(synchronize) target:self argument:nil order:0 modes:[CPDefaultRunLoopMode]];

    [[CPNotificationCenter defaultCenter] postNotificationName:CPUserDefaultsDidChangeNotification object:self];
}

- (void)synchronize
{
    var globalDomain = [_domains objectForKey:CPGlobalDomain];
    if (globalDomain)
    {
        var data = [CPKeyedArchiver archivedDataWithRootObject:globalDomain];
        [[self persistentStoreForDomain:CPGlobalDomain] setData:data];
    }

    var appDomain = [_domains objectForKey:CPApplicationDomain];
    if (appDomain)
    {
        var data = [CPKeyedArchiver archivedDataWithRootObject:appDomain];
        [[self persistentStoreForDomain:CPApplicationDomain] setData:data];
    }
}

#pragma mark Getting Default Values

- (CPArray)arrayForKey:(CPString)aKey
{
    var value = [self objectForKey:aKey];
    if ([value isKindOfClass:CPArray])
        return value;

    return nil;
}

- (BOOL)boolForKey:(CPString)aKey
{
    var value = [self objectForKey:aKey];
    if ([value respondsToSelector:@selector(boolValue)])
        return [value boolValue];

    return NO;
}


- (CPData)dataForKey:(CPString)aKey
{
    var value = [self objectForKey:aKey];
    if ([value isKindOfClass:CPData])
        return value;

    return nil;
}

- (CPDictionary)dictionaryForKey:(CPString)aKey
{
    var value = [self objectForKey:aKey];
    if ([value isKindOfClass:CPDictionary])
        return value;

    return nil;
}

- (float)floatForKey:(CPString)aKey
{
    var value = [self objectForKey:aKey];
    if (value === nil)
        return 0;

    if ([value respondsToSelector:@selector(floatValue)])
        value = [value floatValue];

    return parseFloat(value);
}

- (int)integerForKey:(CPString)aKey
{
    var value = [self objectForKey:aKey];
    if (value === nil)
        return 0;

    if ([value respondsToSelector:@selector(intValue)])
        value = [value intValue];

    return parseInt(value);
}

- (double)doubleForKey:(CPString)aKey
{
    return [self floatForKey:aKey];
}

- (CPString)stringForKey:(CPString)aKey
{
    var value = [self objectForKey:aKey];

    if ([value isKindOfClass:CPString])
        return value;

    else if ([value respondsToSelector:@selector(stringValue)])
        return [value stringValue];

    return nil;
}

- (CPArray)stringArrayForKey:(CPString)aKey
{
    var value = [self objectForKey:aKey];
    if (![value isKindOfClass:CPArray])
        return nil;

    for (var i = 0, count = [value count]; i < count; i++)
        if (![value[i] isKindOfClass:CPString])
            return nil;

    return value;
}

- (CPURL)URLForKey:(CPString)aKey
{
    var value = [self objectForKey:aKey];
    if ([value isKindOfClass:CPURL])
        return value;

    if ([value isKindOfClass:CPString])
        return [CPURL URLWithString:value];

    return nil;
}

#pragma mark Setting Default Values

- (void)setBool:(BOOL)aValue forKey:(CPString)aKey
{
    if ([aValue respondsToSelector:@selector(boolValue)])
        [self setObject:[aValue boolValue] forKey:aKey];
}

- (void)setFloat:(float)aValue forKey:(CPString)aKey
{
    if ([aValue respondsToSelector:@selector(floatValue)])
        aValue = [aValue floatValue];

    [self setObject:parseFloat(aValue) forKey:aKey];
}

- (void)setDouble:(double)aValue forKey:(CPString)aKey
{
    [self setFloat:aValue forKey:aKey];
}

- (void)setInteger:(int)aValue forKey:(CPString)aKey
{
    if ([aValue respondsToSelector:@selector(intValue)])
        aValue = [aValue intValue];

    [self setObject:parseInt(aValue) forKey:aKey];
}

- (void)setURL:(CPURL)aValue forKey:(CPString)aKey
{
    if ([aValue isKindOfClass:CPString])
        aValue = [CPURL URLWithString:aValue];

    [self setObject:aValue forKey:aKey];
}

@end

@implementation CPUserDefaultsStore : CPObject
{
    CPString    _domain;
}

- (CPData)data
{
    _CPRaiseInvalidAbstractInvocation(self, _cmd);
    return nil;
}

- (void)setData:(CPData)aData
{
    _CPRaiseInvalidAbstractInvocation(self, _cmd);
}

@end

@implementation CPUserDefaultsCookieStore : CPUserDefaultsStore
{
    CPCookie    _cookie;
}

- (void)setDomain:(CPString)aDomain
{
    if (_domain === aDomain)
        return;

    _domain = aDomain;

    _cookie = [[CPCookie alloc] initWithName:_domain];
}

- (CPData)data
{
    var result = [_cookie value];
    if (!result || [result length] < 1)
        return nil;

    return [CPData dataWithRawString:decodeURIComponent(result)];
}

- (void)setData:(CPData)aData
{
    [_cookie setValue:encodeURIComponent([aData rawString]) expires:[CPDate distantFuture] domain:window.location.href.hostname];
}

@end

var CPUserDefaultsLocalStoreTestKey = "9961800812587769-Cappuccino-Storage-Test";
@implementation CPUserDefaultsLocalStore : CPUserDefaultsStore
{
    id __doxygen__;
}

+ (BOOL)supportsLocalStorage
{
    if (!window.localStorage)
        return NO;

    try
    {
        // Just because localStorage exists does not mean it works. In particular it might be disabled
        // as it is when Safari's private browsing mode is active.
        localStorage.setItem(CPUserDefaultsLocalStoreTestKey, "1");
        if (localStorage.getItem(CPUserDefaultsLocalStoreTestKey) != "1")
            return NO;
        localStorage.removeItem(CPUserDefaultsLocalStoreTestKey);
    }
    catch (e)
    {
        return NO;
    }
    return YES;
}

- (id)init
{
    if (![[self class] supportsLocalStorage])
    {
        [CPException raise:@"UnsupportedFeature" reason:@"Browser does not support localStorage for CPUserDefaultsLocalStore"];
        return self = nil;
    }

    return self = [super init];
}

- (CPData)data
{
    var result = localStorage.getItem(_domain);
    if (!result || [result length] < 1)
        return nil;

    return [CPData dataWithRawString:decodeURIComponent(result)];
}

- (void)setData:(CPData)aData
{
    try
    {
        localStorage.setItem(_domain, encodeURIComponent([aData rawString]));
    }
    catch (e)
    {
        CPLog.warn("Unable to write to local storage: " + e);
    }
}

@end

@implementation CPUserDefaultsStore (CPSynthesizedAccessors)

- (CPString)domain
{
    return _domain;
}

- (void)setDomain:(CPString)aValue
{
    _domain = aValue;
}

@end