cocoapods-deintegrate 0.1.1 → 0.2.0

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

@@ -0,0 +1,100 @@
+/**
+    Adds methods to World to support top-level DSL functions (Swift) and
+    macros (Objective-C). These functions map directly to the DSL that test
+    writers use in their specs.
+*/
+extension World {
+    public func beforeSuite(closure: BeforeSuiteClosure) {
+        suiteHooks.appendBefore(closure)
+    }
+
+    public func afterSuite(closure: AfterSuiteClosure) {
+        suiteHooks.appendAfter(closure)
+    }
+
+    public func sharedExamples(name: String, closure: SharedExampleClosure) {
+        registerSharedExample(name, closure: closure)
+    }
+
+    public func describe(description: String, closure: () -> (), flags: FilterFlags) {
+        var group = ExampleGroup(description: description, flags: flags)
+        currentExampleGroup!.appendExampleGroup(group)
+        currentExampleGroup = group
+        closure()
+        currentExampleGroup = group.parent
+    }
+
+    public func context(description: String, closure: () -> (), flags: FilterFlags) {
+        self.describe(description, closure: closure, flags: flags)
+    }
+
+    public func fdescribe(description: String, closure: () -> (), flags: FilterFlags) {
+        var focusedFlags = flags
+        focusedFlags[Filter.focused] = true
+        self.describe(description, closure: closure, flags: focusedFlags)
+    }
+
+    public func xdescribe(description: String, closure: () -> (), flags: FilterFlags) {
+        var pendingFlags = flags
+        pendingFlags[Filter.pending] = true
+        self.describe(description, closure: closure, flags: pendingFlags)
+    }
+
+    public func beforeEach(closure: BeforeExampleClosure) {
+        currentExampleGroup!.hooks.appendBefore(closure)
+    }
+
+    public func beforeEach(#closure: BeforeExampleWithMetadataClosure) {
+        currentExampleGroup!.hooks.appendBefore(closure)
+    }
+
+    public func afterEach(closure: AfterExampleClosure) {
+        currentExampleGroup!.hooks.appendAfter(closure)
+    }
+
+    public func afterEach(#closure: AfterExampleWithMetadataClosure) {
+        currentExampleGroup!.hooks.appendAfter(closure)
+    }
+
+    @objc(itWithDescription:flags:file:line:closure:)
+    public func it(description: String, flags: FilterFlags, file: String, line: Int, closure: () -> ()) {
+        let callsite = Callsite(file: file, line: line)
+        let example = Example(description: description, callsite: callsite, flags: flags, closure)
+        currentExampleGroup!.appendExample(example)
+    }
+
+    @objc(fitWithDescription:flags:file:line:closure:)
+    public func fit(description: String, flags: FilterFlags, file: String, line: Int, closure: () -> ()) {
+        var focusedFlags = flags
+        focusedFlags[Filter.focused] = true
+        self.it(description, flags: focusedFlags, file: file, line: line, closure: closure)
+    }
+
+    @objc(xitWithDescription:flags:file:line:closure:)
+    public func xit(description: String, flags: FilterFlags, file: String, line: Int, closure: () -> ()) {
+        var pendingFlags = flags
+        pendingFlags[Filter.pending] = true
+        self.it(description, flags: pendingFlags, file: file, line: line, closure: closure)
+    }
+
+    @objc(itBehavesLikeSharedExampleNamed:sharedExampleContext:flags:file:line:)
+    public func itBehavesLike(name: String, sharedExampleContext: SharedExampleContext, flags: FilterFlags, file: String, line: Int) {
+        let callsite = Callsite(file: file, line: line)
+        let closure = World.sharedWorld().sharedExample(name)
+
+        var group = ExampleGroup(description: name, flags: flags)
+        currentExampleGroup!.appendExampleGroup(group)
+        currentExampleGroup = group
+        closure(sharedExampleContext)
+        currentExampleGroup!.walkDownExamples { (example: Example) in
+            example.isSharedExample = true
+            example.callsite = callsite
+        }
+
+        currentExampleGroup = group.parent
+    }
+
+    public func pending(description: String, closure: () -> ()) {
+        NSLog("Pending: %@", description)
+    }
+}

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

@@ -0,0 +1,103 @@
+private var numberOfExamplesRun = 0
+
+/**
+    Examples, defined with the `it` function, use assertions to
+    demonstrate how code should behave. These are like "tests" in XCTest.
+*/
+@objc final public class Example: Equatable {
+    /**
+        A boolean indicating whether the example is a shared example;
+        i.e.: whether it is an example defined with `itBehavesLike`.
+    */
+    public var isSharedExample = false
+
+    /**
+        The site at which the example is defined.
+        This must be set correctly in order for Xcode to highlight
+        the correct line in red when reporting a failure.
+    */
+    public var callsite: Callsite
+
+    weak internal var group: ExampleGroup?
+
+    private let description: String
+    private let closure: () -> ()
+    private let flags: FilterFlags
+
+    internal init(description: String, callsite: Callsite, flags: FilterFlags, closure: () -> ()) {
+        self.description = description
+        self.closure = closure
+        self.callsite = callsite
+        self.flags = flags
+    }
+
+    /**
+        The example name. A name is a concatenation of the name of
+        the example group the example belongs to, followed by the
+        description of the example itself.
+
+        The example name is used to generate a test method selector
+        to be displayed in Xcode's test navigator.
+    */
+    public var name: String {
+        switch group!.name {
+        case .Some(let groupName): return "\(groupName), \(description)"
+        case .None: return description
+        }
+    }
+
+    /**
+        Executes the example closure, as well as all before and after
+        closures defined in the its surrounding example groups.
+    */
+    public func run() {
+        let world = World.sharedWorld()
+
+        if numberOfExamplesRun == 0 {
+            world.suiteHooks.executeBefores()
+        }
+
+        let exampleMetadata = ExampleMetadata(example: self, exampleIndex: numberOfExamplesRun)
+        world.currentExampleMetadata = exampleMetadata
+
+        world.exampleHooks.executeBefores(exampleMetadata)
+        for before in group!.befores {
+            before(exampleMetadata: exampleMetadata)
+        }
+
+        closure()
+
+        for after in group!.afters {
+            after(exampleMetadata: exampleMetadata)
+        }
+        world.exampleHooks.executeAfters(exampleMetadata)
+
+        ++numberOfExamplesRun
+
+        if !world.isRunningAdditionalSuites && numberOfExamplesRun >= world.exampleCount {
+            world.suiteHooks.executeAfters()
+        }
+    }
+
+    /**
+        Evaluates the filter flags set on this example and on the example groups
+        this example belongs to. Flags set on the example are trumped by flags on
+        the example group it belongs to. Flags on inner example groups are trumped
+        by flags on outer example groups.
+    */
+    internal var filterFlags: FilterFlags {
+        var aggregateFlags = flags
+        for (key, value) in group!.filterFlags {
+            aggregateFlags[key] = value
+        }
+        return aggregateFlags
+    }
+}
+
+/**
+    Returns a boolean indicating whether two Example objects are equal.
+    If two examples are defined at the exact same callsite, they must be equal.
+*/
+public func ==(lhs: Example, rhs: Example) -> Bool {
+    return lhs.callsite == rhs.callsite
+}

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

@@ -0,0 +1,97 @@
+/**
+    Example groups are logical groupings of examples, defined with
+    the `describe` and `context` functions. Example groups can share
+    setup and teardown code.
+*/
+@objc final public class ExampleGroup {
+    weak internal var parent: ExampleGroup?
+    internal let hooks = ExampleHooks()
+
+    private let description: String
+    private let flags: FilterFlags
+    private let isInternalRootExampleGroup: Bool
+    private var childGroups = [ExampleGroup]()
+    private var childExamples = [Example]()
+
+    internal init(description: String, flags: FilterFlags, isInternalRootExampleGroup: Bool = false) {
+        self.description = description
+        self.flags = flags
+        self.isInternalRootExampleGroup = isInternalRootExampleGroup
+    }
+
+    /**
+        Returns a list of examples that belong to this example group,
+        or to any of its descendant example groups.
+    */
+    public var examples: [Example] {
+        var examples = childExamples
+        for group in childGroups {
+            examples.extend(group.examples)
+        }
+        return examples
+    }
+
+    internal var name: String? {
+        if let parent = parent {
+            switch(parent.name) {
+            case .Some(let name): return "\(name), \(description)"
+            case .None: return description
+            }
+        } else {
+            return isInternalRootExampleGroup ? nil : description
+        }
+    }
+
+    internal var filterFlags: FilterFlags {
+        var aggregateFlags = flags
+        walkUp() { (group: ExampleGroup) -> () in
+            for (key, value) in group.flags {
+                aggregateFlags[key] = value
+            }
+        }
+        return aggregateFlags
+    }
+
+    internal var befores: [BeforeExampleWithMetadataClosure] {
+        var closures = hooks.befores.reverse()
+        walkUp() { (group: ExampleGroup) -> () in
+            closures.extend(group.hooks.befores.reverse())
+        }
+        return closures.reverse()
+    }
+
+    internal var afters: [AfterExampleWithMetadataClosure] {
+        var closures = hooks.afters
+        walkUp() { (group: ExampleGroup) -> () in
+            closures.extend(group.hooks.afters)
+        }
+        return closures
+    }
+
+    internal func walkDownExamples(callback: (example: Example) -> ()) {
+        for example in childExamples {
+            callback(example: example)
+        }
+        for group in childGroups {
+            group.walkDownExamples(callback)
+        }
+    }
+
+    internal func appendExampleGroup(group: ExampleGroup) {
+        group.parent = self
+        childGroups.append(group)
+    }
+
+    internal func appendExample(example: Example) {
+        example.group = self
+        childExamples.append(example)
+    }
+
+    private func walkUp(callback: (group: ExampleGroup) -> ()) {
+        var group = self
+        while let parent = group.parent {
+            callback(group: parent)
+            group = parent
+        }
+    }
+}

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

@@ -0,0 +1,22 @@
+/**
+    A class that encapsulates information about an example,
+    including the index at which the example was executed, as
+    well as the example itself.
+*/
+@objc final public class ExampleMetadata {
+    /**
+        The example for which this metadata was collected.
+    */
+    public let example: Example
+
+    /**
+        The index at which this example was executed in the
+        test suite.
+    */
+    public let exampleIndex: Int
+
+    internal init(example: Example, exampleIndex: Int) {
+        self.example = example
+        self.exampleIndex = exampleIndex
+    }
+}

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

@@ -0,0 +1,16 @@
+import Foundation
+
+@objc final class Failure {
+    let callsite: Callsite
+    let exception: NSException
+
+    init(exception: NSException, callsite: Callsite) {
+        self.exception = exception
+        self.callsite = callsite
+    }
+
+    @objc(failureWithException:callsite:)
+    class func failure(exception: NSException, callsite: Callsite) -> Failure {
+        return Failure(exception: exception, callsite: callsite)
+    }
+}

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

@@ -0,0 +1,29 @@
+/**
+    A mapping of string keys to booleans that can be used to
+    filter examples or example groups. For example, a "focused"
+    example would have the flags [Focused: true].
+*/
+public typealias FilterFlags = [String: Bool]
+
+/**
+    A namespace for filter flag keys, defined primarily to make the
+    keys available in Objective-C.
+*/
+@objc(QCKFilter) final public class Filter {
+    /**
+        Example and example groups with [Focused: true] are included in test runs,
+        excluding all other examples without this flag. Use this to only run one or
+        two tests that you're currently focusing on.
+    */
+    public class var focused: String {
+        return "focused"
+    }
+
+    /**
+        Example and example groups with [Pending: true] are excluded from test runs.
+        Use this to temporarily suspend examples that you know do not pass yet.
+    */
+    public class var pending: String {
+        return "pending"
+    }
+}

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

@@ -0,0 +1,35 @@
+// MARK: Example Hooks
+
+/**
+    A closure executed before an example is run.
+*/
+public typealias BeforeExampleClosure = () -> ()
+
+/**
+    A closure executed before an example is run. The closure is given example metadata,
+    which contains information about the example that is about to be run.
+*/
+public typealias BeforeExampleWithMetadataClosure = (exampleMetadata: ExampleMetadata) -> ()
+
+/**
+    A closure executed after an example is run.
+*/
+public typealias AfterExampleClosure = BeforeExampleClosure
+
+/**
+    A closure executed after an example is run. The closure is given example metadata,
+    which contains information about the example that has just finished running.
+*/
+public typealias AfterExampleWithMetadataClosure = BeforeExampleWithMetadataClosure
+
+// MARK: Suite Hooks
+
+/**
+    A closure executed before any examples are run.
+*/
+public typealias BeforeSuiteClosure = () -> ()
+
+/**
+    A closure executed after all examples have finished running.
+*/
+public typealias AfterSuiteClosure = BeforeSuiteClosure

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

@@ -0,0 +1,36 @@
+/**
+    A container for closures to be executed before and after each example.
+*/
+final internal class ExampleHooks {
+
+    internal var befores: [BeforeExampleWithMetadataClosure] = []
+    internal var afters: [AfterExampleWithMetadataClosure] = []
+
+    internal func appendBefore(closure: BeforeExampleWithMetadataClosure) {
+        befores.append(closure)
+    }
+
+    internal func appendBefore(closure: BeforeExampleClosure) {
+        befores.append { (exampleMetadata: ExampleMetadata) in closure() }
+    }
+
+    internal func appendAfter(closure: AfterExampleWithMetadataClosure) {
+        afters.append(closure)
+    }
+
+    internal func appendAfter(closure: AfterExampleClosure) {
+        afters.append { (exampleMetadata: ExampleMetadata) in closure() }
+    }
+
+    internal func executeBefores(exampleMetadata: ExampleMetadata) {
+        for before in befores {
+            before(exampleMetadata: exampleMetadata)
+        }
+    }
+
+    internal func executeAfters(exampleMetadata: ExampleMetadata) {
+        for after in afters {
+            after(exampleMetadata: exampleMetadata)
+        }
+    }
+}