OOFileScannerVerifierStage(OOPrivate) Category Reference

Instance Methods
(void)	- scanForFiles
(void)	- checkRootFolders
(void)	- checkKnownFiles
(NSDictionary *)	- lowercaseMap:
(NSDictionary *)	- scanDirectory:
(void)	- checkPListFormat:file:folder:
(NSSet *)	- constructReadMeNames
(void)	- checkConfigFiles [implementation]

Detailed Description

Definition at line 62 of file OOFileScannerVerifierStage.m.

Method Documentation

checkConfigFiles

- (void) checkConfigFiles

implementation

Extends class OOFileScannerVerifierStage.

Definition at line 761 of file OOFileScannerVerifierStage.m.

{
    NSArray                 *knownNames = nil;
    NSEnumerator            *nameEnum = nil;
    NSString                *name = nil,
        *lcName = nil,
        *realFileName = nil;
    BOOL                    inConfigDir;
    
    knownNames = [[self verifier] configurationArrayForKey:@"knownConfigFiles"];
    for (nameEnum = [knownNames objectEnumerator]; (name = [nameEnum nextObject]); )
    {
        if (![name isKindOfClass:[NSString class]])  continue;
        
        /*  In theory, we could use -fileExists:inFolder:referencedFrom:checkBuiltIn:
        here, but we want a different error message.
        */
        
        lcName = [name lowercaseString];
        realFileName = [[_directoryListings oo_dictionaryForKey:@"config"] objectForKey:lcName];
        inConfigDir = realFileName != nil;
        if (!inConfigDir)  realFileName = [[_directoryListings oo_dictionaryForKey:@""] objectForKey:lcName];
        if (realFileName == nil)  continue;
        
        if (![realFileName isEqualToString:name])
        {
            if (inConfigDir)  realFileName = [@"Config" stringByAppendingPathComponent:realFileName];
            OOLog(@"verifyOXP.files.caseMismatch", @"***** ERROR: case mismatch: configuration file '%@' should be called '%@'.", realFileName, name);
        }
    }
}

References nil.

checkKnownFiles

- (void) checkKnownFiles

Extends class OOFileScannerVerifierStage.

Definition at line 761 of file OOFileScannerVerifierStage.m.

{
    NSDictionary            *directories = nil;
    NSEnumerator            *directoryEnum = nil;
    NSString                *directory = nil,
                            *lcDirectory = nil;
    NSArray                 *fileList = nil;
    NSEnumerator            *nameEnum = nil;
    NSString                *name = nil,
                            *lcName = nil,
                            *realFileName = nil;
    BOOL                    inDirectory;
    
    directories = [[self verifier] configurationDictionaryForKey:@"knownFiles"];
    for (directoryEnum = [directories keyEnumerator]; (directory = [directoryEnum nextObject]); )
    {
        fileList = [directories objectForKey:directory];
        lcDirectory = [directory lowercaseString];
        for (nameEnum = [fileList objectEnumerator]; (name = [nameEnum nextObject]); )
        {
            if (![name isKindOfClass:[NSString class]])  continue;
            
            /*  In theory, we could use -fileExists:inFolder:referencedFrom:checkBuiltIn:
                here, but we want a different error message.
            */
            
            lcName = [name lowercaseString];
            realFileName = [[_directoryListings oo_dictionaryForKey:lcDirectory] objectForKey:lcName];
            inDirectory = (realFileName != nil);
            if (!inDirectory)
            {
                // Allow for files in root directory of OXP
                realFileName = [[_directoryListings oo_dictionaryForKey:@""] objectForKey:lcName];
            }
            if (realFileName == nil)  continue;
            
            if (![realFileName isEqualToString:name])
            {
                if (inDirectory)  realFileName = [directory stringByAppendingPathComponent:realFileName];
                OOLog(@"verifyOXP.files.caseMismatch", @"***** ERROR: case mismatch: file '%@' should be called '%@'.", realFileName, name);
            }
        }
    }
}

checkPListFormat:file:folder:

- (void) checkPListFormat:		(NSPropertyListFormat)	format
file:		(NSString *)	file
folder:		(NSString *)	folder

Extends class OOFileScannerVerifierStage.

Definition at line 761 of file OOFileScannerVerifierStage.m.

                        :(NSPropertyListFormat)format file:(NSString *)file folder:(NSString *)folder
{
    NSString                *weirdnessKey = nil;
    NSString                *formatDesc = nil;
    NSString                *displayPath = nil;
    
    if (format != NSPropertyListOpenStepFormat && format != NSPropertyListXMLFormat_v1_0)
    {
        displayPath = [self displayNameForFile:file andFolder:folder];
        weirdnessKey = [displayPath lowercaseString];
        
        if (![_badPLists containsObject:weirdnessKey])
        {
            // Warn about "non-standard" format
            [_badPLists addObject:weirdnessKey];
            
            switch (format)
            {
                case NSPropertyListBinaryFormat_v1_0:
                    formatDesc = @"Apple binary format";
                    break;
                
#if OOLITE_GNUSTEP
                case NSPropertyListGNUstepFormat:
                    formatDesc = @"GNUstep text format";
                    break;
                
                case NSPropertyListGNUstepBinaryFormat:
                    formatDesc = @"GNUstep binary format";
                    break;
#endif
                
                default:
                    formatDesc = [NSString stringWithFormat:@"unknown format (%i)", (int)format];
            }
            
            OOLog(@"verifyOXP.plist.weirdFormat", @"----- WARNING: Property list %@ is in %@; OpenStep text format and XML format are the recommended formats for Oolite.", displayPath, formatDesc);
        }
    }
}

checkRootFolders

- (void) checkRootFolders

Extends class OOFileScannerVerifierStage.

Definition at line 761 of file OOFileScannerVerifierStage.m.

{
    NSArray                 *knownNames = nil;
    NSEnumerator            *nameEnum = nil;
    NSString                *name = nil;
    NSString                *lcName = nil;
    NSString                *actual = nil;
    
    knownNames = [[self verifier] configurationArrayForKey:@"knownRootDirectories"];
    for (nameEnum = [knownNames objectEnumerator]; (name = [nameEnum nextObject]); )
    {
        if (![name isKindOfClass:[NSString class]])  continue;
        
        lcName = [name lowercaseString];
        actual = [_directoryCases objectForKey:lcName];
        if (actual == nil)  continue;
        
        if (![actual isEqualToString:name])
        {
            OOLog(@"verifyOXP.files.caseMismatch", @"***** ERROR: case mismatch: directory '%@' should be called '%@'.", actual, name);
        }
        [_caseWarnings addObject:lcName];
    }
}

constructReadMeNames

- (NSSet *) constructReadMeNames

Extends class OOFileScannerVerifierStage.

Definition at line 761 of file OOFileScannerVerifierStage.m.

{
    NSDictionary            *dict = nil;
    NSArray                 *stems = nil,
                            *extensions = nil;
    NSMutableSet            *result = nil;
    NSUInteger              i, j, stemCount, extCount;
    NSString                *stem = nil,
                            *extension = nil;
    
    dict = [[self verifier] configurationDictionaryForKey:@"readMeNames"];
    stems = [dict oo_arrayForKey:@"stems"];
    extensions = [dict oo_arrayForKey:@"extensions"];
    stemCount = [stems count];
    extCount = [extensions count];
    if (stemCount * extCount == 0)  return nil;
    
    // Construct all stem+extension permutations
    result = [NSMutableSet setWithCapacity:stemCount * extCount];
    for (i = 0; i != stemCount; ++i)
    {
        stem = [[stems oo_stringAtIndex:i] lowercaseString];
        if (stem != nil)
        {
            for (j = 0; j != extCount; ++j)
            {
                extension = [[extensions oo_stringAtIndex:j] lowercaseString];
                if (extension != nil)
                {
                    [result addObject:[stem stringByAppendingString:extension]];
                }
            }
        }
    }
    
    return result;
}

lowercaseMap:

- (NSDictionary *) lowercaseMap:

(NSArray *)

array

Extends class OOFileScannerVerifierStage.

Definition at line 761 of file OOFileScannerVerifierStage.m.

                              :(NSArray *)array
{
    NSUInteger              i, count;
    NSString                *canonical = nil,
                            *lowercase = nil;
    NSMutableDictionary     *result = nil;
    
    count = [array count];
    if (count == 0)  return [NSDictionary dictionary];
    result = [NSMutableDictionary dictionaryWithCapacity:count];
    
    for (i = 0; i != count; ++i)
    {
        canonical = [array oo_stringAtIndex:i];
        if (canonical != nil)
        {
            lowercase = [canonical lowercaseString];
            [result setObject:canonical forKey:lowercase];
        }
    }
    
    return result;
}

scanDirectory:

- (NSDictionary *) scanDirectory:

(NSString *)

path

Extends class OOFileScannerVerifierStage.

Definition at line 761 of file OOFileScannerVerifierStage.m.

                               :(NSString *)path
{
    NSDirectoryEnumerator   *dirEnum = nil;
    NSMutableDictionary     *result = nil;
    NSString                *name = nil,
                            *lcName = nil,
                            *type = nil,
                            *dirName = nil,
                            *relativeName = nil,
                            *existing = nil;
    
    result = [NSMutableDictionary dictionary];
    dirName = [path lastPathComponent];
    
    dirEnum = [[NSFileManager defaultManager] enumeratorAtPath:path];
    while ((name = [dirEnum nextObject]))
    {
        type = [[dirEnum fileAttributes] fileType];
        relativeName = [dirName stringByAppendingPathComponent:name];
        
        if ([_junkFileNames containsObject:name])
        {
            OOLog(@"verifyOXP.scanFiles.skipJunk", @"NOTE: skipping junk file %@/%@.", dirName, name);
        }
        else if ([type isEqualToString:NSFileTypeRegular])
        {
            lcName = [name lowercaseString];
            existing = [result objectForKey:lcName];
            
            if (existing == nil)
            {
                OOLog(@"verifyOXP.verbose.listFiles", @"- %@", name);
                [result setObject:name forKey:lcName];
            }
            else
            {
                OOLog(@"verifyOXP.scanFiles.overloadedName", @"***** ERROR: %@ '%@' conflicts with %@ named '%@', ignoring. (OXPs must work on case-insensitive file systems!)", @"file", relativeName, @"file", [dirName stringByAppendingPathComponent:existing]);
            }
        }
        else
        {
            if ([type isEqualToString:NSFileTypeDirectory])
            {
                [dirEnum skipDescendents];
                if (![_skipDirectoryNames containsObject:name])
                {
                    OOLog(@"verifyOXP.scanFiles.directory", @"----- WARNING: \"%@\" is a nested directory, ignoring.", relativeName);
                }
                else
                {
                    OOLog(@"verifyOXP.verbose.listFiles", @"- Skipping %@/%@/", dirName, name);
                }
            }
            else if ([type isEqualToString:NSFileTypeSymbolicLink])
            {
                OOLog(@"verifyOXP.scanFiles.symLink", @"----- WARNING: \"%@\" is a symbolic link, ignoring.", relativeName);
            }
            else
            {
                OOLog(@"verifyOXP.scanFiles.nonStandardFile", @"----- WARNING: \"%@\" is a non-standard file (%@), ignoring.", relativeName, type);
            }
        }
    }
    
    return result;
}

scanForFiles

- (void) scanForFiles

Extends class OOFileScannerVerifierStage.

Definition at line 761 of file OOFileScannerVerifierStage.m.

{
    NSDirectoryEnumerator   *dirEnum = nil;
    NSString                *name = nil,
                            *path = nil,
                            *type = nil,
                            *lcName = nil,
                            *existing = nil,
                            *existingType = nil;
    NSMutableDictionary     *directoryListings = nil,
                            *directoryCases = nil,
                            *rootFiles = nil;
    NSDictionary            *dirFiles = nil;
    NSSet                   *readMeNames = nil;
    
    _basePath = [[[self verifier] oxpPath] copy];
    
    _junkFileNames = [[self verifier] configurationSetForKey:@"junkFiles"];
    _skipDirectoryNames = [[self verifier] configurationSetForKey:@"skipDirectories"];
    
    directoryCases = [NSMutableDictionary dictionary];
    directoryListings = [NSMutableDictionary dictionary];
    rootFiles = [NSMutableDictionary dictionary];
    readMeNames = [self constructReadMeNames];
    
    dirEnum = [[NSFileManager defaultManager] enumeratorAtPath:_basePath];
    while ((name = [dirEnum nextObject]))
    {
        path = [_basePath stringByAppendingPathComponent:name];
        type = [[dirEnum fileAttributes] fileType];
        lcName = [name lowercaseString];
        
        if ([type isEqualToString:NSFileTypeDirectory])
        {
            [dirEnum skipDescendents];
            
            if ([_skipDirectoryNames containsObject:name])
            {
                // Silently skip .svn and CVS
                OOLog(@"verifyOXP.verbose.listFiles", @"- Skipping %@/", name);
            }
            else if (!CheckNameConflict(lcName, directoryCases, rootFiles, &existing, &existingType))
            {
                OOLog(@"verifyOXP.verbose.listFiles", @"- %@/", name);
                OOLogIndentIf(@"verifyOXP.verbose.listFiles");
                dirFiles = [self scanDirectory:path];
                [directoryListings setObject:dirFiles forKey:lcName];
                [directoryCases setObject:name forKey:lcName];
                OOLogOutdentIf(@"verifyOXP.verbose.listFiles");
            }
            else
            {
                OOLog(@"verifyOXP.scanFiles.overloadedName", @"***** ERROR: %@ '%@' conflicts with %@ named '%@', ignoring. (OXPs must work on case-insensitive file systems!)", @"directory", name, existingType, existing);
            }
        }
        else if ([type isEqualToString:NSFileTypeRegular])
        {
            if ([_junkFileNames containsObject:name])
            {
                OOLog(@"verifyOXP.scanFiles.skipJunk", @"NOTE: skipping junk file %@.", name);
            }
            else if ([readMeNames containsObject:lcName])
            {
                OOLog(@"verifyOXP.scanFiles.readMe", @"----- WARNING: apparent Read Me file (\"%@\") inside OXP. This is the wrong place for a Read Me file, because it will not be read.", name);
            }
            else if (!CheckNameConflict(lcName, directoryCases, rootFiles, &existing, &existingType))
            {
                OOLog(@"verifyOXP.verbose.listFiles", @"- %@", name);
                [rootFiles setObject:name forKey:lcName];
            }
            else
            {
                OOLog(@"verifyOXP.scanFiles.overloadedName", @"***** ERROR: %@ '%@' conflicts with %@ named '%@', ignoring. (OXPs must work on case-insensitive file systems!)", @"file", name, existingType, existing);
            }
        }
        else if ([type isEqualToString:NSFileTypeSymbolicLink])
        {
            OOLog(@"verifyOXP.scanFiles.symLink", @"----- WARNING: \"%@\" is a symbolic link, ignoring.", name);
        }
        else
        {
            OOLog(@"verifyOXP.scanFiles.nonStandardFile", @"----- WARNING: \"%@\" is a non-standard file (%@), ignoring.", name, type);
        }
    }
    
    _junkFileNames = nil;
    _skipDirectoryNames = nil;
    
    [directoryListings setObject:rootFiles forKey:@""];
    _directoryListings = [directoryListings copy];
    _directoryCases = [directoryCases copy];
}

---

The documentation for this category was generated from the following file:

• src/Core/OXPVerifier/OOFileScannerVerifierStage.m