cocoapods-deintegrate 0.2.1 → 1.0.0.beta.1

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

@@ -1,34 +0,0 @@
-/**
-    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

@@ -1,17 +0,0 @@
-#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

@@ -1,33 +0,0 @@
-#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

@@ -1,13 +0,0 @@
-#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

@@ -1,48 +0,0 @@
-#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

@@ -1,142 +0,0 @@
-#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

@@ -1,197 +0,0 @@
-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()
-        }
-    }
-}