second_curtain 0.2.2 → 0.2.3

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+beSubclassOf.m

@@ -0,0 +1,27 @@
+#import "EXPMatchers+beSubclassOf.h"
+#import "NSValue+Expecta.h"
+#import <objc/runtime.h>
+
+EXPMatcherImplementationBegin(beSubclassOf, (Class expected)) {
+  __block BOOL actualIsClass = YES;
+
+  prerequisite(^BOOL {
+    actualIsClass = class_isMetaClass(object_getClass(actual));
+    return actualIsClass;
+  });
+
+  match(^BOOL{
+    return [actual isSubclassOfClass:expected];
+  });
+
+  failureMessageForTo(^NSString *{
+    if(!actualIsClass) return @"the actual value is not a Class";
+    return [NSString stringWithFormat:@"expected: a subclass of %@, got: a class %@, which is not a subclass of %@", [expected class], actual, [expected class]];
+  });
+
+  failureMessageForNotTo(^NSString *{
+    if(!actualIsClass) return @"the actual value is not a Class";
+    return [NSString stringWithFormat:@"expected: not a subclass of %@, got: a class %@, which is a subclass of %@", [expected class], actual, [expected class]];
+  });
+}
+EXPMatcherImplementationEnd

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+beSupersetOf.h

@@ -0,0 +1,4 @@
+#import "Expecta.h"
+
+EXPMatcherInterface(beSupersetOf, (id subset));
+

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+beSupersetOf.m

@@ -0,0 +1,57 @@
+#import "EXPMatchers+contain.h"
+
+EXPMatcherImplementationBegin(beSupersetOf, (id subset)) {
+  BOOL actualIsCompatible = [actual isKindOfClass:[NSDictionary class]] || [actual respondsToSelector:@selector(containsObject:)];
+  BOOL subsetIsNil = (subset == nil);
+
+  // For some instances the isKindOfClass: method returns false, even though
+  // they are both actually dictionaries. e.g. Comparing a NSCFDictionary and a
+  // NSDictionary.
+  BOOL bothAreDictionaries = [actual isKindOfClass:[NSDictionary class]] && [subset isKindOfClass:[NSDictionary class]];
+
+  BOOL classMatches = bothAreDictionaries || [subset isKindOfClass:[actual class]];
+
+  prerequisite(^BOOL{
+    return actualIsCompatible && !subsetIsNil && classMatches;
+  });
+
+  match(^BOOL{
+    if(!actualIsCompatible) return NO;
+
+    if([actual isKindOfClass:[NSDictionary class]]) {
+      for (id key in subset) {
+        id actualValue = [actual valueForKey:key];
+        id subsetValue = [subset valueForKey:key];
+
+        if (![subsetValue isEqual:actualValue]) return NO;
+      }
+    } else {
+      for (id object in subset) {
+        if (![actual containsObject:object]) return NO;
+      }
+    }
+
+    return YES;
+  });
+
+  failureMessageForTo(^NSString *{
+    if(!actualIsCompatible) return [NSString stringWithFormat:@"%@ is not an instance of NSDictionary and does not implement -containsObject:", EXPDescribeObject(actual)];
+
+    if(subsetIsNil) return @"the expected value is nil/null";
+
+    if(!classMatches) return [NSString stringWithFormat:@"%@ does not match the class of %@", EXPDescribeObject(subset), EXPDescribeObject(actual)];
+
+    return [NSString stringWithFormat:@"expected %@ to be a superset of %@", EXPDescribeObject(actual), EXPDescribeObject(subset)];
+  });
+
+  failureMessageForNotTo(^NSString *{
+    if(!actualIsCompatible) return [NSString stringWithFormat:@"%@ is not an instance of NSDictionary and does not implement -containsObject:", EXPDescribeObject(actual)];
+
+    if(subsetIsNil) return @"the expected value is nil/null";
+
+    if(!classMatches) return [NSString stringWithFormat:@"%@ does not match the class of %@", EXPDescribeObject(subset), EXPDescribeObject(actual)];
+
+    return [NSString stringWithFormat:@"expected %@ not to be a superset of %@", EXPDescribeObject(actual), EXPDescribeObject(subset)];
+  });
+}
+EXPMatcherImplementationEnd

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+beTruthy.h

@@ -0,0 +1,3 @@
+#import "Expecta.h"
+
+EXPMatcherInterface(beTruthy, (void));

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+beTruthy.m

@@ -0,0 +1,24 @@
+#import "EXPMatchers+beTruthy.h"
+#import "EXPMatcherHelpers.h"
+
+EXPMatcherImplementationBegin(beTruthy, (void)) {
+  match(^BOOL{
+    if([actual isKindOfClass:[NSNumber class]]) {
+      return !![(NSNumber *)actual boolValue];
+    } else if([actual isKindOfClass:[NSValue class]]) {
+      if(EXPIsValuePointer((NSValue *)actual)) {
+        return !![(NSValue *)actual pointerValue];
+      }
+    }
+    return !!actual;
+  });
+
+  failureMessageForTo(^NSString *{
+    return [NSString stringWithFormat:@"expected: a truthy value, got: %@, which is falsy", EXPDescribeObject(actual)];
+  });
+
+  failureMessageForNotTo(^NSString *{
+    return [NSString stringWithFormat:@"expected: a non-truthy value, got: %@, which is truthy", EXPDescribeObject(actual)];
+  });
+}
+EXPMatcherImplementationEnd

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+beginWith.h

@@ -0,0 +1,5 @@
+#import "Expecta.h"
+
+EXPMatcherInterface(beginWith, (id expected));
+
+#define startWith beginWith

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+beginWith.m

@@ -0,0 +1,49 @@
+#import "EXPMatchers+beginWith.h"
+
+EXPMatcherImplementationBegin(beginWith, (id expected)) {
+  BOOL actualIsNil = (actual == nil);
+  BOOL expectedIsNil = (expected == nil);
+  //This condition allows the comparison of an immutable string or ordered collection to the mutable type of the same
+  BOOL actualAndExpectedAreCompatible = (([actual isKindOfClass:[NSString class]] && [expected isKindOfClass:[NSString class]])
+                                         || ([actual isKindOfClass:[NSArray class]] && [expected isKindOfClass:[NSArray class]])
+                                         || ([actual isKindOfClass:[NSOrderedSet class]] && [expected isKindOfClass:[NSOrderedSet class]]));
+  
+  prerequisite(^BOOL {
+    return actualAndExpectedAreCompatible;
+  });
+  
+  match(^BOOL {
+    if ([actual isKindOfClass:[NSString class]]) {
+      return [actual hasPrefix:expected];
+    } else if ([actual isKindOfClass:[NSArray class]]) {
+      if ([expected count] > [actual count] || [expected count] == 0) {
+        return NO;
+      }
+      NSArray *subArray = [actual subarrayWithRange:NSMakeRange(0, [expected count])];
+      return [subArray isEqualToArray:expected];
+    } else {
+      if ([expected count] > [actual count] || [expected count] == 0) {
+        return NO;
+      }
+      
+      NSOrderedSet *subset = [NSOrderedSet orderedSetWithOrderedSet:actual range:NSMakeRange(0, [expected count]) copyItems:NO];
+      return [subset isEqualToOrderedSet:expected];
+    }
+  });
+  
+  failureMessageForTo(^NSString *{
+    if (actualIsNil) return @"the object is nil/null";
+    if (expectedIsNil) return @"the expected value is nil/null";
+    if (!actualAndExpectedAreCompatible) return [NSString stringWithFormat:@"%@ and %@ are not instances of one of %@, %@, or %@", EXPDescribeObject(actual), EXPDescribeObject(expected), [NSString class], [NSArray class], [NSOrderedSet class]];
+    return [NSString stringWithFormat:@"expected: %@ to begin with %@", EXPDescribeObject(actual), EXPDescribeObject(expected)];
+  });
+  
+  failureMessageForNotTo(^NSString *{
+    if (actualIsNil) return @"the object is nil/null";
+    if (expectedIsNil) return @"the expected value is nil/null";
+    if (!actualAndExpectedAreCompatible) return [NSString stringWithFormat:@"%@ and %@ are not instances of one of %@, %@, or %@", EXPDescribeObject(actual), EXPDescribeObject(expected), [NSString class], [NSArray class], [NSOrderedSet class]];
+    
+    return [NSString stringWithFormat:@"expected: %@ not to begin with %@", EXPDescribeObject(actual), EXPDescribeObject(expected)];
+  });
+}
+EXPMatcherImplementationEnd

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+conformTo.h

@@ -0,0 +1,3 @@
+#import "Expecta.h"
+
+EXPMatcherInterface(conformTo, (Protocol *expected));

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+conformTo.m

@@ -0,0 +1,33 @@
+#import "EXPMatchers+conformTo.h"
+#import "NSValue+Expecta.h"
+#import <objc/runtime.h>
+
+EXPMatcherImplementationBegin(conformTo, (Protocol *expected)) {
+    BOOL actualIsNil = (actual == nil);
+    BOOL expectedIsNil = (expected == nil);
+
+    prerequisite(^BOOL{
+        return !(actualIsNil || expectedIsNil);
+    });
+
+    match(^BOOL{
+        return [actual conformsToProtocol:expected];
+    });
+
+    failureMessageForTo(^NSString *{
+        if(actualIsNil) return @"the object is nil/null";
+        if(expectedIsNil) return @"the protocol is nil/null";
+
+        NSString *name = NSStringFromProtocol(expected);
+        return [NSString stringWithFormat:@"expected: %@ to conform to %@", actual, name];
+    });
+
+    failureMessageForNotTo(^NSString *{
+        if(actualIsNil) return @"the object is nil/null";
+        if(expectedIsNil) return @"the protocol is nil/null";
+
+        NSString *name = NSStringFromProtocol(expected);
+        return [NSString stringWithFormat:@"expected: %@ not to conform to %@", actual, name];
+    });
+}
+EXPMatcherImplementationEnd

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+contain.h

@@ -0,0 +1,5 @@
+#import "Expecta.h"
+
+EXPMatcherInterface(_contain, (id expected));
+EXPMatcherInterface(contain, (id expected)); // to aid code completion
+#define contain(expected) _contain(EXPObjectify((expected)))

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+contain.m

@@ -0,0 +1,38 @@
+#import "EXPMatchers+contain.h"
+
+EXPMatcherImplementationBegin(_contain, (id expected)) {
+  BOOL actualIsCompatible = [actual isKindOfClass:[NSString class]] || [actual conformsToProtocol:@protocol(NSFastEnumeration)];
+  BOOL expectedIsNil = (expected == nil);
+
+  prerequisite(^BOOL{
+    return actualIsCompatible && !expectedIsNil;
+  });
+
+  match(^BOOL{
+    if(actualIsCompatible) {
+      if([actual isKindOfClass:[NSString class]]) {
+        return [(NSString *)actual rangeOfString:[expected description]].location != NSNotFound;
+      } else {
+        for (id object in actual) {
+          if ([object isEqual:expected]) {
+            return YES;
+          }
+        }
+      }
+    }
+    return NO;
+  });
+
+  failureMessageForTo(^NSString *{
+    if(!actualIsCompatible) return [NSString stringWithFormat:@"%@ is not an instance of NSString or NSFastEnumeration", EXPDescribeObject(actual)];
+    if(expectedIsNil) return @"the expected value is nil/null";
+    return [NSString stringWithFormat:@"expected %@ to contain %@", EXPDescribeObject(actual), EXPDescribeObject(expected)];
+  });
+
+  failureMessageForNotTo(^NSString *{
+    if(!actualIsCompatible) return [NSString stringWithFormat:@"%@ is not an instance of NSString or NSFastEnumeration", EXPDescribeObject(actual)];
+    if(expectedIsNil) return @"the expected value is nil/null";
+    return [NSString stringWithFormat:@"expected %@ not to contain %@", EXPDescribeObject(actual), EXPDescribeObject(expected)];
+  });
+}
+EXPMatcherImplementationEnd

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+endWith.h

@@ -0,0 +1,3 @@
+#import "Expecta.h"
+
+EXPMatcherInterface(endWith, (id expected));

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+endWith.m

@@ -0,0 +1,49 @@
+#import "EXPMatchers+endWith.h"
+
+EXPMatcherImplementationBegin(endWith, (id expected)) {
+  BOOL actualIsNil = (actual == nil);
+  BOOL expectedIsNil = (expected == nil);
+  //This condition allows the comparison of an immutable string or ordered collection to the mutable type of the same
+  BOOL actualAndExpectedAreCompatible = (([actual isKindOfClass:[NSString class]] && [expected isKindOfClass:[NSString class]])
+                                         || ([actual isKindOfClass:[NSArray class]] && [expected isKindOfClass:[NSArray class]])
+                                         || ([actual isKindOfClass:[NSOrderedSet class]] && [expected isKindOfClass:[NSOrderedSet class]]));
+  
+  prerequisite(^BOOL {
+    return actualAndExpectedAreCompatible;
+  });
+  
+  match(^BOOL {
+    if ([actual isKindOfClass:[NSString class]]) {
+      return [actual hasSuffix:expected];
+    } else if ([actual isKindOfClass:[NSArray class]]) {
+      if ([expected count] > [actual count] || [expected count] == 0) {
+        return NO;
+      }
+      NSArray *subArray = [actual subarrayWithRange:NSMakeRange([actual count] - [expected count], [expected count])];
+      return [subArray isEqualToArray:expected];
+    } else {
+      if ([expected count] > [actual count] || [expected count] == 0) {
+        return NO;
+      }
+      
+      NSOrderedSet *subset = [NSOrderedSet orderedSetWithOrderedSet:actual range:NSMakeRange([actual count] - [expected count], [expected count]) copyItems:NO];
+      return [subset isEqualToOrderedSet:expected];
+    }
+  });
+  
+  failureMessageForTo(^NSString *{
+    if (actualIsNil) return @"the object is nil/null";
+    if (expectedIsNil) return @"the expected value is nil/null";
+    if (!actualAndExpectedAreCompatible) return [NSString stringWithFormat:@"%@ and %@ are not instances of one of %@, %@, or %@", EXPDescribeObject(actual), EXPDescribeObject(expected), [NSString class], [NSArray class], [NSOrderedSet class]];
+    return [NSString stringWithFormat:@"expected: %@ to end with %@", EXPDescribeObject(actual), EXPDescribeObject(expected)];
+  });
+  
+  failureMessageForNotTo(^NSString *{
+    if (actualIsNil) return @"the object is nil/null";
+    if (expectedIsNil) return @"the expected value is nil/null";
+    if (!actualAndExpectedAreCompatible) return [NSString stringWithFormat:@"%@ and %@ are not instances of one of %@, %@, or %@", EXPDescribeObject(actual), EXPDescribeObject(expected), [NSString class], [NSArray class], [NSOrderedSet class]];
+    
+    return [NSString stringWithFormat:@"expected: %@ not to end with %@", EXPDescribeObject(actual), EXPDescribeObject(expected)];
+  });
+}
+EXPMatcherImplementationEnd

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+equal.h

@@ -0,0 +1,5 @@
+#import "Expecta.h"
+
+EXPMatcherInterface(_equal, (id expected));
+EXPMatcherInterface(equal, (id expected)); // to aid code completion
+#define equal(...) _equal(EXPObjectify((__VA_ARGS__)))

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+equal.m

@@ -0,0 +1,24 @@
+#import "EXPMatchers+equal.h"
+#import "EXPMatcherHelpers.h"
+
+EXPMatcherImplementationBegin(_equal, (id expected)) {
+  match(^BOOL{
+    if((actual == expected) || [actual isEqual:expected]) {
+      return YES;
+    } else if([actual isKindOfClass:[NSNumber class]] && [expected isKindOfClass:[NSNumber class]]) {
+      if(EXPIsNumberFloat((NSNumber *)actual) || EXPIsNumberFloat((NSNumber *)expected)) {
+        return [(NSNumber *)actual floatValue] == [(NSNumber *)expected floatValue];
+      }
+    }
+    return NO;
+  });
+
+  failureMessageForTo(^NSString *{
+    return [NSString stringWithFormat:@"expected: %@, got: %@", EXPDescribeObject(expected), EXPDescribeObject(actual)];
+  });
+
+  failureMessageForNotTo(^NSString *{
+    return [NSString stringWithFormat:@"expected: not %@, got: %@", EXPDescribeObject(expected), EXPDescribeObject(actual)];
+  });
+}
+EXPMatcherImplementationEnd

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+haveCountOf.h

@@ -0,0 +1,10 @@
+#import "Expecta.h"
+
+EXPMatcherInterface(haveCountOf, (NSUInteger expected));
+
+#define haveCount     haveCountOf
+#define haveACountOf  haveCountOf
+#define haveLength    haveCountOf
+#define haveLengthOf  haveCountOf
+#define haveALengthOf haveCountOf
+#define beEmpty()     haveCountOf(0)

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+haveCountOf.m

@@ -0,0 +1,36 @@
+#import "EXPMatchers+haveCountOf.h"
+
+EXPMatcherImplementationBegin(haveCountOf, (NSUInteger expected)) {
+  BOOL actualIsStringy = [actual isKindOfClass:[NSString class]] || [actual isKindOfClass:[NSAttributedString class]];
+  BOOL actualIsCompatible = actualIsStringy || [actual respondsToSelector:@selector(count)];
+
+  prerequisite(^BOOL{
+    return actualIsCompatible;
+  });
+
+  NSUInteger (^count)(id) = ^(id actual) {
+    if(actualIsStringy) {
+      return [actual length];
+  } else {
+      return [actual count];
+    }
+  };
+
+  match(^BOOL{
+    if(actualIsCompatible) {
+      return count(actual) == expected;
+    }
+    return NO;
+  });
+
+  failureMessageForTo(^NSString *{
+    if(!actualIsCompatible) return [NSString stringWithFormat:@"%@ is not an instance of NSString, NSAttributedString, NSArray, NSSet, NSOrderedSet, or NSDictionary", EXPDescribeObject(actual)];
+    return [NSString stringWithFormat:@"expected %@ to have a count of %zi but got %zi", EXPDescribeObject(actual), expected, count(actual)];
+  });
+
+  failureMessageForNotTo(^NSString *{
+    if(!actualIsCompatible) return [NSString stringWithFormat:@"%@ is not an instance of NSString, NSAttributedString, NSArray, NSSet, NSOrderedSet, or NSDictionary", EXPDescribeObject(actual)];
+    return [NSString stringWithFormat:@"expected %@ not to have a count of %zi", EXPDescribeObject(actual), expected];
+  });
+}
+EXPMatcherImplementationEnd

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+notify.h

@@ -0,0 +1,4 @@
+#import "Expecta.h"
+
+EXPMatcherInterface(notify, (id expectedNotification));
+

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+notify.m

@@ -0,0 +1,63 @@
+#import "EXPMatchers+notify.h"
+
+EXPMatcherImplementationBegin(notify, (id expected)){
+  BOOL actualIsNil = (actual == nil);
+  BOOL expectedIsNil = (expected == nil);
+  BOOL isNotification = [expected isKindOfClass:[NSNotification class]];
+  BOOL isName = [expected isKindOfClass:[NSString class]];
+  
+  __block NSString *expectedName;
+  __block BOOL expectedNotificationOccurred = NO;
+  __block id observer;
+  
+  prerequisite(^BOOL{
+    expectedNotificationOccurred = NO;
+    if (actualIsNil || expectedIsNil) return NO;
+    if (isNotification) {
+      expectedName = [expected name];
+    }else if(isName) {
+      expectedName = expected;
+    }else{
+      return NO;
+    }
+    
+    observer = [[NSNotificationCenter defaultCenter] addObserverForName:expectedName object:nil queue:nil usingBlock:^(NSNotification *note){
+      if (isNotification) {
+        expectedNotificationOccurred |= [expected isEqual:note];
+      }else{
+        expectedNotificationOccurred = YES;
+      }
+    }];
+    ((EXPBasicBlock)actual)();
+    return YES;
+  });
+  
+  match(^BOOL{
+    if(expectedNotificationOccurred) {
+      [[NSNotificationCenter defaultCenter] removeObserver:observer];
+    }
+    return expectedNotificationOccurred;
+  });
+  
+  failureMessageForTo(^NSString *{
+    if (observer) {
+      [[NSNotificationCenter defaultCenter] removeObserver:observer];
+    }
+    if(actualIsNil) return @"the actual value is nil/null";
+    if(expectedIsNil) return @"the expected value is nil/null";
+    if(!(isNotification || isName)) return @"the actual value is not a notification or string";
+    return [NSString stringWithFormat:@"expected: %@, got: none",expectedName];
+  });
+  
+  failureMessageForNotTo(^NSString *{
+    if (observer) {
+      [[NSNotificationCenter defaultCenter] removeObserver:observer];
+    }
+    if(actualIsNil) return @"the actual value is nil/null";
+    if(expectedIsNil) return @"the expected value is nil/null";
+    if(!(isNotification || isName)) return @"the actual value is not a notification or string";
+    return [NSString stringWithFormat:@"expected: none, got: %@", expectedName];
+  });
+}
+
+EXPMatcherImplementationEnd

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+raise.h

@@ -0,0 +1,4 @@
+#import "Expecta.h"
+
+EXPMatcherInterface(raise, (NSString *expectedExceptionName));
+#define raiseAny() raise(nil)

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+raise.m

@@ -0,0 +1,30 @@
+#import "EXPMatchers+raise.h"
+#import "EXPDefines.h"
+
+EXPMatcherImplementationBegin(raise, (NSString *expectedExceptionName)) {
+  __block NSException *exceptionCaught = nil;
+
+  match(^BOOL{
+    BOOL expectedExceptionCaught = NO;
+    @try {
+      ((EXPBasicBlock)actual)();
+    } @catch(NSException *e) {
+      exceptionCaught = e;
+      expectedExceptionCaught = (expectedExceptionName == nil) || [[exceptionCaught name] isEqualToString:expectedExceptionName];
+    }
+    return expectedExceptionCaught;
+  });
+
+  failureMessageForTo(^NSString *{
+    return [NSString stringWithFormat:@"expected: %@, got: %@",
+            expectedExceptionName ? expectedExceptionName : @"any exception",
+            exceptionCaught ? [exceptionCaught name] : @"no exception"];
+  });
+
+  failureMessageForNotTo(^NSString *{
+    return [NSString stringWithFormat:@"expected: %@, got: %@",
+            expectedExceptionName ? [NSString stringWithFormat:@"not %@", expectedExceptionName] : @"no exception",
+            exceptionCaught ? [exceptionCaught name] : @"no exception"];
+  });
+}
+EXPMatcherImplementationEnd

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+raiseWithReason.h

@@ -0,0 +1,3 @@
+#import "Expecta.h"
+
+EXPMatcherInterface(raiseWithReason, (NSString *expectedExceptionName, NSString *expectedReason));

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+raiseWithReason.m

@@ -0,0 +1,35 @@
+#import "EXPMatchers+raiseWithReason.h"
+#import "EXPDefines.h"
+
+EXPMatcherImplementationBegin(raiseWithReason, (NSString *expectedExceptionName, NSString *expectedReason)) {
+    __block NSException *exceptionCaught = nil;
+    
+    match(^BOOL{
+        BOOL expectedExceptionCaught = NO;
+        @try {
+            ((EXPBasicBlock)actual)();
+        } @catch(NSException *e) {
+            exceptionCaught = e;
+            expectedExceptionCaught = (((expectedExceptionName == nil) || [[exceptionCaught name] isEqualToString:expectedExceptionName]) &&
+                                       ((expectedReason == nil) || ([[exceptionCaught reason] isEqualToString:expectedReason])));
+        }
+        return expectedExceptionCaught;
+    });
+    
+    failureMessageForTo(^NSString *{
+        return [NSString stringWithFormat:@"expected: %@ (%@), got: %@ (%@)",
+                expectedExceptionName ?: @"any exception",
+                expectedReason ?: @"any reason",
+                exceptionCaught ? [exceptionCaught name] : @"no exception",
+                exceptionCaught ? [exceptionCaught reason] : @""];
+    });
+    
+    failureMessageForNotTo(^NSString *{
+        return [NSString stringWithFormat:@"expected: %@ (%@), got: %@ (%@)",
+                expectedExceptionName ? [NSString stringWithFormat:@"not %@", expectedExceptionName] : @"no exception",
+                expectedReason ? [NSString stringWithFormat:@"not '%@'", expectedReason] : @"no reason",
+                exceptionCaught ? [exceptionCaught name] : @"no exception",
+                exceptionCaught ? [exceptionCaught reason] : @"no reason"];
+    });
+}
+EXPMatcherImplementationEnd

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+respondTo.h

@@ -0,0 +1,3 @@
+#import "Expecta.h"
+
+EXPMatcherInterface(respondTo, (SEL expected));

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+respondTo.m

@@ -0,0 +1,28 @@
+#import "EXPMatchers+respondTo.h"
+#import "EXPMatcherHelpers.h"
+
+EXPMatcherImplementationBegin(respondTo, (SEL expected)) {
+  BOOL actualIsNil = (actual == nil);
+  BOOL expectedIsNull = (expected == NULL);
+
+  prerequisite (^BOOL {
+    return !(actualIsNil || expectedIsNull);
+  });
+
+  match(^BOOL {
+    return [actual respondsToSelector:expected];
+  });
+
+  failureMessageForTo(^NSString *{
+    if (actualIsNil) return @"the object is nil/null";
+    if (expectedIsNull) return @"the selector is null";
+    return [NSString stringWithFormat:@"expected: %@ to respond to %@", EXPDescribeObject(actual), NSStringFromSelector(expected)];
+  });
+
+  failureMessageForNotTo(^NSString *{
+    if (actualIsNil) return @"the object is nil/null";
+    if (expectedIsNull) return @"the selector is null";
+    return [NSString stringWithFormat:@"expected: %@ not to respond to %@", EXPDescribeObject(actual), NSStringFromSelector(expected)];
+  });
+}
+EXPMatcherImplementationEnd

data/Demo/Pods/Expecta/src/matchers/EXPMatchers.h

@@ -0,0 +1,24 @@
+#import "EXPMatchers+beNil.h"
+#import "EXPMatchers+equal.h"
+#import "EXPMatchers+beInstanceOf.h"
+#import "EXPMatchers+beKindOf.h"
+#import "EXPMatchers+beSubclassOf.h"
+#import "EXPMatchers+conformTo.h"
+#import "EXPMatchers+beTruthy.h"
+#import "EXPMatchers+beFalsy.h"
+#import "EXPMatchers+contain.h"
+#import "EXPMatchers+beSupersetOf.h"
+#import "EXPMatchers+haveCountOf.h"
+#import "EXPMatchers+beIdenticalTo.h"
+#import "EXPMatchers+beGreaterThan.h"
+#import "EXPMatchers+beGreaterThanOrEqualTo.h"
+#import "EXPMatchers+beLessThan.h"
+#import "EXPMatchers+beLessThanOrEqualTo.h"
+#import "EXPMatchers+beInTheRangeOf.h"
+#import "EXPMatchers+beCloseTo.h"
+#import "EXPMatchers+raise.h"
+#import "EXPMatchers+raiseWithReason.h"
+#import "EXPMatchers+respondTo.h"
+#import "EXPMatchers+notify.h"
+#import "EXPMatchers+beginWith.h"
+#import "EXPMatchers+endWith.h"

data/Demo/Pods/Expecta+Snapshots/EXPMatchers+FBSnapshotTest.h

@@ -0,0 +1,21 @@
+//
+//  EXPMatchers+FBSnapshotTest.h
+//  Artsy
+//
+//  Created by Daniel Doubrovkine on 1/14/14.
+//  Copyright (c) 2014 Artsy Inc. All rights reserved.
+//
+
+#import <Expecta/Expecta.h>
+
+@interface EXPExpectFBSnapshotTest : NSObject
+@end
+
+/// Set the default folder for image tests to run in
+extern void setGlobalReferenceImageDir(char *reference);
+
+EXPMatcherInterface(haveValidSnapshot, (void));
+EXPMatcherInterface(recordSnapshot, (void));
+
+EXPMatcherInterface(haveValidSnapshotNamed, (NSString *snapshot));
+EXPMatcherInterface(recordSnapshotNamed, (NSString *snapshot));