cocoapods-deintegrate 0.1.1 → 0.2.0

data/spec/fixtures/Project/Frameworks/Pods/Quick/Quick/Hooks/SuiteHooks.swift

@@ -0,0 +1,34 @@
+/**
+    A container for closures to be executed before and after all examples.
+*/
+final internal class SuiteHooks {
+    internal var befores: [BeforeSuiteClosure] = []
+    internal var beforesAlreadyExecuted = false
+
+    internal var afters: [AfterSuiteClosure] = []
+    internal var aftersAlreadyExecuted = false
+
+    internal func appendBefore(closure: BeforeSuiteClosure) {
+        befores.append(closure)
+    }
+
+    internal func appendAfter(closure: AfterSuiteClosure) {
+        afters.append(closure)
+    }
+
+    internal func executeBefores() {
+        assert(!beforesAlreadyExecuted)
+        for before in befores {
+            before()
+        }
+        beforesAlreadyExecuted = true
+    }
+
+    internal func executeAfters() {
+        assert(!aftersAlreadyExecuted)
+        for after in afters {
+            after()
+        }
+        aftersAlreadyExecuted = true
+    }
+}

data/spec/fixtures/Project/Frameworks/Pods/Quick/Quick/NSString+QCKSelectorName.h

@@ -0,0 +1,17 @@
+#import <Foundation/Foundation.h>
+
+/**
+ QuickSpec converts example names into test methods.
+ Those test methods need valid selector names, which means no whitespace,
+ control characters, etc. This category gives NSString objects an easy way
+ to replace those illegal characters with underscores.
+ */
+@interface NSString (QCKSelectorName)
+
+/**
+ Returns a string with underscores in place of all characters that cannot
+ be included in a selector (SEL) name.
+ */
+@property (nonatomic, readonly) NSString *qck_selectorName;
+
+@end

data/spec/fixtures/Project/Frameworks/Pods/Quick/Quick/NSString+QCKSelectorName.m

@@ -0,0 +1,33 @@
+#import "NSString+QCKSelectorName.h"
+
+@implementation NSString (QCKSelectorName)
+
+- (NSString *)qck_selectorName {
+    static NSMutableCharacterSet *invalidCharacters = nil;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        invalidCharacters = [NSMutableCharacterSet new];
+
+        NSCharacterSet *whitespaceCharacterSet = [NSCharacterSet whitespaceCharacterSet];
+        NSCharacterSet *newlineCharacterSet = [NSCharacterSet newlineCharacterSet];
+        NSCharacterSet *illegalCharacterSet = [NSCharacterSet illegalCharacterSet];
+        NSCharacterSet *controlCharacterSet = [NSCharacterSet controlCharacterSet];
+        NSCharacterSet *punctuationCharacterSet = [NSCharacterSet punctuationCharacterSet];
+        NSCharacterSet *nonBaseCharacterSet = [NSCharacterSet nonBaseCharacterSet];
+        NSCharacterSet *symbolCharacterSet = [NSCharacterSet symbolCharacterSet];
+
+        [invalidCharacters formUnionWithCharacterSet:whitespaceCharacterSet];
+        [invalidCharacters formUnionWithCharacterSet:newlineCharacterSet];
+        [invalidCharacters formUnionWithCharacterSet:illegalCharacterSet];
+        [invalidCharacters formUnionWithCharacterSet:controlCharacterSet];
+        [invalidCharacters formUnionWithCharacterSet:punctuationCharacterSet];
+        [invalidCharacters formUnionWithCharacterSet:nonBaseCharacterSet];
+        [invalidCharacters formUnionWithCharacterSet:symbolCharacterSet];
+    });
+
+    NSArray *validComponents = [self componentsSeparatedByCharactersInSet:invalidCharacters];
+
+    return [validComponents componentsJoinedByString:@"_"];
+}
+
+@end

data/spec/fixtures/Project/Frameworks/Pods/Quick/Quick/Quick.h

@@ -0,0 +1,13 @@
+#import <Foundation/Foundation.h>
+
+//! Project version number for Quick.
+FOUNDATION_EXPORT double QuickVersionNumber;
+
+//! Project version string for Quick.
+FOUNDATION_EXPORT const unsigned char QuickVersionString[];
+
+// In this header, you should import all the public headers of your framework using statements like #import <Quick/PublicHeader.h>
+
+#import <Quick/QuickSpec.h>
+#import <Quick/QCKDSL.h>
+#import <Quick/QuickConfiguration.h>

data/spec/fixtures/Project/Frameworks/Pods/Quick/Quick/QuickSpec.h

@@ -0,0 +1,48 @@
+#import <XCTest/XCTest.h>
+
+/**
+ QuickSpec is a base class all specs written in Quick inherit from.
+ They need to inherit from QuickSpec, a subclass of XCTestCase, in
+ order to be discovered by the XCTest framework.
+
+ XCTest automatically compiles a list of XCTestCase subclasses included
+ in the test target. It iterates over each class in that list, and creates
+ a new instance of that class for each test method. It then creates an
+ "invocation" to execute that test method. The invocation is an instance of
+ NSInvocation, which represents a single message send in Objective-C.
+ The invocation is set on the XCTestCase instance, and the test is run.
+
+ Most of the code in QuickSpec is dedicated to hooking into XCTest events.
+ First, when the spec is first loaded and before it is sent any messages,
+ the +[NSObject initialize] method is called. QuickSpec overrides this method
+ to call +[QuickSpec spec]. This builds the example group stacks and
+ registers them with Quick.World, a global register of examples.
+
+ Then, XCTest queries QuickSpec for a list of test methods. Normally, XCTest
+ automatically finds all methods whose selectors begin with the string "test".
+ However, QuickSpec overrides this default behavior by implementing the
+ +[XCTestCase testInvocations] method. This method iterates over each example
+ registered in Quick.World, defines a new method for that example, and
+ returns an invocation to call that method to XCTest. Those invocations are
+ the tests that are run by XCTest. Their selector names are displayed in
+ the Xcode test navigation bar.
+ */
+@interface QuickSpec : XCTestCase
+
+/**
+ Override this method in your spec to define a set of example groups
+ and examples.
+
+     override class func spec() {
+         describe("winter") {
+             it("is coming") {
+                 // ...
+             }
+         }
+     }
+
+ See DSL.swift for more information on what syntax is available.
+ */
+- (void)spec;
+
+@end

data/spec/fixtures/Project/Frameworks/Pods/Quick/Quick/QuickSpec.m

@@ -0,0 +1,142 @@
+#import "QuickSpec.h"
+#import "QuickConfiguration.h"
+#import "NSString+QCKSelectorName.h"
+#import <Quick/Quick-Swift.h>
+#import <objc/runtime.h>
+
+const void * const QCKExampleKey = &QCKExampleKey;
+
+@interface QuickSpec ()
+@property (nonatomic, strong) Example *example;
+@end
+
+@implementation QuickSpec
+
+#pragma mark - XCTestCase Overrides
+
+/**
+ The runtime sends initialize to each class in a program just before the class, or any class
+ that inherits from it, is sent its first message from within the program. QuickSpec hooks into
+ this event to compile the example groups for this spec subclass.
+
+ If an exception occurs when compiling the examples, report it to the user. Chances are they
+ included an expectation outside of a "it", "describe", or "context" block.
+ */
++ (void)initialize {
+    [QuickConfiguration initialize];
+
+    World *world = [World sharedWorld];
+    world.currentExampleGroup = [world rootExampleGroupForSpecClass:[self class]];
+    QuickSpec *spec = [self new];
+
+    @try {
+        [spec spec];
+    }
+    @catch (NSException *exception) {
+        [NSException raise:NSInternalInconsistencyException
+                    format:@"An exception occurred when building Quick's example groups.\n"
+                           @"Some possible reasons this might happen include:\n\n"
+                           @"- An 'expect(...).to' expectation was evaluated outside of "
+                           @"an 'it', 'context', or 'describe' block\n"
+                           @"- 'sharedExamples' was called twice with the same name\n"
+                           @"- 'itBehavesLike' was called with a name that is not registered as a shared example\n\n"
+                           @"Here's the original exception: '%@', reason: '%@', userInfo: '%@'",
+                           exception.name, exception.reason, exception.userInfo];
+    }
+}
+
+/**
+ Invocations for each test method in the test case. QuickSpec overrides this method to define a
+ new method for each example defined in +[QuickSpec spec].
+
+ @return An array of invocations that execute the newly defined example methods.
+ */
++ (NSArray *)testInvocations {
+    NSArray *examples = [[World sharedWorld] examplesForSpecClass:[self class]];
+    NSMutableArray *invocations = [NSMutableArray arrayWithCapacity:[examples count]];
+    for (Example *example in examples) {
+        SEL selector = [self addInstanceMethodForExample:example];
+        NSInvocation *invocation = [self invocationForInstanceMethodWithSelector:selector
+                                                                         example:example];
+        [invocations addObject:invocation];
+    }
+
+    return invocations;
+}
+
+/**
+ XCTest sets the invocation for the current test case instance using this setter.
+ QuickSpec hooks into this event to give the test case a reference to the current example.
+ It will need this reference to correctly report its name to XCTest.
+ */
+- (void)setInvocation:(NSInvocation *)invocation {
+    self.example = objc_getAssociatedObject(invocation, QCKExampleKey);
+    [super setInvocation:invocation];
+}
+
+#pragma mark - Public Interface
+
+- (void)spec { }
+
+#pragma mark - Internal Methods
+
+/**
+ QuickSpec uses this method to dynamically define a new instance method for the
+ given example. The instance method runs the example, catching any exceptions.
+ The exceptions are then reported as test failures.
+
+ In order to report the correct file and line number, examples must raise exceptions
+ containing following keys in their userInfo:
+
+ - "SenTestFilenameKey": A String representing the file name
+ - "SenTestLineNumberKey": An Int representing the line number
+
+ These keys used to be used by SenTestingKit, and are still used by some testing tools
+ in the wild. See: https://github.com/Quick/Quick/pull/41
+
+ @return The selector of the newly defined instance method.
+ */
++ (SEL)addInstanceMethodForExample:(Example *)example {
+    IMP implementation = imp_implementationWithBlock(^(id self){
+        [example run];
+    });
+    const char *types = [[NSString stringWithFormat:@"%s%s%s", @encode(id), @encode(id), @encode(SEL)] UTF8String];
+    SEL selector = NSSelectorFromString(example.name.qck_selectorName);
+    class_addMethod(self, selector, implementation, types);
+
+    return selector;
+}
+
++ (NSInvocation *)invocationForInstanceMethodWithSelector:(SEL)selector
+                                                  example:(Example *)example {
+    NSMethodSignature *signature = [self instanceMethodSignatureForSelector:selector];
+    NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:signature];
+    invocation.selector = selector;
+    objc_setAssociatedObject(invocation,
+                             QCKExampleKey,
+                             example,
+                             OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+    return invocation;
+}
+
+/**
+ This method is used to record failures, whether they represent example
+ expectations that were not met, or exceptions raised during test setup
+ and teardown. By default, the failure will be reported as an
+ XCTest failure, and the example will be highlighted in Xcode.
+ */
+- (void)recordFailureWithDescription:(NSString *)description
+                              inFile:(NSString *)filePath
+                              atLine:(NSUInteger)lineNumber
+                            expected:(BOOL)expected {
+    if (self.example.isSharedExample) {
+        filePath = self.example.callsite.file;
+        lineNumber = self.example.callsite.line;
+    }
+    [super recordFailureWithDescription:description
+                                 inFile:filePath
+                                 atLine:lineNumber
+                               expected:expected];
+}
+
+@end

data/spec/fixtures/Project/Frameworks/Pods/Quick/Quick/World.swift

@@ -0,0 +1,197 @@
+import Foundation
+
+/**
+    A closure that, when evaluated, returns a dictionary of key-value
+    pairs that can be accessed from within a group of shared examples.
+*/
+public typealias SharedExampleContext = () -> (NSDictionary)
+
+/**
+    A closure that is used to define a group of shared examples. This
+    closure may contain any number of example and example groups.
+*/
+public typealias SharedExampleClosure = (SharedExampleContext) -> ()
+
+/**
+    A collection of state Quick builds up in order to work its magic.
+    World is primarily responsible for maintaining a mapping of QuickSpec
+    classes to root example groups for those classes.
+
+    It also maintains a mapping of shared example names to shared
+    example closures.
+
+    You may configure how Quick behaves by calling the -[World configure:]
+    method from within an overridden +[QuickConfiguration configure:] method.
+*/
+@objc final public class World {
+    /**
+        The example group that is currently being run.
+        The DSL requires that this group is correctly set in order to build a
+        correct hierarchy of example groups and their examples.
+    */
+    public var currentExampleGroup: ExampleGroup?
+
+    /**
+        The example metadata of the test that is currently being run.
+        This is useful for using the Quick test metadata (like its name) at
+        runtime.
+    */
+
+    public var currentExampleMetadata: ExampleMetadata?
+
+    /**
+        A flag that indicates whether additional test suites are being run
+        within this test suite. This is only true within the context of Quick
+        functional tests.
+    */
+    public var isRunningAdditionalSuites = false
+
+    private var specs: Dictionary<String, ExampleGroup> = [:]
+    private var sharedExamples: [String: SharedExampleClosure] = [:]
+    private let configuration = Configuration()
+    private var isConfigurationFinalized = false
+
+    internal var exampleHooks: ExampleHooks {return configuration.exampleHooks }
+    internal var suiteHooks: SuiteHooks { return configuration.suiteHooks }
+
+    // MARK: Singleton Constructor
+
+    private init() {}
+    private struct Shared {
+        static let instance = World()
+    }
+    public class func sharedWorld() -> World {
+        return Shared.instance
+    }
+
+    // MARK: Public Interface
+
+    /**
+        Exposes the World's Configuration object within the scope of the closure
+        so that it may be configured. This method must not be called outside of
+        an overridden +[QuickConfiguration configure:] method.
+
+        :param: closure  A closure that takes a Configuration object that can
+                         be mutated to change Quick's behavior.
+    */
+    public func configure(closure: QuickConfigurer) {
+        assert(!isConfigurationFinalized,
+               "Quick cannot be configured outside of a +[QuickConfiguration configure:] method. You should not call -[World configure:] directly. Instead, subclass QuickConfiguration and override the +[QuickConfiguration configure:] method.")
+        closure(configuration: configuration)
+    }
+
+    /**
+        Finalizes the World's configuration.
+        Any subsequent calls to World.configure() will raise.
+    */
+    public func finalizeConfiguration() {
+        isConfigurationFinalized = true
+    }
+
+    /**
+        Returns an internally constructed root example group for the given
+        QuickSpec class.
+
+        A root example group with the description "root example group" is lazily
+        initialized for each QuickSpec class. This root example group wraps the
+        top level of a -[QuickSpec spec] method--it's thanks to this group that
+        users can define beforeEach and it closures at the top level, like so:
+
+            override func spec() {
+                // These belong to the root example group
+                beforeEach {}
+                it("is at the top level") {}
+            }
+
+        :param: cls The QuickSpec class for which to retrieve the root example group.
+        :returns: The root example group for the class.
+    */
+    public func rootExampleGroupForSpecClass(cls: AnyClass) -> ExampleGroup {
+        let name = NSStringFromClass(cls)
+        if let group = specs[name] {
+            return group
+        } else {
+            let group = ExampleGroup(
+                description: "root example group",
+                flags: [:],
+                isInternalRootExampleGroup: true
+            )
+            specs[name] = group
+            return group
+        }
+    }
+
+    /**
+        Returns all examples that should be run for a given spec class.
+        There are two filtering passes that occur when determining which examples should be run.
+        That is, these examples are the ones that are included by inclusion filters, and are
+        not excluded by exclusion filters.
+
+        :param: specClass The QuickSpec subclass for which examples are to be returned.
+        :returns: A list of examples to be run as test invocations.
+    */
+    @objc(examplesForSpecClass:)
+    public func examples(specClass: AnyClass) -> [Example] {
+        // 1. Grab all included examples.
+        let included = includedExamples
+        // 2. Grab the intersection of (a) examples for this spec, and (b) included examples.
+        let spec = rootExampleGroupForSpecClass(specClass).examples.filter { contains(included, $0) }
+        // 3. Remove all excluded examples.
+        return spec.filter { example in
+            !self.configuration.exclusionFilters.reduce(false) { $0 || $1(example: example) }
+        }
+    }
+
+    // MARK: Internal
+
+    internal func registerSharedExample(name: String, closure: SharedExampleClosure) {
+        raiseIfSharedExampleAlreadyRegistered(name)
+        sharedExamples[name] = closure
+    }
+
+    internal func sharedExample(name: String) -> SharedExampleClosure {
+        raiseIfSharedExampleNotRegistered(name)
+        return sharedExamples[name]!
+    }
+
+    internal var exampleCount: Int {
+        return allExamples.count
+    }
+
+    private var allExamples: [Example] {
+        var all: [Example] = []
+        for (_, group) in specs {
+            group.walkDownExamples { all.append($0) }
+        }
+        return all
+    }
+
+    private var includedExamples: [Example] {
+        let all = allExamples
+        let included = all.filter { example in
+            return self.configuration.inclusionFilters.reduce(false) { $0 || $1(example: example) }
+        }
+
+        if included.isEmpty && configuration.runAllWhenEverythingFiltered {
+            return all
+        } else {
+            return included
+        }
+    }
+
+    private func raiseIfSharedExampleAlreadyRegistered(name: String) {
+        if sharedExamples[name] != nil {
+            NSException(name: NSInternalInconsistencyException,
+                reason: "A shared example named '\(name)' has already been registered.",
+                userInfo: nil).raise()
+        }
+    }
+
+    private func raiseIfSharedExampleNotRegistered(name: String) {
+        if sharedExamples[name] == nil {
+            NSException(name: NSInternalInconsistencyException,
+                reason: "No shared example named '\(name)' has been registered. Registered shared examples: '\(Array(sharedExamples.keys))'",
+                userInfo: nil).raise()
+        }
+    }
+}