RubyGems - cocoapods-deintegrate - Versions diffs - 0.2.1 → 1.0.0.beta.1 - Mend

cocoapods-deintegrate 0.2.1 → 1.0.0.beta.1

Files changed (323) hide show

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

@@ -1,28 +0,0 @@
-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 DELETED

@@ -1,21 +0,0 @@
-//
-//  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 DELETED

@@ -1,19 +0,0 @@
-//
-//  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 DELETED

@@ -1,237 +0,0 @@
-//
-//  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 DELETED

@@ -1,151 +0,0 @@
-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).