motion-yapper 0.0.3 → 0.1.0

data/vendor/Pods/CocoaLumberjack/Lumberjack/DDFileLogger.h

@@ -1,369 +0,0 @@
-#import <Foundation/Foundation.h>
-#import "DDLog.h"
-
-@class DDLogFileInfo;
-
-/**
- * Welcome to Cocoa Lumberjack!
- * 
- * The project page has a wealth of documentation if you have any questions.
- * https://github.com/CocoaLumberjack/CocoaLumberjack
- * 
- * If you're new to the project you may wish to read the "Getting Started" wiki.
- * https://github.com/CocoaLumberjack/CocoaLumberjack/wiki/GettingStarted
- * 
- * 
- * This class provides a logger to write log statements to a file.
-**/
-
-
-// Default configuration and safety/sanity values.
-// 
-// maximumFileSize         -> DEFAULT_LOG_MAX_FILE_SIZE
-// rollingFrequency        -> DEFAULT_LOG_ROLLING_FREQUENCY
-// maximumNumberOfLogFiles -> DEFAULT_LOG_MAX_NUM_LOG_FILES
-// 
-// You should carefully consider the proper configuration values for your application.
-
-#define DEFAULT_LOG_MAX_FILE_SIZE     (1024 * 1024)   //  1 MB
-#define DEFAULT_LOG_ROLLING_FREQUENCY (60 * 60 * 24)  // 24 Hours
-#define DEFAULT_LOG_MAX_NUM_LOG_FILES (5)             //  5 Files
-
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark -
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-// The LogFileManager protocol is designed to allow you to control all aspects of your log files.
-// 
-// The primary purpose of this is to allow you to do something with the log files after they have been rolled.
-// Perhaps you want to compress them to save disk space.
-// Perhaps you want to upload them to an FTP server.
-// Perhaps you want to run some analytics on the file.
-// 
-// A default LogFileManager is, of course, provided.
-// The default LogFileManager simply deletes old log files according to the maximumNumberOfLogFiles property.
-// 
-// This protocol provides various methods to fetch the list of log files.
-// 
-// There are two variants: sorted and unsorted.
-// If sorting is not necessary, the unsorted variant is obviously faster.
-// The sorted variant will return an array sorted by when the log files were created,
-// with the most recently created log file at index 0, and the oldest log file at the end of the array.
-// 
-// You can fetch only the log file paths (full path including name), log file names (name only),
-// or an array of DDLogFileInfo objects.
-// The DDLogFileInfo class is documented below, and provides a handy wrapper that
-// gives you easy access to various file attributes such as the creation date or the file size.
-
-@protocol DDLogFileManager <NSObject>
-@required
-
-// Public properties
-
-/**
- * The maximum number of archived log files to keep on disk.
- * For example, if this property is set to 3,
- * then the LogFileManager will only keep 3 archived log files (plus the current active log file) on disk.
- * Once the active log file is rolled/archived, then the oldest of the existing 3 rolled/archived log files is deleted.
- * 
- * You may optionally disable deleting old/rolled/archived log files by setting this property to zero.
-**/
-@property (readwrite, assign) NSUInteger maximumNumberOfLogFiles;
-
-// Public methods
-
-- (NSString *)logsDirectory;
-
-- (NSArray *)unsortedLogFilePaths;
-- (NSArray *)unsortedLogFileNames;
-- (NSArray *)unsortedLogFileInfos;
-
-- (NSArray *)sortedLogFilePaths;
-- (NSArray *)sortedLogFileNames;
-- (NSArray *)sortedLogFileInfos;
-
-// Private methods (only to be used by DDFileLogger)
-
-- (NSString *)createNewLogFile;
-
-@optional
-
-// Notifications from DDFileLogger
-
-- (void)didArchiveLogFile:(NSString *)logFilePath;
-- (void)didRollAndArchiveLogFile:(NSString *)logFilePath;
-
-@end
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark -
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/**
- * Default log file manager.
- * 
- * All log files are placed inside the logsDirectory.
- * If a specific logsDirectory isn't specified, the default directory is used.
- * On Mac, this is in ~/Library/Logs/<Application Name>.
- * On iPhone, this is in ~/Library/Caches/Logs.
- * 
- * Log files are named "<bundle identifier> <date> <time>.log"
- * Example: com.organization.myapp 2013-12-03 17-14.log
- * 
- * Archived log files are automatically deleted according to the maximumNumberOfLogFiles property.
-**/
-@interface DDLogFileManagerDefault : NSObject <DDLogFileManager>
-{
-    NSUInteger maximumNumberOfLogFiles;
-    NSString *_logsDirectory;
-}
-
-- (id)init;
-- (instancetype)initWithLogsDirectory:(NSString *)logsDirectory;
-
-/*
- * Methods to override.
- *
- * Log files are named "<bundle identifier> <date> <time>.log"
- * Example: com.organization.myapp 2013-12-03 17-14.log
- *
- * If you wish to change default filename, you can override following two methods.
- * - newLogFileName method would be called on new logfile creation.
- * - isLogFile: method would be called to filter logfiles from all other files in logsDirectory.
- *   You have to parse given filename and return YES if it is logFile.
- *
- * **NOTE**
- * newLogFileName returns filename. If appropriate file already exists, number would be added
- * to filename before extension. You have to handle this case in isLogFile: method.
- *
- * Example:
- * - newLogFileName returns "com.organization.myapp 2013-12-03.log",
- *   file "com.organization.myapp 2013-12-03.log" would be created.
- * - after some time "com.organization.myapp 2013-12-03.log" is archived
- * - newLogFileName again returns "com.organization.myapp 2013-12-03.log",
- *   file "com.organization.myapp 2013-12-03 2.log" would be created.
- * - after some time "com.organization.myapp 2013-12-03 1.log" is archived
- * - newLogFileName again returns "com.organization.myapp 2013-12-03.log",
- *   file "com.organization.myapp 2013-12-03 3.log" would be created.
-**/
-- (NSString *)newLogFileName;
-- (BOOL)isLogFile:(NSString *)fileName;
-
-/* Inherited from DDLogFileManager protocol:
-
-@property (readwrite, assign) NSUInteger maximumNumberOfLogFiles;
-
-- (NSString *)logsDirectory;
-
-- (NSArray *)unsortedLogFilePaths;
-- (NSArray *)unsortedLogFileNames;
-- (NSArray *)unsortedLogFileInfos;
-
-- (NSArray *)sortedLogFilePaths;
-- (NSArray *)sortedLogFileNames;
-- (NSArray *)sortedLogFileInfos;
-
-*/
-
-@end
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark -
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/**
- * Most users will want file log messages to be prepended with the date and time.
- * Rather than forcing the majority of users to write their own formatter,
- * we will supply a logical default formatter.
- * Users can easily replace this formatter with their own by invoking the setLogFormatter method.
- * It can also be removed by calling setLogFormatter, and passing a nil parameter.
- * 
- * In addition to the convenience of having a logical default formatter,
- * it will also provide a template that makes it easy for developers to copy and change.
-**/
-@interface DDLogFileFormatterDefault : NSObject <DDLogFormatter>
-{
-    NSDateFormatter *dateFormatter;
-}
-
-- (id)init;
-- (instancetype)initWithDateFormatter:(NSDateFormatter *)dateFormatter;
-
-@end
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark -
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-@interface DDFileLogger : DDAbstractLogger <DDLogger>
-{
-    __strong id <DDLogFileManager> logFileManager;
-    
-    DDLogFileInfo *currentLogFileInfo;
-    NSFileHandle *currentLogFileHandle;
-    
-    dispatch_source_t currentLogFileVnode;
-    dispatch_source_t rollingTimer;
-    
-    unsigned long long maximumFileSize;
-    NSTimeInterval rollingFrequency;
-}
-
-- (id)init;
-- (instancetype)initWithLogFileManager:(id <DDLogFileManager>)logFileManager;
-
-/**
- * Log File Rolling:
- * 
- * maximumFileSize:
- *   The approximate maximum size to allow log files to grow.
- *   If a log file is larger than this value after a log statement is appended,
- *   then the log file is rolled.
- * 
- * rollingFrequency
- *   How often to roll the log file.
- *   The frequency is given as an NSTimeInterval, which is a double that specifies the interval in seconds.
- *   Once the log file gets to be this old, it is rolled.
- * 
- * Both the maximumFileSize and the rollingFrequency are used to manage rolling.
- * Whichever occurs first will cause the log file to be rolled.
- * 
- * For example:
- * The rollingFrequency is 24 hours,
- * but the log file surpasses the maximumFileSize after only 20 hours.
- * The log file will be rolled at that 20 hour mark.
- * A new log file will be created, and the 24 hour timer will be restarted.
- * 
- * You may optionally disable rolling due to filesize by setting maximumFileSize to zero.
- * If you do so, rolling is based solely on rollingFrequency.
- * 
- * You may optionally disable rolling due to time by setting rollingFrequency to zero (or any non-positive number).
- * If you do so, rolling is based solely on maximumFileSize.
- * 
- * If you disable both maximumFileSize and rollingFrequency, then the log file won't ever be rolled.
- * This is strongly discouraged.
-**/
-@property (readwrite, assign) unsigned long long maximumFileSize;
-@property (readwrite, assign) NSTimeInterval rollingFrequency;
-
-/**
- * The DDLogFileManager instance can be used to retrieve the list of log files,
- * and configure the maximum number of archived log files to keep.
- * 
- * @see DDLogFileManager.maximumNumberOfLogFiles
-**/
-@property (strong, nonatomic, readonly) id <DDLogFileManager> logFileManager;
-
-
-// You can optionally force the current log file to be rolled with this method.
-// CompletionBlock will be called on main queue.
-
-- (void)rollLogFileWithCompletionBlock:(void (^)())completionBlock;
-
-// Method is deprecated. Use rollLogFileWithCompletionBlock: method instead.
-
-- (void)rollLogFile __attribute((deprecated));
-
-// Inherited from DDAbstractLogger
-
-// - (id <DDLogFormatter>)logFormatter;
-// - (void)setLogFormatter:(id <DDLogFormatter>)formatter;
-
-@end
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark -
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/**
- * DDLogFileInfo is a simple class that provides access to various file attributes.
- * It provides good performance as it only fetches the information if requested,
- * and it caches the information to prevent duplicate fetches.
- * 
- * It was designed to provide quick snapshots of the current state of log files,
- * and to help sort log files in an array.
- * 
- * This class does not monitor the files, or update it's cached attribute values if the file changes on disk.
- * This is not what the class was designed for.
- * 
- * If you absolutely must get updated values,
- * you can invoke the reset method which will clear the cache.
-**/
-@interface DDLogFileInfo : NSObject
-{
-    __strong NSString *filePath;
-    __strong NSString *fileName;
-    
-    __strong NSDictionary *fileAttributes;
-    
-    __strong NSDate *creationDate;
-    __strong NSDate *modificationDate;
-    
-    unsigned long long fileSize;
-}
-
-@property (strong, nonatomic, readonly) NSString *filePath;
-@property (strong, nonatomic, readonly) NSString *fileName;
-
-@property (strong, nonatomic, readonly) NSDictionary *fileAttributes;
-
-@property (strong, nonatomic, readonly) NSDate *creationDate;
-@property (strong, nonatomic, readonly) NSDate *modificationDate;
-
-@property (nonatomic, readonly) unsigned long long fileSize;
-
-@property (nonatomic, readonly) NSTimeInterval age;
-
-@property (nonatomic, readwrite) BOOL isArchived;
-
-+ (instancetype)logFileWithPath:(NSString *)filePath;
-
-- (instancetype)initWithFilePath:(NSString *)filePath;
-
-- (void)reset;
-- (void)renameFile:(NSString *)newFileName;
-
-#if TARGET_IPHONE_SIMULATOR
-
-// So here's the situation.
-// Extended attributes are perfect for what we're trying to do here (marking files as archived).
-// This is exactly what extended attributes were designed for.
-// 
-// But Apple screws us over on the simulator.
-// Everytime you build-and-go, they copy the application into a new folder on the hard drive,
-// and as part of the process they strip extended attributes from our log files.
-// Normally, a copy of a file preserves extended attributes.
-// So obviously Apple has gone to great lengths to piss us off.
-// 
-// Thus we use a slightly different tactic for marking log files as archived in the simulator.
-// That way it "just works" and there's no confusion when testing.
-// 
-// The difference in method names is indicative of the difference in functionality.
-// On the simulator we add an attribute by appending a filename extension.
-// 
-// For example:
-// "mylog.txt" -> "mylog.archived.txt"
-// "mylog"     -> "mylog.archived"
-
-- (BOOL)hasExtensionAttributeWithName:(NSString *)attrName;
-
-- (void)addExtensionAttributeWithName:(NSString *)attrName;
-- (void)removeExtensionAttributeWithName:(NSString *)attrName;
-
-#else
-
-// Normal use of extended attributes used everywhere else,
-// such as on Macs and on iPhone devices.
-
-- (BOOL)hasExtendedAttributeWithName:(NSString *)attrName;
-
-- (void)addExtendedAttributeWithName:(NSString *)attrName;
-- (void)removeExtendedAttributeWithName:(NSString *)attrName;
-
-#endif
-
-- (NSComparisonResult)reverseCompareByCreationDate:(DDLogFileInfo *)another;
-- (NSComparisonResult)reverseCompareByModificationDate:(DDLogFileInfo *)another;
-
-@end

data/vendor/Pods/CocoaLumberjack/Lumberjack/DDFileLogger.m

@@ -1,1539 +0,0 @@
-#import "DDFileLogger.h"
-
-#import <unistd.h>
-#import <sys/attr.h>
-#import <sys/xattr.h>
-#import <libkern/OSAtomic.h>
-
-/**
- * Welcome to Cocoa Lumberjack!
- * 
- * The project page has a wealth of documentation if you have any questions.
- * https://github.com/CocoaLumberjack/CocoaLumberjack
- * 
- * If you're new to the project you may wish to read the "Getting Started" wiki.
- * https://github.com/CocoaLumberjack/CocoaLumberjack/wiki/GettingStarted
-**/
-
-#if ! __has_feature(objc_arc)
-#warning This file must be compiled with ARC. Use -fobjc-arc flag (or convert project to ARC).
-#endif
-
-// We probably shouldn't be using DDLog() statements within the DDLog implementation.
-// But we still want to leave our log statements for any future debugging,
-// and to allow other developers to trace the implementation (which is a great learning tool).
-// 
-// So we use primitive logging macros around NSLog.
-// We maintain the NS prefix on the macros to be explicit about the fact that we're using NSLog.
-
-#define LOG_LEVEL 2
-
-#define NSLogError(frmt, ...)    do{ if(LOG_LEVEL >= 1) NSLog((frmt), ##__VA_ARGS__); } while(0)
-#define NSLogWarn(frmt, ...)     do{ if(LOG_LEVEL >= 2) NSLog((frmt), ##__VA_ARGS__); } while(0)
-#define NSLogInfo(frmt, ...)     do{ if(LOG_LEVEL >= 3) NSLog((frmt), ##__VA_ARGS__); } while(0)
-#define NSLogDebug(frmt, ...)    do{ if(LOG_LEVEL >= 4) NSLog((frmt), ##__VA_ARGS__); } while(0)
-#define NSLogVerbose(frmt, ...)  do{ if(LOG_LEVEL >= 5) NSLog((frmt), ##__VA_ARGS__); } while(0)
-
-@interface DDLogFileManagerDefault (PrivateAPI)
-
-- (void)deleteOldLogFiles;
-- (NSString *)defaultLogsDirectory;
-
-@end
-
-@interface DDFileLogger (PrivateAPI)
-
-- (void)rollLogFileNow;
-- (void)maybeRollLogFileDueToAge;
-- (void)maybeRollLogFileDueToSize;
-
-@end
-
-#if TARGET_OS_IPHONE
-BOOL doesAppRunInBackground(void);
-#endif
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark -
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-@implementation DDLogFileManagerDefault
-
-@synthesize maximumNumberOfLogFiles;
-
-- (id)init
-{
-    return [self initWithLogsDirectory:nil];
-}
-
-- (instancetype)initWithLogsDirectory:(NSString *)aLogsDirectory
-{
-    if ((self = [super init]))
-    {
-        maximumNumberOfLogFiles = DEFAULT_LOG_MAX_NUM_LOG_FILES;
-        
-        if (aLogsDirectory)
-            _logsDirectory = [aLogsDirectory copy];
-        else
-            _logsDirectory = [[self defaultLogsDirectory] copy];
-        
-        NSKeyValueObservingOptions kvoOptions = NSKeyValueObservingOptionOld | NSKeyValueObservingOptionNew;
-        
-        [self addObserver:self forKeyPath:NSStringFromSelector(@selector(maximumNumberOfLogFiles)) options:kvoOptions context:nil];
-        
-        NSLogVerbose(@"DDFileLogManagerDefault: logsDirectory:\n%@", [self logsDirectory]);
-        NSLogVerbose(@"DDFileLogManagerDefault: sortedLogFileNames:\n%@", [self sortedLogFileNames]);
-    }
-    return self;
-}
-
-- (void)dealloc
-{
-    // try-catch because the observer might be removed or never added. In this case, removeObserver throws and exception
-    @try {
-        [self removeObserver:self forKeyPath:NSStringFromSelector(@selector(maximumNumberOfLogFiles))];
-    }
-    @catch (NSException *exception) {
-        
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark Configuration
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-- (void)observeValueForKeyPath:(NSString *)keyPath
-                      ofObject:(id)object
-                        change:(NSDictionary *)change
-                       context:(void *)context
-{
-    NSNumber *old = [change objectForKey:NSKeyValueChangeOldKey];
-    NSNumber *new = [change objectForKey:NSKeyValueChangeNewKey];
-    
-    if ([old isEqual:new])
-    {
-        // No change in value - don't bother with any processing.
-        return;
-    }
-    
-    if ([keyPath isEqualToString:NSStringFromSelector(@selector(maximumNumberOfLogFiles))])
-    {
-        NSLogInfo(@"DDFileLogManagerDefault: Responding to configuration change: maximumNumberOfLogFiles");
-        
-        dispatch_async([DDLog loggingQueue], ^{ @autoreleasepool {
-            
-            [self deleteOldLogFiles];
-        }});
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark File Deleting
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/**
- * Deletes archived log files that exceed the maximumNumberOfLogFiles configuration value.
-**/
-- (void)deleteOldLogFiles
-{
-    NSLogVerbose(@"DDLogFileManagerDefault: deleteOldLogFiles");
-    
-    NSUInteger maxNumLogFiles = self.maximumNumberOfLogFiles;
-    if (maxNumLogFiles == 0)
-    {
-        // Unlimited - don't delete any log files
-        return;
-    }
-    
-    NSArray *sortedLogFileInfos = [self sortedLogFileInfos];
-    
-    // Do we consider the first file?
-    // We are only supposed to be deleting archived files.
-    // In most cases, the first file is likely the log file that is currently being written to.
-    // So in most cases, we do not want to consider this file for deletion.
-    
-    NSUInteger count = [sortedLogFileInfos count];
-    BOOL excludeFirstFile = NO;
-    
-    if (count > 0)
-    {
-        DDLogFileInfo *logFileInfo = [sortedLogFileInfos objectAtIndex:0];
-        
-        if (!logFileInfo.isArchived)
-        {
-            excludeFirstFile = YES;
-        }
-    }
-    
-    NSArray *sortedArchivedLogFileInfos;
-    if (excludeFirstFile)
-    {
-        count--;
-        sortedArchivedLogFileInfos = [sortedLogFileInfos subarrayWithRange:NSMakeRange(1, count)];
-    }
-    else
-    {
-        sortedArchivedLogFileInfos = sortedLogFileInfos;
-    }
-    
-    NSUInteger i;
-    for (i = maxNumLogFiles; i < count; i++)
-    {
-        DDLogFileInfo *logFileInfo = [sortedArchivedLogFileInfos objectAtIndex:i];
-        
-        NSLogInfo(@"DDLogFileManagerDefault: Deleting file: %@", logFileInfo.fileName);
-        
-        [[NSFileManager defaultManager] removeItemAtPath:logFileInfo.filePath error:nil];
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark Log Files
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/**
- * Returns the path to the default logs directory.
- * If the logs directory doesn't exist, this method automatically creates it.
-**/
-- (NSString *)defaultLogsDirectory
-{
-#if TARGET_OS_IPHONE
-    NSArray *paths = NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES);
-    NSString *baseDir = ([paths count] > 0) ? [paths objectAtIndex:0] : nil;
-    NSString *logsDirectory = [baseDir stringByAppendingPathComponent:@"Logs"];
-    
-#else
-    NSString *appName = [[NSProcessInfo processInfo] processName];
-    NSArray *paths = NSSearchPathForDirectoriesInDomains(NSLibraryDirectory, NSUserDomainMask, YES);
-    NSString *basePath = ([paths count] > 0) ? [paths objectAtIndex:0] : NSTemporaryDirectory();
-    NSString *logsDirectory = [[basePath stringByAppendingPathComponent:@"Logs"] stringByAppendingPathComponent:appName];
-
-#endif
-
-    return logsDirectory;
-}
-
-- (NSString *)logsDirectory
-{
-    // We could do this check once, during initalization, and not bother again.
-    // But this way the code continues to work if the directory gets deleted while the code is running.
-    
-    if (![[NSFileManager defaultManager] fileExistsAtPath:_logsDirectory])
-    {
-        NSError *err = nil;
-        if (![[NSFileManager defaultManager] createDirectoryAtPath:_logsDirectory
-                                       withIntermediateDirectories:YES attributes:nil error:&err])
-        {
-            NSLogError(@"DDFileLogManagerDefault: Error creating logsDirectory: %@", err);
-        }
-    }
-    
-    return _logsDirectory;
-}
-
-/**
- * Default log file name is "<bundle identifier> <date> <time>.log".
- * Example: MobileSafari 2013-12-03 17-14.log
- *
- * You can change it by overriding newLogFileName and isLogFile: methods.
-**/
-- (BOOL)isLogFile:(NSString *)fileName
-{
-    NSString *appName = [self applicationName];
-
-    BOOL hasProperPrefix = [fileName hasPrefix:appName];
-    BOOL hasProperSuffix = [fileName hasSuffix:@".log"];
-    BOOL hasProperDate = NO;
-
-    if (hasProperPrefix && hasProperSuffix)
-    {
-        NSUInteger lengthOfMiddle = fileName.length - appName.length - @".log".length;
-
-        // Date string should have at least 16 characters - " 2013-12-03 17-14"
-        if (lengthOfMiddle >= 17)
-        {
-            NSRange range = NSMakeRange(appName.length, lengthOfMiddle);
-
-            NSString *middle = [fileName substringWithRange:range];
-            NSArray *components = [middle componentsSeparatedByString:@" "];
-
-            // When creating logfile if there is existing file with the same name, we append attemp number at the end.
-            // Thats why here we can have three or four components. For details see createNewLogFile method.
-            //
-            // Components:
-            //     "", "2013-12-03", "17-14"
-            // or
-            //     "", "2013-12-03", "17-14", "1"
-            if (components.count == 3 || components.count == 4)
-            {
-                NSString *dateString = [NSString stringWithFormat:@"%@ %@", components[1], components[2]];
-                NSDateFormatter *dateFormatter = [self logFileDateFormatter];
-
-                NSDate *date = [dateFormatter dateFromString:dateString];
-
-                if (date)
-                {
-                    hasProperDate = YES;
-                }
-            }
-        }
-    }
-
-    return (hasProperPrefix && hasProperDate && hasProperSuffix);
-}
-
-- (NSDateFormatter *)logFileDateFormatter
-{
-    NSDateFormatter *dateFormatter = [[NSDateFormatter alloc] init];
-    [dateFormatter setDateFormat:@"yyyy'-'MM'-'dd' 'HH'-'mm'"];
-    [dateFormatter setTimeZone:[NSTimeZone timeZoneForSecondsFromGMT:0]];
-
-    return dateFormatter;
-}
-
-/**
- * Returns an array of NSString objects,
- * each of which is the filePath to an existing log file on disk.
-**/
-- (NSArray *)unsortedLogFilePaths
-{
-    NSString *logsDirectory = [self logsDirectory];
-    NSArray *fileNames = [[NSFileManager defaultManager] contentsOfDirectoryAtPath:logsDirectory error:nil];
-    
-    NSMutableArray *unsortedLogFilePaths = [NSMutableArray arrayWithCapacity:[fileNames count]];
-    
-    for (NSString *fileName in fileNames)
-    {
-        // Filter out any files that aren't log files. (Just for extra safety)
-        
-    #if TARGET_IPHONE_SIMULATOR
-        // In case of iPhone simulator there can be 'archived' extension. isLogFile:
-        // method knows nothing about it. Thus removing it for this method.
-        //
-        // See full explanation in the header file.
-        NSString *theFileName = [fileName stringByReplacingOccurrencesOfString:@".archived"
-                                                                    withString:@""];
-
-        if ([self isLogFile:theFileName])
-    #else
-        if ([self isLogFile:fileName])
-    #endif
-        {
-            NSString *filePath = [logsDirectory stringByAppendingPathComponent:fileName];
-            
-            [unsortedLogFilePaths addObject:filePath];
-        }
-    }
-    
-    return unsortedLogFilePaths;
-}
-
-/**
- * Returns an array of NSString objects,
- * each of which is the fileName of an existing log file on disk.
-**/
-- (NSArray *)unsortedLogFileNames
-{
-    NSArray *unsortedLogFilePaths = [self unsortedLogFilePaths];
-    
-    NSMutableArray *unsortedLogFileNames = [NSMutableArray arrayWithCapacity:[unsortedLogFilePaths count]];
-    
-    for (NSString *filePath in unsortedLogFilePaths)
-    {
-        [unsortedLogFileNames addObject:[filePath lastPathComponent]];
-    }
-    
-    return unsortedLogFileNames;
-}
-
-/**
- * Returns an array of DDLogFileInfo objects,
- * each representing an existing log file on disk,
- * and containing important information about the log file such as it's modification date and size.
-**/
-- (NSArray *)unsortedLogFileInfos
-{
-    NSArray *unsortedLogFilePaths = [self unsortedLogFilePaths];
-    
-    NSMutableArray *unsortedLogFileInfos = [NSMutableArray arrayWithCapacity:[unsortedLogFilePaths count]];
-    
-    for (NSString *filePath in unsortedLogFilePaths)
-    {
-        DDLogFileInfo *logFileInfo = [[DDLogFileInfo alloc] initWithFilePath:filePath];
-        
-        [unsortedLogFileInfos addObject:logFileInfo];
-    }
-    
-    return unsortedLogFileInfos;
-}
-
-/**
- * Just like the unsortedLogFilePaths method, but sorts the array.
- * The items in the array are sorted by creation date.
- * The first item in the array will be the most recently created log file.
-**/
-- (NSArray *)sortedLogFilePaths
-{
-    NSArray *sortedLogFileInfos = [self sortedLogFileInfos];
-    
-    NSMutableArray *sortedLogFilePaths = [NSMutableArray arrayWithCapacity:[sortedLogFileInfos count]];
-    
-    for (DDLogFileInfo *logFileInfo in sortedLogFileInfos)
-    {
-        [sortedLogFilePaths addObject:[logFileInfo filePath]];
-    }
-    
-    return sortedLogFilePaths;
-}
-
-/**
- * Just like the unsortedLogFileNames method, but sorts the array.
- * The items in the array are sorted by creation date.
- * The first item in the array will be the most recently created log file.
-**/
-- (NSArray *)sortedLogFileNames
-{
-    NSArray *sortedLogFileInfos = [self sortedLogFileInfos];
-    
-    NSMutableArray *sortedLogFileNames = [NSMutableArray arrayWithCapacity:[sortedLogFileInfos count]];
-    
-    for (DDLogFileInfo *logFileInfo in sortedLogFileInfos)
-    {
-        [sortedLogFileNames addObject:[logFileInfo fileName]];
-    }
-    
-    return sortedLogFileNames;
-}
-
-/**
- * Just like the unsortedLogFileInfos method, but sorts the array.
- * The items in the array are sorted by creation date.
- * The first item in the array will be the most recently created log file.
-**/
-- (NSArray *)sortedLogFileInfos
-{
-    return [[self unsortedLogFileInfos] sortedArrayUsingSelector:@selector(reverseCompareByCreationDate:)];
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark Creation
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/**
- * Generates log file name with default format "<bundle identifier> <date> <time>.log"
- * Example: MobileSafari 2013-12-03 17-14.log
- *
- * You can change it by overriding newLogFileName and isLogFile: methods.
-**/
-- (NSString *)newLogFileName
-{
-    NSString *appName = [self applicationName];
-
-    NSDateFormatter *dateFormatter = [self logFileDateFormatter];
-    NSString *formattedDate = [dateFormatter stringFromDate:[NSDate date]];
-
-    return [NSString stringWithFormat:@"%@ %@.log", appName, formattedDate];
-}
-
-/**
- * Generates a new unique log file path, and creates the corresponding log file.
-**/
-- (NSString *)createNewLogFile
-{
-    NSString *fileName = [self newLogFileName];
-    NSString *logsDirectory = [self logsDirectory];
-
-    NSUInteger attempt = 1;
-    do
-    {
-        NSString *actualFileName = fileName;
-
-        if (attempt > 1) {
-            NSString *extension = [actualFileName pathExtension];
-
-            actualFileName = [actualFileName stringByDeletingPathExtension];
-            actualFileName = [actualFileName stringByAppendingFormat:@" %lu", (unsigned long)attempt];
-            if (extension.length) {
-                actualFileName = [actualFileName stringByAppendingPathExtension:extension];
-            }
-        }
-
-        NSString *filePath = [logsDirectory stringByAppendingPathComponent:actualFileName];
-
-        if (![[NSFileManager defaultManager] fileExistsAtPath:filePath])
-        {
-            NSLogVerbose(@"DDLogFileManagerDefault: Creating new log file: %@", actualFileName);
-
-            NSDictionary *attributes = nil;
-
-        #if TARGET_OS_IPHONE
-             // When creating log file on iOS we're setting NSFileProtectionKey attribute to NSFileProtectionCompleteUnlessOpen.
-             // 
-             // But in case if app is able to launch from background we need to have an ability to open log file any time we
-             // want (even if device is locked). Thats why that attribute have to be changed to
-             // NSFileProtectionCompleteUntilFirstUserAuthentication.
-
-            NSString *key = doesAppRunInBackground() ?
-                NSFileProtectionCompleteUntilFirstUserAuthentication : NSFileProtectionCompleteUnlessOpen;
-
-            attributes = @{ NSFileProtectionKey : key };
-        #endif
-            
-            [[NSFileManager defaultManager] createFileAtPath:filePath contents:nil attributes:attributes];
-            
-            // Since we just created a new log file, we may need to delete some old log files
-            [self deleteOldLogFiles];
-            
-            return filePath;
-        } else {
-            attempt++;
-        }
-        
-    } while(YES);
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark Utility
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-- (NSString *)applicationName
-{
-    static NSString *_appName;
-    static dispatch_once_t onceToken;
-
-    dispatch_once(&onceToken, ^{
-        _appName = [[NSBundle mainBundle] objectForInfoDictionaryKey:@"CFBundleIdentifier"];
-
-        if (! _appName)
-        {
-            _appName = [[NSProcessInfo processInfo] processName];
-        }
-
-        if (! _appName)
-        {
-            _appName = @"";
-        }
-    });
-
-    return _appName;
-}
-
-@end
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark -
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-@implementation DDLogFileFormatterDefault
-
-- (id)init
-{
-    return [self initWithDateFormatter:nil];
-}
-
-- (instancetype)initWithDateFormatter:(NSDateFormatter *)aDateFormatter
-{
-    if ((self = [super init]))
-    {
-        if (aDateFormatter)
-        {
-            dateFormatter = aDateFormatter;
-        }
-        else
-        {
-            dateFormatter = [[NSDateFormatter alloc] init];
-            [dateFormatter setFormatterBehavior:NSDateFormatterBehavior10_4]; // 10.4+ style
-            [dateFormatter setDateFormat:@"yyyy/MM/dd HH:mm:ss:SSS"];
-        }
-    }
-    return self;
-}
-
-- (NSString *)formatLogMessage:(DDLogMessage *)logMessage
-{
-    NSString *dateAndTime = [dateFormatter stringFromDate:(logMessage->timestamp)];
-    
-    return [NSString stringWithFormat:@"%@  %@", dateAndTime, logMessage->logMsg];
-}
-
-@end
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark -
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-@implementation DDFileLogger
-
-- (id)init
-{
-    DDLogFileManagerDefault *defaultLogFileManager = [[DDLogFileManagerDefault alloc] init];
-    
-    return [self initWithLogFileManager:defaultLogFileManager];
-}
-
-- (instancetype)initWithLogFileManager:(id <DDLogFileManager>)aLogFileManager
-{
-    if ((self = [super init]))
-    {
-        maximumFileSize = DEFAULT_LOG_MAX_FILE_SIZE;
-        rollingFrequency = DEFAULT_LOG_ROLLING_FREQUENCY;
-        
-        logFileManager = aLogFileManager;
-        
-        formatter = [[DDLogFileFormatterDefault alloc] init];
-    }
-    return self;
-}
-
-- (void)dealloc
-{
-    [currentLogFileHandle synchronizeFile];
-    [currentLogFileHandle closeFile];
-
-    if (currentLogFileVnode) {
-        dispatch_source_cancel(currentLogFileVnode);
-        currentLogFileVnode = NULL;
-    }
-
-    if (rollingTimer)
-    {
-        dispatch_source_cancel(rollingTimer);
-        rollingTimer = NULL;
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark Properties
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-@synthesize logFileManager;
-
-- (unsigned long long)maximumFileSize
-{
-    __block unsigned long long result;
-    
-    dispatch_block_t block = ^{
-        result = maximumFileSize;
-    };
-    
-    // The design of this method is taken from the DDAbstractLogger implementation.
-    // For extensive documentation please refer to the DDAbstractLogger implementation.
-    
-    // Note: The internal implementation MUST access the maximumFileSize variable directly,
-    // This method is designed explicitly for external access.
-    //
-    // Using "self." syntax to go through this method will cause immediate deadlock.
-    // This is the intended result. Fix it by accessing the ivar directly.
-    // Great strides have been take to ensure this is safe to do. Plus it's MUCH faster.
-    
-    NSAssert(![self isOnGlobalLoggingQueue], @"Core architecture requirement failure");
-    NSAssert(![self isOnInternalLoggerQueue], @"MUST access ivar directly, NOT via self.* syntax.");
-    
-    dispatch_queue_t globalLoggingQueue = [DDLog loggingQueue];
-    
-    dispatch_sync(globalLoggingQueue, ^{
-        dispatch_sync(loggerQueue, block);
-    });
-    
-    return result;
-}
-
-- (void)setMaximumFileSize:(unsigned long long)newMaximumFileSize
-{
-    dispatch_block_t block = ^{ @autoreleasepool {
-        
-        maximumFileSize = newMaximumFileSize;
-        [self maybeRollLogFileDueToSize];
-        
-    }};
-    
-    // The design of this method is taken from the DDAbstractLogger implementation.
-    // For extensive documentation please refer to the DDAbstractLogger implementation.
-    
-    // Note: The internal implementation MUST access the maximumFileSize variable directly,
-    // This method is designed explicitly for external access.
-    //
-    // Using "self." syntax to go through this method will cause immediate deadlock.
-    // This is the intended result. Fix it by accessing the ivar directly.
-    // Great strides have been take to ensure this is safe to do. Plus it's MUCH faster.
-    
-    NSAssert(![self isOnGlobalLoggingQueue], @"Core architecture requirement failure");
-    NSAssert(![self isOnInternalLoggerQueue], @"MUST access ivar directly, NOT via self.* syntax.");
-    
-    dispatch_queue_t globalLoggingQueue = [DDLog loggingQueue];
-    
-    dispatch_async(globalLoggingQueue, ^{
-        dispatch_async(loggerQueue, block);
-    });
-}
-
-- (NSTimeInterval)rollingFrequency
-{
-    __block NSTimeInterval result;
-    
-    dispatch_block_t block = ^{
-        result = rollingFrequency;
-    };
-    
-    // The design of this method is taken from the DDAbstractLogger implementation.
-    // For extensive documentation please refer to the DDAbstractLogger implementation.
-    
-    // Note: The internal implementation should access the rollingFrequency variable directly,
-    // This method is designed explicitly for external access.
-    //
-    // Using "self." syntax to go through this method will cause immediate deadlock.
-    // This is the intended result. Fix it by accessing the ivar directly.
-    // Great strides have been take to ensure this is safe to do. Plus it's MUCH faster.
-    
-    NSAssert(![self isOnGlobalLoggingQueue], @"Core architecture requirement failure");
-    NSAssert(![self isOnInternalLoggerQueue], @"MUST access ivar directly, NOT via self.* syntax.");
-    
-    dispatch_queue_t globalLoggingQueue = [DDLog loggingQueue];
-    
-    dispatch_sync(globalLoggingQueue, ^{
-        dispatch_sync(loggerQueue, block);
-    });
-    
-    return result;
-}
-
-- (void)setRollingFrequency:(NSTimeInterval)newRollingFrequency
-{
-    dispatch_block_t block = ^{ @autoreleasepool {
-        
-        rollingFrequency = newRollingFrequency;
-        [self maybeRollLogFileDueToAge];
-    }};
-    
-    // The design of this method is taken from the DDAbstractLogger implementation.
-    // For extensive documentation please refer to the DDAbstractLogger implementation.
-    
-    // Note: The internal implementation should access the rollingFrequency variable directly,
-    // This method is designed explicitly for external access.
-    //
-    // Using "self." syntax to go through this method will cause immediate deadlock.
-    // This is the intended result. Fix it by accessing the ivar directly.
-    // Great strides have been take to ensure this is safe to do. Plus it's MUCH faster.
-    
-    NSAssert(![self isOnGlobalLoggingQueue], @"Core architecture requirement failure");
-    NSAssert(![self isOnInternalLoggerQueue], @"MUST access ivar directly, NOT via self.* syntax.");
-    
-    dispatch_queue_t globalLoggingQueue = [DDLog loggingQueue];
-    
-    dispatch_async(globalLoggingQueue, ^{
-        dispatch_async(loggerQueue, block);
-    });
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark File Rolling
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-- (void)scheduleTimerToRollLogFileDueToAge
-{
-    if (rollingTimer)
-    {
-        dispatch_source_cancel(rollingTimer);
-        rollingTimer = NULL;
-    }
-    
-    if (currentLogFileInfo == nil || rollingFrequency <= 0.0)
-    {
-        return;
-    }
-    
-    NSDate *logFileCreationDate = [currentLogFileInfo creationDate];
-    
-    NSTimeInterval ti = [logFileCreationDate timeIntervalSinceReferenceDate];
-    ti += rollingFrequency;
-    
-    NSDate *logFileRollingDate = [NSDate dateWithTimeIntervalSinceReferenceDate:ti];
-    
-    NSLogVerbose(@"DDFileLogger: scheduleTimerToRollLogFileDueToAge");
-    
-    NSLogVerbose(@"DDFileLogger: logFileCreationDate: %@", logFileCreationDate);
-    NSLogVerbose(@"DDFileLogger: logFileRollingDate : %@", logFileRollingDate);
-    
-    rollingTimer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, loggerQueue);
-    
-    dispatch_source_set_event_handler(rollingTimer, ^{ @autoreleasepool {
-        
-        [self maybeRollLogFileDueToAge];
-        
-    }});
-    
-    #if !OS_OBJECT_USE_OBJC
-    dispatch_source_t theRollingTimer = rollingTimer;
-    dispatch_source_set_cancel_handler(rollingTimer, ^{
-        dispatch_release(theRollingTimer);
-    });
-    #endif
-    
-    uint64_t delay = (uint64_t)([logFileRollingDate timeIntervalSinceNow] * NSEC_PER_SEC);
-    dispatch_time_t fireTime = dispatch_time(DISPATCH_TIME_NOW, delay);
-    
-    dispatch_source_set_timer(rollingTimer, fireTime, DISPATCH_TIME_FOREVER, 1.0);
-    dispatch_resume(rollingTimer);
-}
-
-
-- (void)rollLogFile
-{
-    [self rollLogFileWithCompletionBlock:nil];
-}
-
-- (void)rollLogFileWithCompletionBlock:(void (^)())completionBlock
-{
-    // This method is public.
-    // We need to execute the rolling on our logging thread/queue.
-    
-    dispatch_block_t block = ^{ @autoreleasepool {
-        
-        [self rollLogFileNow];
-
-        if (completionBlock)
-        {
-            dispatch_async(dispatch_get_main_queue(), ^{
-                completionBlock();
-            });
-        }
-    }};
-    
-    // The design of this method is taken from the DDAbstractLogger implementation.
-    // For extensive documentation please refer to the DDAbstractLogger implementation.
-    
-    if ([self isOnInternalLoggerQueue])
-    {
-        block();
-    }
-    else
-    {
-        dispatch_queue_t globalLoggingQueue = [DDLog loggingQueue];
-        NSAssert(![self isOnGlobalLoggingQueue], @"Core architecture requirement failure");
-        
-        dispatch_async(globalLoggingQueue, ^{
-            dispatch_async(loggerQueue, block);
-        });
-    }
-}
-
-- (void)rollLogFileNow
-{
-    NSLogVerbose(@"DDFileLogger: rollLogFileNow");
-    
-    
-    if (currentLogFileHandle == nil) return;
-    
-    [currentLogFileHandle synchronizeFile];
-    [currentLogFileHandle closeFile];
-    currentLogFileHandle = nil;
-    
-    currentLogFileInfo.isArchived = YES;
-    
-    if ([logFileManager respondsToSelector:@selector(didRollAndArchiveLogFile:)])
-    {
-        [logFileManager didRollAndArchiveLogFile:(currentLogFileInfo.filePath)];
-    }
-    
-    currentLogFileInfo = nil;
-    
-    if (currentLogFileVnode) {
-        dispatch_source_cancel(currentLogFileVnode);
-        currentLogFileVnode = NULL;
-    }
-
-    if (rollingTimer)
-    {
-        dispatch_source_cancel(rollingTimer);
-        rollingTimer = NULL;
-    }
-}
-
-- (void)maybeRollLogFileDueToAge
-{
-    if (rollingFrequency > 0.0 && currentLogFileInfo.age >= rollingFrequency)
-    {
-        NSLogVerbose(@"DDFileLogger: Rolling log file due to age...");
-        
-        [self rollLogFileNow];
-    }
-    else
-    {
-        [self scheduleTimerToRollLogFileDueToAge];
-    }
-}
-
-- (void)maybeRollLogFileDueToSize
-{
-    // This method is called from logMessage.
-    // Keep it FAST.
-    
-    // Note: Use direct access to maximumFileSize variable.
-    // We specifically wrote our own getter/setter method to allow us to do this (for performance reasons).
-    
-    if (maximumFileSize > 0)
-    {
-        unsigned long long fileSize = [currentLogFileHandle offsetInFile];
-        
-        if (fileSize >= maximumFileSize)
-        {
-            NSLogVerbose(@"DDFileLogger: Rolling log file due to size (%qu)...", fileSize);
-            
-            [self rollLogFileNow];
-        }
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark File Logging
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/**
- * Returns the log file that should be used.
- * If there is an existing log file that is suitable,
- * within the constraints of maximumFileSize and rollingFrequency, then it is returned.
- * 
- * Otherwise a new file is created and returned.
-**/
-- (DDLogFileInfo *)currentLogFileInfo
-{
-    if (currentLogFileInfo == nil)
-    {
-        NSArray *sortedLogFileInfos = [logFileManager sortedLogFileInfos];
-        
-        if ([sortedLogFileInfos count] > 0)
-        {
-            DDLogFileInfo *mostRecentLogFileInfo = [sortedLogFileInfos objectAtIndex:0];
-            
-            BOOL useExistingLogFile = YES;
-            BOOL shouldArchiveMostRecent = NO;
-            
-            if (mostRecentLogFileInfo.isArchived)
-            {
-                useExistingLogFile = NO;
-                shouldArchiveMostRecent = NO;
-            }
-            else if (maximumFileSize > 0 && mostRecentLogFileInfo.fileSize >= maximumFileSize)
-            {
-                useExistingLogFile = NO;
-                shouldArchiveMostRecent = YES;
-            }
-            else if (rollingFrequency > 0.0 && mostRecentLogFileInfo.age >= rollingFrequency)
-            {
-                useExistingLogFile = NO;
-                shouldArchiveMostRecent = YES;
-            }
-
-
-        #if TARGET_OS_IPHONE
-            // When creating log file on iOS we're setting NSFileProtectionKey attribute to NSFileProtectionCompleteUnlessOpen.
-            // 
-            // But in case if app is able to launch from background we need to have an ability to open log file any time we
-            // want (even if device is locked). Thats why that attribute have to be changed to
-            // NSFileProtectionCompleteUntilFirstUserAuthentication.
-            //
-            // If previous log was created when app wasn't running in background, but now it is - we archive it and create
-            // a new one.
-
-            if (useExistingLogFile && doesAppRunInBackground()) {
-                NSString *key = mostRecentLogFileInfo.fileAttributes[NSFileProtectionKey];
-
-                if (! [key isEqualToString:NSFileProtectionCompleteUntilFirstUserAuthentication]) {
-                    useExistingLogFile = NO;
-                    shouldArchiveMostRecent = YES;
-                }
-            }
-        #endif
-            
-            if (useExistingLogFile)
-            {
-                NSLogVerbose(@"DDFileLogger: Resuming logging with file %@", mostRecentLogFileInfo.fileName);
-                
-                currentLogFileInfo = mostRecentLogFileInfo;
-            }
-            else
-            {
-                if (shouldArchiveMostRecent)
-                {
-                    mostRecentLogFileInfo.isArchived = YES;
-                    
-                    if ([logFileManager respondsToSelector:@selector(didArchiveLogFile:)])
-                    {
-                        [logFileManager didArchiveLogFile:(mostRecentLogFileInfo.filePath)];
-                    }
-                }
-            }
-        }
-        
-        if (currentLogFileInfo == nil)
-        {
-            NSString *currentLogFilePath = [logFileManager createNewLogFile];
-            
-            currentLogFileInfo = [[DDLogFileInfo alloc] initWithFilePath:currentLogFilePath];
-        }
-    }
-    
-    return currentLogFileInfo;
-}
-
-- (NSFileHandle *)currentLogFileHandle
-{
-    if (currentLogFileHandle == nil)
-    {
-        NSString *logFilePath = [[self currentLogFileInfo] filePath];
-        
-        currentLogFileHandle = [NSFileHandle fileHandleForWritingAtPath:logFilePath];
-        [currentLogFileHandle seekToEndOfFile];
-        
-        if (currentLogFileHandle)
-        {
-            [self scheduleTimerToRollLogFileDueToAge];
-
-            // Here we are monitoring the log file. In case if it would be deleted ormoved
-            // somewhere we want to roll it and use a new one.
-            currentLogFileVnode = dispatch_source_create(
-                DISPATCH_SOURCE_TYPE_VNODE,
-                [currentLogFileHandle fileDescriptor],
-                DISPATCH_VNODE_DELETE | DISPATCH_VNODE_RENAME,
-                loggerQueue
-            );
-
-            dispatch_source_set_event_handler(currentLogFileVnode, ^{ @autoreleasepool {
-                NSLogInfo(@"DDFileLogger: Current logfile was moved. Rolling it and creating a new one");
-                [self rollLogFileNow];
-            }});
-
-            #if !OS_OBJECT_USE_OBJC
-            dispatch_source_t vnode = currentLogFileVnode;
-            dispatch_source_set_cancel_handler(currentLogFileVnode, ^{
-                dispatch_release(vnode);
-            });
-            #endif
-
-            dispatch_resume(currentLogFileVnode);
-        }
-    }
-    
-    return currentLogFileHandle;
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark DDLogger Protocol
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-static int exception_count = 0;
-- (void)logMessage:(DDLogMessage *)logMessage
-{
-    NSString *logMsg = logMessage->logMsg;
-    
-    if (formatter)
-    {
-        logMsg = [formatter formatLogMessage:logMessage];
-    }
-    
-    if (logMsg)
-    {
-        if (![logMsg hasSuffix:@"\n"])
-        {
-            logMsg = [logMsg stringByAppendingString:@"\n"];
-        }
-        
-        NSData *logData = [logMsg dataUsingEncoding:NSUTF8StringEncoding];
-
-        @try {
-            [[self currentLogFileHandle] writeData:logData];
-
-            [self maybeRollLogFileDueToSize];
-        }
-        @catch (NSException *exception) {
-            exception_count++;
-            if (exception_count <= 10) {
-                NSLogError(@"DDFileLogger.logMessage: %@", exception);
-                if (exception_count == 10)
-                    NSLogError(@"DDFileLogger.logMessage: Too many exceptions -- will not log any more of them.");
-            }
-        }
-    }
-}
-
-- (void)willRemoveLogger
-{
-    // If you override me be sure to invoke [super willRemoveLogger];
-    
-    [self rollLogFileNow];
-}
-
-- (NSString *)loggerName
-{
-    return @"cocoa.lumberjack.fileLogger";
-}
-
-@end
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark -
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-#if TARGET_IPHONE_SIMULATOR
-  #define XATTR_ARCHIVED_NAME  @"archived"
-#else
-  #define XATTR_ARCHIVED_NAME  @"lumberjack.log.archived"
-#endif
-
-@implementation DDLogFileInfo
-
-@synthesize filePath;
-
-@dynamic fileName;
-@dynamic fileAttributes;
-@dynamic creationDate;
-@dynamic modificationDate;
-@dynamic fileSize;
-@dynamic age;
-
-@dynamic isArchived;
-
-
-#pragma mark Lifecycle
-
-+ (instancetype)logFileWithPath:(NSString *)aFilePath
-{
-    return [[self alloc] initWithFilePath:aFilePath];
-}
-
-- (instancetype)initWithFilePath:(NSString *)aFilePath
-{
-    if ((self = [super init]))
-    {
-        filePath = [aFilePath copy];
-    }
-    return self;
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark Standard Info
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-- (NSDictionary *)fileAttributes
-{
-    if (fileAttributes == nil)
-    {
-        fileAttributes = [[NSFileManager defaultManager] attributesOfItemAtPath:filePath error:nil];
-    }
-    return fileAttributes;
-}
-
-- (NSString *)fileName
-{
-    if (fileName == nil)
-    {
-        fileName = [filePath lastPathComponent];
-    }
-    return fileName;
-}
-
-- (NSDate *)modificationDate
-{
-    if (modificationDate == nil)
-    {
-        modificationDate = [[self fileAttributes] objectForKey:NSFileModificationDate];
-    }
-    
-    return modificationDate;
-}
-
-- (NSDate *)creationDate
-{
-    if (creationDate == nil)
-    {
-        creationDate = [[self fileAttributes] objectForKey:NSFileCreationDate];
-    }
-    return creationDate;
-}
-
-- (unsigned long long)fileSize
-{
-    if (fileSize == 0)
-    {
-        fileSize = [[[self fileAttributes] objectForKey:NSFileSize] unsignedLongLongValue];
-    }
-    
-    return fileSize;
-}
-
-- (NSTimeInterval)age
-{
-    return [[self creationDate] timeIntervalSinceNow] * -1.0;
-}
-
-- (NSString *)description
-{
-    return [@{@"filePath": self.filePath ?: @"",
-              @"fileName": self.fileName ?: @"",
-              @"fileAttributes": self.fileAttributes ?: @"",
-              @"creationDate": self.creationDate ?: @"",
-              @"modificationDate": self.modificationDate ?: @"",
-              @"fileSize": @(self.fileSize),
-              @"age": @(self.age),
-              @"isArchived": @(self.isArchived)} description];
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark Archiving
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-- (BOOL)isArchived
-{
-    
-#if TARGET_IPHONE_SIMULATOR
-    
-    // Extended attributes don't work properly on the simulator.
-    // So we have to use a less attractive alternative.
-    // See full explanation in the header file.
-    
-    return [self hasExtensionAttributeWithName:XATTR_ARCHIVED_NAME];
-    
-#else
-    
-    return [self hasExtendedAttributeWithName:XATTR_ARCHIVED_NAME];
-    
-#endif
-}
-
-- (void)setIsArchived:(BOOL)flag
-{
-    
-#if TARGET_IPHONE_SIMULATOR
-    
-    // Extended attributes don't work properly on the simulator.
-    // So we have to use a less attractive alternative.
-    // See full explanation in the header file.
-    
-    if (flag)
-        [self addExtensionAttributeWithName:XATTR_ARCHIVED_NAME];
-    else
-        [self removeExtensionAttributeWithName:XATTR_ARCHIVED_NAME];
-    
-#else
-    
-    if (flag)
-        [self addExtendedAttributeWithName:XATTR_ARCHIVED_NAME];
-    else
-        [self removeExtendedAttributeWithName:XATTR_ARCHIVED_NAME];
-    
-#endif
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark Changes
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-- (void)reset
-{
-    fileName = nil;
-    fileAttributes = nil;
-    creationDate = nil;
-    modificationDate = nil;
-}
-
-- (void)renameFile:(NSString *)newFileName
-{
-    // This method is only used on the iPhone simulator, where normal extended attributes are broken.
-    // See full explanation in the header file.
-    
-    if (![newFileName isEqualToString:[self fileName]])
-    {
-        NSString *fileDir = [filePath stringByDeletingLastPathComponent];
-        
-        NSString *newFilePath = [fileDir stringByAppendingPathComponent:newFileName];
-        
-        NSLogVerbose(@"DDLogFileInfo: Renaming file: '%@' -> '%@'", self.fileName, newFileName);
-
-        NSError *error = nil;
-        if (![[NSFileManager defaultManager] fileExistsAtPath:newFilePath]){
-            if([[NSFileManager defaultManager] removeItemAtPath:newFilePath error:&error]){
-                NSLogError(@"DDLogFileInfo: Error deleting archive (%@): %@", self.fileName, error);
-            }
-        }
-
-        if (![[NSFileManager defaultManager] moveItemAtPath:filePath toPath:newFilePath error:&error])
-        {
-            NSLogError(@"DDLogFileInfo: Error renaming file (%@): %@", self.fileName, error);
-        }
-
-        filePath = newFilePath;
-        [self reset];
-    }
-}
-
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark Attribute Management
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-#if TARGET_IPHONE_SIMULATOR
-
-// Extended attributes don't work properly on the simulator.
-// So we have to use a less attractive alternative.
-// See full explanation in the header file.
-
-- (BOOL)hasExtensionAttributeWithName:(NSString *)attrName
-{
-    // This method is only used on the iPhone simulator, where normal extended attributes are broken.
-    // See full explanation in the header file.
-    
-    // Split the file name into components. File name may have various format, but generally
-    // structure is same:
-    //
-    // <name part>.<extension part> and <name part>.archived.<extension part>
-    // or
-    // <name part> and <name part>.archived
-    //
-    // So we want to search for the attrName in the components (ignoring the first array index).
-    
-    NSArray *components = [[self fileName] componentsSeparatedByString:@"."];
-    
-    // Watch out for file names without an extension
-
-    for (NSUInteger i = 1; i < components.count; i++)
-    {
-        NSString *attr = [components objectAtIndex:i];
-
-        if ([attrName isEqualToString:attr])
-        {
-            return YES;
-        }
-    }
-
-    return NO;
-}
-
-- (void)addExtensionAttributeWithName:(NSString *)attrName
-{
-    // This method is only used on the iPhone simulator, where normal extended attributes are broken.
-    // See full explanation in the header file.
-    
-    if ([attrName length] == 0) return;
-    
-    // Example:
-    // attrName = "archived"
-    //
-    // "mylog.txt" -> "mylog.archived.txt"
-    // "mylog"     -> "mylog.archived"
-
-    NSArray *components = [[self fileName] componentsSeparatedByString:@"."];
-    
-    NSUInteger count = [components count];
-    
-    NSUInteger estimatedNewLength = [[self fileName] length] + [attrName length] + 1;
-    NSMutableString *newFileName = [NSMutableString stringWithCapacity:estimatedNewLength];
-    
-    if (count > 0)
-    {
-        [newFileName appendString:[components objectAtIndex:0]];
-    }
-    
-    NSString *lastExt = @"";
-    
-    NSUInteger i;
-    for (i = 1; i < count; i++)
-    {
-        NSString *attr = [components objectAtIndex:i];
-        if ([attr length] == 0)
-        {
-            continue;
-        }
-        
-        if ([attrName isEqualToString:attr])
-        {
-            // Extension attribute already exists in file name
-            return;
-        }
-        
-        if ([lastExt length] > 0)
-        {
-            [newFileName appendFormat:@".%@", lastExt];
-        }
-        
-        lastExt = attr;
-    }
-    
-    [newFileName appendFormat:@".%@", attrName];
-    
-    if ([lastExt length] > 0)
-    {
-        [newFileName appendFormat:@".%@", lastExt];
-    }
-    
-    [self renameFile:newFileName];
-}
-
-- (void)removeExtensionAttributeWithName:(NSString *)attrName
-{
-    // This method is only used on the iPhone simulator, where normal extended attributes are broken.
-    // See full explanation in the header file.
-    
-    if ([attrName length] == 0) return;
-    
-    // Example:
-    // attrName = "archived"
-    // 
-    // "mylog.archived.txt" -> "mylog.txt"
-    // "mylog.archived"     -> "mylog"
-    
-    NSArray *components = [[self fileName] componentsSeparatedByString:@"."];
-    
-    NSUInteger count = [components count];
-    
-    NSUInteger estimatedNewLength = [[self fileName] length];
-    NSMutableString *newFileName = [NSMutableString stringWithCapacity:estimatedNewLength];
-    
-    if (count > 0)
-    {
-        [newFileName appendString:[components objectAtIndex:0]];
-    }
-    
-    BOOL found = NO;
-    
-    NSUInteger i;
-    for (i = 1; i < count; i++)
-    {
-        NSString *attr = [components objectAtIndex:i];
-        
-        if ([attrName isEqualToString:attr])
-        {
-            found = YES;
-        }
-        else
-        {
-            [newFileName appendFormat:@".%@", attr];
-        }
-    }
-    
-    if (found)
-    {
-        [self renameFile:newFileName];
-    }
-}
-
-#else
-
-- (BOOL)hasExtendedAttributeWithName:(NSString *)attrName
-{
-    const char *path = [filePath UTF8String];
-    const char *name = [attrName UTF8String];
-    
-    ssize_t result = getxattr(path, name, NULL, 0, 0, 0);
-    
-    return (result >= 0);
-}
-
-- (void)addExtendedAttributeWithName:(NSString *)attrName
-{
-    const char *path = [filePath UTF8String];
-    const char *name = [attrName UTF8String];
-    
-    int result = setxattr(path, name, NULL, 0, 0, 0);
-    
-    if (result < 0)
-    {
-        NSLogError(@"DDLogFileInfo: setxattr(%@, %@): error = %s",
-                   attrName,
-                   self.fileName,
-                   strerror(errno));
-    }
-}
-
-- (void)removeExtendedAttributeWithName:(NSString *)attrName
-{
-    const char *path = [filePath UTF8String];
-    const char *name = [attrName UTF8String];
-    
-    int result = removexattr(path, name, 0);
-    
-    if (result < 0 && errno != ENOATTR)
-    {
-        NSLogError(@"DDLogFileInfo: removexattr(%@, %@): error = %s",
-                   attrName,
-                   self.fileName,
-                   strerror(errno));
-    }
-}
-
-#endif
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma mark Comparisons
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-- (BOOL)isEqual:(id)object
-{
-    if ([object isKindOfClass:[self class]])
-    {
-        DDLogFileInfo *another = (DDLogFileInfo *)object;
-        
-        return [filePath isEqualToString:[another filePath]];
-    }
-    
-    return NO;
-}
-
-- (NSComparisonResult)reverseCompareByCreationDate:(DDLogFileInfo *)another
-{
-    NSDate *us = [self creationDate];
-    NSDate *them = [another creationDate];
-    
-    NSComparisonResult result = [us compare:them];
-    
-    if (result == NSOrderedAscending)
-        return NSOrderedDescending;
-    
-    if (result == NSOrderedDescending)
-        return NSOrderedAscending;
-    
-    return NSOrderedSame;
-}
-
-- (NSComparisonResult)reverseCompareByModificationDate:(DDLogFileInfo *)another
-{
-    NSDate *us = [self modificationDate];
-    NSDate *them = [another modificationDate];
-    
-    NSComparisonResult result = [us compare:them];
-    
-    if (result == NSOrderedAscending)
-        return NSOrderedDescending;
-    
-    if (result == NSOrderedDescending)
-        return NSOrderedAscending;
-    
-    return NSOrderedSame;
-}
-
-@end
-
-#if TARGET_OS_IPHONE
-/**
- * When creating log file on iOS we're setting NSFileProtectionKey attribute to NSFileProtectionCompleteUnlessOpen.
- *
- * But in case if app is able to launch from background we need to have an ability to open log file any time we
- * want (even if device is locked). Thats why that attribute have to be changed to
- * NSFileProtectionCompleteUntilFirstUserAuthentication.
- */
-BOOL doesAppRunInBackground()
-{
-    BOOL answer = NO;
-
-    NSArray *backgroundModes = [[NSBundle mainBundle] objectForInfoDictionaryKey:@"UIBackgroundModes"];
-
-    for (NSString *mode in backgroundModes) {
-        if (mode.length > 0) {
-            answer = YES;
-            break;
-        }
-    }
-
-    return answer;
-}
-#endif
-