cocoapods-deintegrate 0.1.1 → 0.2.0

data/spec/fixtures/Project/Frameworks/Pods/QueryKit/QueryKit/ObjectiveC/QKQuerySet.swift

@@ -0,0 +1,28 @@
+import Foundation
+
+extension QuerySet {
+    public func asQKQuerySet() -> QKQuerySet {
+        let entityDescription = NSEntityDescription.entityForName(entityName, inManagedObjectContext: context)
+
+        var nsrange:NSRange = NSMakeRange(NSNotFound, NSNotFound)
+        if let range = self.range {
+            nsrange = NSMakeRange(range.startIndex, range.endIndex - range.startIndex)
+        }
+
+        return QKQuerySet(managedObjectContext: context, entityDescription: entityDescription, predicate: predicate, sortDescriptors: sortDescriptors, range:nsrange)
+    }
+}
+
+extension QKQuerySet {
+    public func asQuerySet() -> QuerySet<NSManagedObject> {
+        let queryset = QuerySet<NSManagedObject>(managedObjectContext, entityDescription.name!)
+            .orderBy(sortDescriptors as [NSSortDescriptor])
+            .filter(predicate)
+
+        if range.location != NSNotFound {
+            return queryset[range.location..<(range.location + range.length)]
+        }
+
+        return queryset
+    }
+}

data/spec/fixtures/Project/Frameworks/Pods/QueryKit/QueryKit/Predicate.swift

@@ -0,0 +1,21 @@
+//
+//  Predicate.swift
+//  QueryKit
+//
+//  Created by Kyle Fuller on 19/06/2014.
+//
+//
+
+import Foundation
+
+public func && (left: NSPredicate, right: NSPredicate) -> NSPredicate {
+    return NSCompoundPredicate(type: NSCompoundPredicateType.AndPredicateType, subpredicates: [left, right])
+}
+
+public func || (left: NSPredicate, right: NSPredicate) -> NSPredicate {
+    return NSCompoundPredicate(type: NSCompoundPredicateType.OrPredicateType, subpredicates: [left, right])
+}
+
+prefix public func ! (left: NSPredicate) -> NSPredicate {
+    return NSCompoundPredicate(type: NSCompoundPredicateType.NotPredicateType, subpredicates: [left])
+}

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

@@ -0,0 +1,19 @@
+//
+//  QueryKit.h
+//  QueryKit
+//
+//  Created by Kyle Fuller on 19/06/2014.
+//
+//
+
+#import <Foundation/Foundation.h>
+
+//! Project version number for QueryKit.
+FOUNDATION_EXPORT double QueryKitVersionNumber;
+
+//! Project version string for QueryKit.
+FOUNDATION_EXPORT const unsigned char QueryKitVersionString[];
+
+// In this header, you should import all the public headers of your framework using statements like #import <QueryKit/PublicHeader.h>
+#import <QueryKit/QKAttribute.h>
+#import <QueryKit/QKQuerySet.h>

data/spec/fixtures/Project/Frameworks/Pods/QueryKit/QueryKit/QuerySet.swift

@@ -0,0 +1,237 @@
+//
+//  QuerySet.swift
+//  QueryKit
+//
+//  Created by Kyle Fuller on 06/07/2014.
+//
+//
+
+import Foundation
+import CoreData
+
+
+/// Represents a lazy database lookup for a set of objects.
+public class QuerySet<T : NSManagedObject> : SequenceType, Equatable {
+    /// Returns the managed object context that will be used to execute any requests.
+    public let context:NSManagedObjectContext
+
+    /// Returns the name of the entity the request is configured to fetch.
+    public let entityName:String
+
+    /// Returns the sort descriptors of the receiver.
+    public let sortDescriptors = [NSSortDescriptor]()
+
+    /// Returns the predicate of the receiver.
+    public let predicate:NSPredicate?
+
+    public let range:Range<Int>?
+
+    // MARK: Initialization
+
+    public init(_ context:NSManagedObjectContext, _ entityName:String) {
+        self.context = context
+        self.entityName = entityName
+    }
+
+    public init(queryset:QuerySet<T>, sortDescriptors:[NSSortDescriptor]?, predicate:NSPredicate?, range:Range<Int>?) {
+        self.context = queryset.context
+        self.entityName = queryset.entityName
+
+        if let sortDescriptors = sortDescriptors {
+            self.sortDescriptors = sortDescriptors
+        }
+
+        self.predicate = predicate
+        self.range = range
+    }
+
+    // MARK: Sorting
+
+    /// Returns a new QuerySet containing objects ordered by the given sort descriptor.
+    public func orderBy(sortDescriptor:NSSortDescriptor) -> QuerySet<T> {
+        return orderBy([sortDescriptor])
+    }
+
+    /// Returns a new QuerySet containing objects ordered by the given sort descriptors.
+    public func orderBy(sortDescriptors:[NSSortDescriptor]) -> QuerySet<T> {
+        return QuerySet(queryset:self, sortDescriptors:sortDescriptors, predicate:predicate, range:range)
+    }
+
+    /// Reverses the ordering of the QuerySet
+    public func reverse() -> QuerySet<T> {
+        return QuerySet(queryset:self, sortDescriptors:sortDescriptors.reverse(), predicate:predicate, range:range)
+    }
+
+    // MARK: Filtering
+
+    /// Returns a new QuerySet containing objects that match the given predicate.
+    public func filter(predicate:NSPredicate) -> QuerySet<T> {
+        var futurePredicate = predicate
+
+        if let existingPredicate = self.predicate {
+            futurePredicate = NSCompoundPredicate(type: NSCompoundPredicateType.AndPredicateType, subpredicates: [existingPredicate, predicate])
+        }
+
+        return QuerySet(queryset:self, sortDescriptors:sortDescriptors, predicate:futurePredicate, range:range)
+    }
+
+    /// Returns a new QuerySet containing objects that match the given predicates.
+    public func filter(predicates:[NSPredicate]) -> QuerySet<T> {
+        let newPredicate = NSCompoundPredicate(type: NSCompoundPredicateType.AndPredicateType, subpredicates: predicates)
+        return filter(newPredicate)
+    }
+
+    /// Returns a new QuerySet containing objects that exclude the given predicate.
+    public func exclude(predicate:NSPredicate) -> QuerySet<T> {
+        let excludePredicate = NSCompoundPredicate(type: NSCompoundPredicateType.NotPredicateType, subpredicates: [predicate])
+        return filter(excludePredicate)
+    }
+
+    /// Returns a new QuerySet containing objects that exclude the given predicates.
+    public func exclude(predicates:[NSPredicate]) -> QuerySet<T> {
+        let excludePredicate = NSCompoundPredicate(type: NSCompoundPredicateType.AndPredicateType, subpredicates: predicates)
+        return exclude(excludePredicate)
+    }
+
+    // MARK: Subscripting
+
+    public subscript(index: Int) -> (object:T?, error:NSError?) {
+        get {
+            var request = fetchRequest
+            request.fetchOffset = index
+            request.fetchLimit = 1
+
+            var error:NSError?
+            if let items = context.executeFetchRequest(request, error:&error) {
+              return (object:items.first as T?, error:error)
+            } else {
+              return (object: nil, error: error)
+            }
+        }
+    }
+
+    /// Returns the object at the specified index.
+    public subscript(index: Int) -> T? {
+        get {
+            return self[index].object
+        }
+    }
+
+    public subscript(range:Range<Int>) -> QuerySet<T> {
+        get {
+            var fullRange = range
+
+            if let currentRange = self.range {
+                fullRange = Range<Int>(start: currentRange.startIndex + range.startIndex, end:  range.endIndex)
+            }
+
+            return QuerySet(queryset:self, sortDescriptors:sortDescriptors, predicate:predicate, range:fullRange)
+        }
+    }
+  
+    // Mark: Getters
+    public var first: T? {
+      get {
+        return self[0].object
+      }
+    }
+  
+
+    // MARK: Conversion
+
+    public var fetchRequest:NSFetchRequest {
+        var request = NSFetchRequest(entityName:entityName)
+        request.predicate = predicate
+        request.sortDescriptors = sortDescriptors
+
+        if let range = range {
+            request.fetchOffset = range.startIndex
+            request.fetchLimit = range.endIndex - range.startIndex
+        }
+
+        return request
+    }
+
+    public func array() -> (objects:([T]?), error:NSError?) {
+        var error:NSError?
+        var objects = context.executeFetchRequest(fetchRequest, error:&error) as? [T]
+        return (objects:objects, error:error)
+    }
+
+    public func array() -> [T]? {
+        return array().objects
+    }
+
+    // MARK: Count
+
+    public func count() -> (count:Int?, error:NSError?) {
+        var error:NSError?
+        var count:Int? = context.countForFetchRequest(fetchRequest, error: &error)
+
+        if count! == NSNotFound {
+            count = nil
+        }
+
+        return (count:count, error:error)
+    }
+
+    /// Returns the count of objects matching the QuerySet.
+    public func count() -> Int? {
+        return count().count
+    }
+
+    // MARK: Exists
+
+    /** Returns true if the QuerySet contains any results, and false if not.
+    :note: Returns nil if the operation could not be completed.
+    */
+    public func exists() -> Bool? {
+        let result:Int? = count()
+
+        if let result = result {
+            return result > 0
+        }
+
+        return nil
+    }
+
+    // MARK: Deletion
+
+    /// Deletes all the objects matching the QuerySet.
+    public func delete() -> (count:Int, error:NSError?) {
+        var result = array() as (objects:([T]?), error:NSError?)
+        var deletedCount = 0
+
+        if let objects = result.objects {
+            for object in objects {
+                context.deleteObject(object)
+            }
+
+            deletedCount = objects.count
+        }
+
+        return (count:deletedCount, error:result.error)
+    }
+
+    // MARK: Sequence
+
+    public func generate() -> IndexingGenerator<Array<T>> {
+        var result = self.array() as (objects:([T]?), error:NSError?)
+        
+        if let objects = result.objects {
+            return objects.generate()
+        }
+        
+        return [].generate()
+    }
+}
+
+public func == <T : NSManagedObject>(lhs: QuerySet<T>, rhs: QuerySet<T>) -> Bool {
+    let context = lhs.context == rhs.context
+    let entityName = lhs.entityName == rhs.entityName
+    let sortDescriptors = lhs.sortDescriptors == rhs.sortDescriptors
+    let predicate = lhs.predicate == rhs.predicate
+    let startIndex = lhs.range?.startIndex == rhs.range?.startIndex
+    let endIndex = lhs.range?.endIndex == rhs.range?.endIndex
+    return context && entityName && sortDescriptors && predicate && startIndex && endIndex
+}

data/spec/fixtures/Project/Frameworks/Pods/QueryKit/README.md

@@ -0,0 +1,151 @@
+QueryKit
+========
+
+[![Build Status](http://img.shields.io/travis/QueryKit/QueryKit/master.svg?style=flat)](https://travis-ci.org/QueryKit/QueryKit)
+
+QueryKit, a simple CoreData query language.
+
+## Usage
+
+```swift
+Person.queryset(context).filter(Person.name == "Kyle").delete()
+```
+
+### Querying
+
+To retrieve objects from CoreData with QueryKit, you can construct a QuerySet
+for your model in a managed object context.
+
+A queryset is an immutable object, any operation will return a new queryset
+instead of modifying the queryset.
+
+```swift
+var queryset = Person.queryset(context)
+```
+
+#### Filtering
+
+You can filter a queryset using the `filter` and `exclude` methods, which
+accept a predicate and return a new queryset.
+
+```swift
+queryset.filter(NSPredicate(format:"name == %@", "Kyle"))
+queryset.filter(Person.name == "Kyle")
+queryset.exclude(Person.age < 21)
+queryset.exclude(Person.isEmployed)
+```
+
+#### Ordering
+
+You can order a queryset's results by using the `orderBy` method which accepts
+a collection of sort descriptors:
+
+```swift
+queryset.orderBy(NSSortDescriptor(key: "name", ascending: true))
+queryset.orderBy(Person.name.ascending)
+queryset.orderBy([Person.name.ascending, Person.age.descending])
+```
+
+#### Slicing
+
+You can use slicing to limit a queryset to a range. For example, to get the
+first 5 items:
+
+```swift
+queryset[0..5]
+```
+
+### Fetching
+
+#### Single object
+
+```swift
+var kyle = queryset.filter(Person.name == "Kyle").get()
+```
+
+#### Object at index
+
+```swift
+var orta = queryset[3]
+```
+
+#### Count
+
+```swift
+queryset.count()
+```
+
+#### Iteration
+
+```swift
+for person in queryset {
+    println(person.name)
+}
+```
+
+#### Conversion to an array
+
+```swift
+queryset.array()
+```
+
+### Deleting
+
+This method immediately deletes the objects in your queryset and returns a
+count and an error if the operation failed.
+
+```swift
+queryset.delete()
+```
+
+### Attributes
+
+The `Attribute` is a generic structure for creating predicates providing
+type-safety.
+
+```swift
+let name = Attribute<String>("name")
+let age = Attribute<Int>("age")
+
+name == "Kyle"
+name << ["Kyle", "Katie"]
+
+age == 27
+age >= 25
+age << (22...30)
+```
+
+#### Operators
+
+| Comparison | Meaning |
+| ------- |:--------:|
+| == | x equals y |
+| != | x is not equal to y |
+| < | x is less than y |
+| <= | x is less than or equal to y |
+| > | x is more than y |
+| >= | x is more than or equal to y |
+| ~= | x is like y |
+| ~= | x is like y |
+| << | x IN y, where y is an array |
+| << | x BETWEEN y, where y is a range |
+
+## Predicate extensions
+
+We've extended NSPredicate to add support for the `!`, `&&` and `||` operators
+for joining predicates together.
+
+```swift
+NSPredicate(format:"name == Kyle") || NSPredicate(format:"name == Katie")
+NSPredicate(format:"age >= 21") && !NSPredicate(format:"name == Kyle")
+```
+
+```swift
+Person.name == "Kyle" || Person.name == "Katie"
+Person.age >= 21 || Person.name != "Kyle"
+```
+
+## License
+
+QueryKit is released under the BSD license. See [LICENSE](LICENSE).
+