motion-yapper 0.0.1 → 0.0.2

data/vendor/Pods/BuildHeaders/YapDatabase/YapDatabaseViewChange.h

@@ -86,8 +86,8 @@ typedef enum {
  *
  * YapDatabaseViewChangedMetadata means the metadata was changed.
  * This might have happend implicitly if the user invoked setObject:forKey:inCollection: (implicitly setting
- * the meatadata to nil). Or explicitly if the user invoked setObject:forKey:inCollection:withMetadata: or
- * setMetadata:forKey:inCollection:.
+ * the metadata to nil). Or explicitly if the user invoked setObject:forKey:inCollection:withMetadata: or
+ * replaceMetadata:forKey:inCollection:.
  * 
  * YapDatabaseViewChangedDependency means the row was flagged due to a cell drawing dependency configuration.
  * See YapDatabaseViewMappings: setCellDrawingDependencyForNeighboringCellWithOffset:forGroup:

data/vendor/Pods/BuildHeaders/YapDatabase/YapDatabaseViewConnection.h

@@ -1,4 +1,5 @@
 #import <Foundation/Foundation.h>
+
 #import "YapDatabaseExtensionConnection.h"
 #import "YapDatabaseViewChange.h"
 #import "YapDatabaseViewMappings.h"

data/vendor/Pods/BuildHeaders/YapDatabase/YapDatabaseViewMappings.h

@@ -173,6 +173,8 @@ struct YapDatabaseViewRangePosition {
 };
 typedef struct YapDatabaseViewRangePosition YapDatabaseViewRangePosition;
 
+typedef BOOL (^YapDatabaseViewMappingGroupFilter)(NSString *group, YapDatabaseReadTransaction *transaction);
+typedef NSComparisonResult (^YapDatabaseViewMappingGroupSort)(NSString *group1, NSString *group2, YapDatabaseReadTransaction *transaction);
 
 @interface YapDatabaseViewMappings : NSObject <NSCopying>
 
@@ -203,6 +205,21 @@ typedef struct YapDatabaseViewRangePosition YapDatabaseViewRangePosition;
 - (id)initWithGroups:(NSArray *)allGroups
 				view:(NSString *)registeredViewName;
 
+
+/**
+ * Initializes a new mappings object that uses a filterBlock and a sortBlock to dynamically construct sections from view.
+ * @param filterBlock
+ *      Block that takes a string and returns a BOOL.  returning YES will include the group in the sections of the mapping.
+ * @param sortBlock
+ *      Block used to sort group names for groups that pass the filter.
+ * @param registeredViewName
+ *      This is the name of the view, as you registered it with the database system.
+ *
+**/
+- (id)initWithGroupFilterBlock:(YapDatabaseViewMappingGroupFilter)filterBlock
+                     sortBlock:(YapDatabaseViewMappingGroupSort)sortBlock
+                          view:(NSString *)registeredViewName;
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma mark Accessors
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

data/vendor/Pods/BuildHeaders/YapDatabase/YapDatabaseViewOptions.h

@@ -43,11 +43,18 @@
  * 
  * The primary motivation for this is to reduce the overhead when first populating the view.
  * For example, if you're creating a view which only includes objects from a single collection,
- * then you could specify that collection here. And when the view first populates itself,
+ * then you could specify that collection here. So when the view first populates itself,
  * it will enumerate over just the allowedCollections, as opposed to enumerating over all collections.
+ * And enumerating a small subset of the entire database during view population can improve speed,
+ * especially with larger databases.
  * 
- * The groupingBlock will still be invoked, but only if the collection is contained in allowedCollections.
- * If not, the view will not invoke the groupingBlock, and act as if the groupingBlock had returned nil.
+ * In addition to reducing the overhead when first populating the view,
+ * the allowedCollections will pre-filter while you're making changes to the database.
+ * So if you add a new object to the database, and the associated collection isn't in allowedCollections,
+ * then the groupingBlock will never be invoked, and the view will act as if the groupingBlock returned nil.
+ * 
+ * For all rows whose collection is in the allowedCollections, the view acts normally.
+ * So the groupingBlock would still be invoked as normal.
  *
  * The default value is nil.
 **/

data/vendor/Pods/BuildHeaders/YapDatabase/YapDatabaseViewPrivate.h

@@ -23,6 +23,9 @@
 **/
 #define YAP_DATABASE_VIEW_CLASS_VERSION 3
 
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+#pragma mark -
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 @interface YapDatabaseView () {
 @public
@@ -32,7 +35,7 @@
 	YapDatabaseViewBlockType groupingBlockType;
 	YapDatabaseViewBlockType sortingBlockType;
 	
-	int version;
+	NSString *versionTag;
 	
 	YapDatabaseViewOptions *options;
 }
@@ -103,6 +106,8 @@
 	YapMemoryTableTransaction *pageTableTransaction;
 	YapMemoryTableTransaction *pageMetadataTableTransaction;
 	
+	BOOL isRepopulate;
+	
 @protected
 	
 	__unsafe_unretained YapDatabaseViewConnection *viewConnection;
@@ -116,6 +121,7 @@
 
 // The following are declared for view subclasses (such as YapDatabaseFilteredView)
 
+- (void)dropTablesForOldClassVersion:(int)oldClassVersion;
 - (BOOL)createTables;
 
 - (NSString *)registeredName;
@@ -151,3 +157,14 @@
                     usingBlock:(void (^)(int64_t rowid, NSUInteger index, BOOL *stop))block;
 
 @end
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+#pragma mark -
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+@protocol YapDatabaseViewDependency <NSObject>
+@optional
+
+- (void)viewDidRepopulate:(NSString *)registeredName;
+
+@end

data/vendor/Pods/BuildHeaders/YapDatabase/YapDatabaseViewTransaction.h

@@ -1,5 +1,7 @@
 #import <Foundation/Foundation.h>
+
 #import "YapDatabaseExtensionTransaction.h"
+#import "YapDatabaseViewTypes.h"
 #import "YapDatabaseViewMappings.h"
 
 /**
@@ -127,18 +129,6 @@ typedef NSComparisonResult (^YapDatabaseViewFindWithMetadataBlock) \
 typedef NSComparisonResult (^YapDatabaseViewFindWithRowBlock)      \
                                                         (NSString *collection, NSString *key, id object, id metadata);
 
-#ifndef YapDatabaseViewBlockTypeDefined
-#define YapDatabaseViewBlockTypeDefined 1
-
-typedef enum {
-	YapDatabaseViewBlockTypeWithKey       = 201,
-	YapDatabaseViewBlockTypeWithObject    = 202,
-	YapDatabaseViewBlockTypeWithMetadata  = 203,
-	YapDatabaseViewBlockTypeWithRow       = 204
-} YapDatabaseViewBlockType;
-
-#endif
-
 /**
  * This method uses a binary search algorithm to find a range of items within the view that match the given criteria.
  * For example:
@@ -314,6 +304,17 @@ typedef enum {
 - (void)touchObjectForKey:(NSString *)key inCollection:(NSString *)collection;
 - (void)touchMetadataForKey:(NSString *)key inCollection:(NSString *)collection;
 
+/**
+ * This method allows you to change the groupingBlock and/or sortingBlock on-the-fly.
+ * 
+ * Note: You must pass a different versionTag, or this method does nothing.
+**/
+- (void)setGroupingBlock:(YapDatabaseViewGroupingBlock)groupingBlock
+       groupingBlockType:(YapDatabaseViewBlockType)groupingBlockType
+            sortingBlock:(YapDatabaseViewSortingBlock)sortingBlock
+        sortingBlockType:(YapDatabaseViewBlockType)sortingBlockType
+              versionTag:(NSString *)versionTag;
+
 @end
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -331,30 +332,30 @@ typedef enum {
 /**
  * Equivalent to invoking:
  *
- * NSString *collection = nil;
- * NSString *key = nil;
- * [[transaction ext:@"myView"] getKey:&key collection:&collection atIndex:index inGroup:group];
- * [transaction objectForKey:key inCollection:collection];
+ * NSString *collection, *key;
+ * if ([[transaction ext:@"myView"] getKey:&key collection:&collection atIndex:index inGroup:group]) {
+ *     object = [transaction objectForKey:key inCollection:collection];
+ * }
 **/
 - (id)objectAtIndex:(NSUInteger)keyIndex inGroup:(NSString *)group;
 
 /**
  * Equivalent to invoking:
  *
- * NSString *collection = nil;
- * NSString *key = nil;
- * [[transaction ext:@"myView"] getFirstKey:&key collection:&collection inGroup:group];
- * [transaction objectForKey:key inCollection:collection];
+ * NSString *collection, *key;
+ * if ([[transaction ext:@"myView"] getFirstKey:&key collection:&collection inGroup:group]) {
+ *     object = [transaction objectForKey:key inCollection:collection];
+ * }
 **/
 - (id)firstObjectInGroup:(NSString *)group;
 
 /**
  * Equivalent to invoking:
  *
- * NSString *collection = nil;
- * NSString *key = nil;
- * [[transaction ext:@"myView"] getLastKey:&key collection:&collection inGroup:group];
- * [transaction objectForKey:key inCollection:collection];
+ * NSString *collection, *key;
+ * if ([[transaction ext:@"myView"] getLastKey:&key collection:&collection inGroup:group]) {
+ *     object = [transaction objectForKey:key inCollection:collection];
+ * }
 **/
 - (id)lastObjectInGroup:(NSString *)group;
 
@@ -436,6 +437,45 @@ typedef enum {
    atIndexPath:(NSIndexPath *)indexPath
   withMappings:(YapDatabaseViewMappings *)mappings;
 
+/**
+ * Gets the key & collection at the given row & section, assuming the given mappings are being used.
+ * Returns NO if the row or section is invalid, or the mappings aren't initialized.
+ * Otherwise returns YES, and sets the key & collection ptr (both optional).
+**/
+- (BOOL)getKey:(NSString **)keyPtr
+    collection:(NSString **)collectionPtr
+        forRow:(NSUInteger)row
+     inSection:(NSUInteger)section
+  withMappings:(YapDatabaseViewMappings *)mappings;
+
+/**
+ * Gets the object at the given indexPath, assuming the given mappings are being used.
+ * 
+ * Equivalent to invoking:
+ *
+ * NSString *collection, *key;
+ * if ([[transaction ext:@"myView"] getKey:&key collection:&collection atIndexPath:indexPath withMappings:mappings]) {
+ *     object = [transaction objectForKey:key inCollection:collection];
+ * }
+**/
+- (id)objectAtIndexPath:(NSIndexPath *)indexPath withMappings:(YapDatabaseViewMappings *)mappings;
+
+/**
+ * Gets the object at the given indexPath, assuming the given mappings are being used.
+ *
+ * Equivalent to invoking:
+ *
+ * NSString *collection, *key;
+ * if ([[transaction ext:@"view"] getKey:&key
+ *                            collection:&collection
+ *                                forRow:row
+ *                             inSection:section
+ *                          withMappings:mappings]) {
+ *     object = [transaction objectForKey:key inCollection:collection];
+ * }
+**/
+- (id)objectAtRow:(NSUInteger)row inSection:(NSUInteger)section withMappings:(YapDatabaseViewMappings *)mappings;
+
 /**
  * Fetches the indexPath for the given {collection, key} tuple, assuming the given mappings are being used.
  * Returns nil if the {collection, key} tuple isn't included in the view + mappings.
@@ -444,4 +484,15 @@ typedef enum {
                     inCollection:(NSString *)collection
                     withMappings:(YapDatabaseViewMappings *)mappings;
 
+/**
+ * Fetches the row & section for the given {collection, key} tuple, assuming the given mappings are being used.
+ * Returns NO if the {collection, key} tuple isn't included in the view + mappings.
+ * Otherwise returns YES, and sets the row & section (both optional).
+**/
+- (BOOL)getRow:(NSUInteger *)rowPtr
+       section:(NSUInteger *)sectionPtr
+        forKey:(NSString *)key
+  inCollection:(NSString *)collection
+  withMappings:(YapDatabaseViewMappings *)mappings;
+
 @end

data/vendor/Pods/BuildHeaders/YapDatabase/YapDatabaseViewTypes.h

@@ -0,0 +1,99 @@
+#import <Foundation/Foundation.h>
+
+
+/**
+ * The grouping block handles both filtering and grouping.
+ * 
+ * When you add or update rows in the databse the grouping block is invoked.
+ * Your grouping block can inspect the row and determine if it should be a part of the view.
+ * If not, your grouping block simply returns 'nil' and the object is excluded from the view (removing it if needed).
+ * Otherwise your grouping block returns a group, which can be any string you want.
+ * Once the view knows what group the row belongs to,
+ * it will then determine the position of the row within the group (using the sorting block).
+ * 
+ * You should choose a block type that takes the minimum number of required parameters.
+ * The view can make various optimizations based on required parameters of the block.
+**/
+typedef id YapDatabaseViewGroupingBlock; // One of the YapDatabaseViewGroupingX types below.
+
+typedef NSString* (^YapDatabaseViewGroupingWithKeyBlock)(NSString *collection, NSString *key);
+typedef NSString* (^YapDatabaseViewGroupingWithObjectBlock)(NSString *collection, NSString *key, id object);
+typedef NSString* (^YapDatabaseViewGroupingWithMetadataBlock)(NSString *collection, NSString *key, id metadata);
+typedef NSString* (^YapDatabaseViewGroupingWithRowBlock)(NSString *collection, NSString *key, id object, id metadata);
+
+
+/**
+ * The sorting block handles sorting of objects within their group.
+ *
+ * After the view invokes the grouping block to determine what group a database row belongs to (if any),
+ * the view then needs to determine what index within that group the row should be.
+ * In order to do this, it needs to compare the new/updated row with existing rows in the same view group.
+ * This is what the sorting block is used for.
+ * So the sorting block will be invoked automatically during this process until the view has come to a conclusion.
+ * 
+ * You should choose a block type that takes the minimum number of required parameters.
+ * The view can make various optimizations based on required parameters of the block.
+ * 
+ * For example, if sorting is based on the object, and the metadata of a row is updated,
+ * then the view can deduce that the index hasn't changed (if the group hans't), and can skip this step.
+ * 
+ * Performance Note:
+ * 
+ * The view uses various optimizations (based on common patterns)
+ * to reduce the number of times it needs to invoke the sorting block.
+ *
+ * - Pattern      : row is updated, but its index in the view doesn't change.
+ *   Optimization : if an updated row doesn't change groups, the view will first compare it with
+ *                  objects to the left and right.
+ *
+ * - Pattern      : rows are added to the beginning or end or a view
+ *   Optimization : if the last change put an object at the beginning of the view, then it will test this quickly.
+ *                  if the last change put an object at the end of the view, then it will test this quickly.
+ * 
+ * These optimizations offer huge performance benefits to many common cases.
+ * For example, adding objects to a view that are sorted by timestamp of when they arrived.
+ *
+ * The optimizations are not always performed.
+ * That is, if the row is added to a group it didn't previously belong,
+ * or if the last change didn't place an item at the beginning or end of the view.
+ *
+ * If optimizations fail, or are skipped, then the view uses a binary search algorithm.
+ * 
+ * Although this may be considered "internal information",
+ * I feel it is important to explain for the following reason:
+ * 
+ * Another common pattern is to fetch a number of objects in a batch, and then insert them into the database.
+ * Now imagine a situation in which the view is sorting posts based on timestamp,
+ * and you just fetched the most recent 10 posts. You can enumerate these 10 posts in forwards or backwards
+ * while adding them to the database. One direction will hit the optimization every time. The other will cause
+ * the view to perform a binary search every time. These little one-liner optimzations are easy.
+**/
+typedef id YapDatabaseViewSortingBlock; // One of the YapDatabaseViewSortingX types below.
+
+typedef NSComparisonResult (^YapDatabaseViewSortingWithKeyBlock) \
+                 (NSString *group, NSString *collection1, NSString *key1, \
+                                   NSString *collection2, NSString *key2);
+typedef NSComparisonResult (^YapDatabaseViewSortingWithObjectBlock) \
+                 (NSString *group, NSString *collection1, NSString *key1, id object1, \
+                                   NSString *collection2, NSString *key2, id object2);
+typedef NSComparisonResult (^YapDatabaseViewSortingWithMetadataBlock) \
+                 (NSString *group, NSString *collection1, NSString *key1, id metadata, \
+                                   NSString *collection2, NSString *key2, id metadata2);
+typedef NSComparisonResult (^YapDatabaseViewSortingWithRowBlock) \
+                 (NSString *group, NSString *collection1, NSString *key1, id object1, id metadata1, \
+                                   NSString *collection2, NSString *key2, id object2, id metadata2);
+
+
+/**
+ * I wish there was a way to inspect a given block and see what kind of parameters it takes.
+ * Sadly this does not appear to be possible (at least not in any kind of standard legal way).
+ * 
+ * Thus you will have to specify what kind of block you're passing.
+**/
+typedef enum {
+	YapDatabaseViewBlockTypeWithKey       = 1,
+	YapDatabaseViewBlockTypeWithObject    = 2,
+	YapDatabaseViewBlockTypeWithMetadata  = 3,
+	YapDatabaseViewBlockTypeWithRow       = 4
+} YapDatabaseViewBlockType;
+

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

@@ -7,10 +7,10 @@
  * Welcome to Cocoa Lumberjack!
  * 
  * The project page has a wealth of documentation if you have any questions.
- * https://github.com/robbiehanson/CocoaLumberjack
+ * https://github.com/CocoaLumberjack/CocoaLumberjack
  * 
  * If you're new to the project you may wish to read the "Getting Started" wiki.
- * https://github.com/robbiehanson/CocoaLumberjack/wiki/GettingStarted
+ * https://github.com/CocoaLumberjack/CocoaLumberjack/wiki/GettingStarted
  * 
  * 
  * This class provides a logger for the Apple System Log facility.
@@ -28,10 +28,10 @@
 
 @interface DDASLLogger : DDAbstractLogger <DDLogger>
 {
-	aslclient client;
+    aslclient client;
 }
 
-+ (DDASLLogger *)sharedInstance;
++ (instancetype)sharedInstance;
 
 // Inherited from DDAbstractLogger
 

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

@@ -6,10 +6,10 @@
  * Welcome to Cocoa Lumberjack!
  * 
  * The project page has a wealth of documentation if you have any questions.
- * https://github.com/robbiehanson/CocoaLumberjack
+ * https://github.com/CocoaLumberjack/CocoaLumberjack
  * 
  * If you're new to the project you may wish to read the "Getting Started" wiki.
- * https://github.com/robbiehanson/CocoaLumberjack/wiki/GettingStarted
+ * https://github.com/CocoaLumberjack/CocoaLumberjack/wiki/GettingStarted
 **/
 
 #if ! __has_feature(objc_arc)
@@ -31,69 +31,70 @@ static DDASLLogger *sharedInstance;
 **/
 + (void)initialize
 {
-	static BOOL initialized = NO;
-	if (!initialized)
-	{
-		initialized = YES;
-		
-		sharedInstance = [[DDASLLogger alloc] init];
-	}
+    static BOOL initialized = NO;
+    if (!initialized)
+    {
+        initialized = YES;
+        
+        sharedInstance = [[[self class] alloc] init];
+    }
 }
 
-+ (DDASLLogger *)sharedInstance
++ (instancetype)sharedInstance
 {
-	return sharedInstance;
+    return sharedInstance;
 }
 
 - (id)init
 {
-	if (sharedInstance != nil)
-	{
-		return nil;
-	}
-	
-	if ((self = [super init]))
-	{
-		// A default asl client is provided for the main thread,
-		// but background threads need to create their own client.
-		
-		client = asl_open(NULL, "com.apple.console", 0);
-	}
-	return self;
+    if (sharedInstance != nil)
+    {
+        return nil;
+    }
+    
+    if ((self = [super init]))
+    {
+        // A default asl client is provided for the main thread,
+        // but background threads need to create their own client.
+        
+        client = asl_open(NULL, "com.apple.console", 0);
+    }
+    return self;
 }
 
 - (void)logMessage:(DDLogMessage *)logMessage
 {
-	NSString *logMsg = logMessage->logMsg;
-	
-	if (formatter)
-	{
-		logMsg = [formatter formatLogMessage:logMessage];
-	}
-	
-	if (logMsg)
-	{
-		const char *msg = [logMsg UTF8String];
-		
-		int aslLogLevel;
-		switch (logMessage->logFlag)
-		{
-			// Note: By default ASL will filter anything above level 5 (Notice).
-			// So our mappings shouldn't go above that level.
-			
-			case LOG_FLAG_ERROR : aslLogLevel = ASL_LEVEL_CRIT;    break;
-			case LOG_FLAG_WARN  : aslLogLevel = ASL_LEVEL_ERR;     break;
-			case LOG_FLAG_INFO  : aslLogLevel = ASL_LEVEL_WARNING; break;
-			default             : aslLogLevel = ASL_LEVEL_NOTICE;  break;
-		}
-		
-		asl_log(client, NULL, aslLogLevel, "%s", msg);
-	}
+    NSString *logMsg = logMessage->logMsg;
+    
+    if (formatter)
+    {
+        logMsg = [formatter formatLogMessage:logMessage];
+    }
+    
+    if (logMsg)
+    {
+        const char *msg = [logMsg UTF8String];
+        
+        int aslLogLevel;
+        switch (logMessage->logFlag)
+        {
+            // Note: By default ASL will filter anything above level 5 (Notice).
+            // So our mappings shouldn't go above that level.
+            
+            case LOG_FLAG_ERROR : aslLogLevel = ASL_LEVEL_ALERT;   break;
+            case LOG_FLAG_WARN  : aslLogLevel = ASL_LEVEL_CRIT;    break;
+            case LOG_FLAG_INFO  : aslLogLevel = ASL_LEVEL_ERR;     break;
+            case LOG_FLAG_DEBUG : aslLogLevel = ASL_LEVEL_WARNING; break;
+            default             : aslLogLevel = ASL_LEVEL_NOTICE;  break;
+        }
+        
+        asl_log(client, NULL, aslLogLevel, "%s", msg);
+    }
 }
 
 - (NSString *)loggerName
 {
-	return @"cocoa.lumberjack.aslLogger";
+    return @"cocoa.lumberjack.aslLogger";
 }
 
 @end