cocoapods-deintegrate 0.1.1 → 0.2.0

data/spec/fixtures/Project/Frameworks/Pods/QueryKit/LICENSE

@@ -0,0 +1,23 @@
+Copyright (c) 2012-2014, Kyle Fuller
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met: 
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer. 
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution. 
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

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

@@ -0,0 +1,124 @@
+//
+//  Attribute.swift
+//  QueryKit
+//
+//  Created by Kyle Fuller on 19/06/2014.
+//
+//
+
+import Foundation
+
+public struct Attribute<T> : Equatable {
+    public let name:String
+
+    public init(_ name:String) {
+        self.name = name
+    }
+
+    /// Builds a compound attribute with other key paths
+    public init(attributes:Array<String>) {
+        self.init(".".join(attributes))
+    }
+
+    public var expression:NSExpression {
+        return NSExpression(forKeyPath: name)
+    }
+
+    // MARK: Sorting
+
+    public func ascending() -> NSSortDescriptor {
+        return NSSortDescriptor(key: name, ascending: true)
+    }
+
+    public func descending() -> NSSortDescriptor {
+        return NSSortDescriptor(key: name, ascending: false)
+    }
+
+    func expressionForValue(value:T) -> NSExpression {
+        if let value = value as? NSObject {
+            return NSExpression(forConstantValue: value as NSObject)
+        }
+
+        if sizeof(value.dynamicType) == 8 {
+            let value = unsafeBitCast(value, Optional<NSObject>.self)
+            if let value = value {
+                return NSExpression(forConstantValue: value)
+            }
+        }
+
+        let value = unsafeBitCast(value, Optional<String>.self)
+        if let value = value {
+            return NSExpression(forConstantValue: value)
+        }
+
+        return NSExpression(forConstantValue: NSNull())
+    }
+}
+
+public func == <T>(lhs: Attribute<T>, rhs: Attribute<T>) -> Bool {
+    return lhs.name == rhs.name
+}
+
+public func == <T>(left: Attribute<T>, right: T) -> NSPredicate {
+    return left.expression == left.expressionForValue(right)
+}
+
+public func != <T>(left: Attribute<T>, right: T) -> NSPredicate {
+    return left.expression != left.expressionForValue(right)
+}
+
+public func > <T>(left: Attribute<T>, right: T) -> NSPredicate {
+    return left.expression > left.expressionForValue(right)
+}
+
+public func >= <T>(left: Attribute<T>, right: T) -> NSPredicate {
+    return left.expression >= left.expressionForValue(right)
+}
+
+public func < <T>(left: Attribute<T>, right: T) -> NSPredicate {
+    return left.expression < left.expressionForValue(right)
+}
+
+public func <= <T>(left: Attribute<T>, right: T) -> NSPredicate {
+    return left.expression <= left.expressionForValue(right)
+}
+
+public func ~= <T>(left: Attribute<T>, right: T) -> NSPredicate {
+    return left.expression ~= left.expressionForValue(right)
+}
+
+public func << <T>(left: Attribute<T>, right: [T]) -> NSPredicate {
+    return left.expression << NSExpression(forConstantValue: right._asCocoaArray())
+}
+
+public func << <T>(left: Attribute<T>, right: Range<T>) -> NSPredicate {
+    let rightExpression = NSExpression(forConstantValue: [right.startIndex, right.endIndex]._asCocoaArray())
+
+    return NSComparisonPredicate(leftExpression: left.expression, rightExpression: rightExpression, modifier: NSComparisonPredicateModifier.DirectPredicateModifier, type: NSPredicateOperatorType.BetweenPredicateOperatorType, options: NSComparisonPredicateOptions(0))
+}
+
+/// MARK: Bool Attributes
+
+prefix public func ! (left: Attribute<Bool>) -> NSPredicate {
+    return left == false
+}
+
+public extension QuerySet {
+    public func filter(attribute:Attribute<Bool>) -> QuerySet<T> {
+        return filter(attribute == true)
+    }
+
+    public func exclude(attribute:Attribute<Bool>) -> QuerySet<T> {
+        return filter(attribute == false)
+    }
+}
+
+// MARK: Collections
+
+public func count(attribute:Attribute<NSSet>) -> Attribute<Int> {
+    return Attribute<Int>(attributes: [attribute.name, "@count"])
+}
+
+public func count(attribute:Attribute<NSOrderedSet>) -> Attribute<Int> {
+    return Attribute<Int>(attributes: [attribute.name, "@count"])
+}

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

@@ -0,0 +1,41 @@
+//
+//  Expression.swift
+//  QueryKit
+//
+//  Created by Kyle Fuller on 06/07/2014.
+//
+//
+
+import Foundation
+
+public func == (left: NSExpression, right: NSExpression) -> NSPredicate {
+    return NSComparisonPredicate(leftExpression: left, rightExpression: right, modifier: NSComparisonPredicateModifier.DirectPredicateModifier, type: NSPredicateOperatorType.EqualToPredicateOperatorType, options: NSComparisonPredicateOptions(0))
+}
+
+public func != (left: NSExpression, right: NSExpression) -> NSPredicate {
+    return NSComparisonPredicate(leftExpression: left, rightExpression: right, modifier: NSComparisonPredicateModifier.DirectPredicateModifier, type: NSPredicateOperatorType.NotEqualToPredicateOperatorType, options: NSComparisonPredicateOptions(0))
+}
+
+public func > (left: NSExpression, right: NSExpression) -> NSPredicate {
+    return NSComparisonPredicate(leftExpression: left, rightExpression: right, modifier: NSComparisonPredicateModifier.DirectPredicateModifier, type: NSPredicateOperatorType.GreaterThanPredicateOperatorType, options: NSComparisonPredicateOptions(0))
+}
+
+public func >= (left: NSExpression, right: NSExpression) -> NSPredicate {
+    return NSComparisonPredicate(leftExpression: left, rightExpression: right, modifier: NSComparisonPredicateModifier.DirectPredicateModifier, type: NSPredicateOperatorType.GreaterThanOrEqualToPredicateOperatorType, options: NSComparisonPredicateOptions(0))
+}
+
+public func < (left: NSExpression, right: NSExpression) -> NSPredicate {
+    return NSComparisonPredicate(leftExpression: left, rightExpression: right, modifier: NSComparisonPredicateModifier.DirectPredicateModifier, type: NSPredicateOperatorType.LessThanPredicateOperatorType, options: NSComparisonPredicateOptions(0))
+}
+
+public func <= (left: NSExpression, right: NSExpression) -> NSPredicate {
+    return NSComparisonPredicate(leftExpression: left, rightExpression: right, modifier: NSComparisonPredicateModifier.DirectPredicateModifier, type: NSPredicateOperatorType.LessThanOrEqualToPredicateOperatorType, options: NSComparisonPredicateOptions(0))
+}
+
+public func ~= (left: NSExpression, right: NSExpression) -> NSPredicate {
+    return NSComparisonPredicate(leftExpression: left, rightExpression: right, modifier: NSComparisonPredicateModifier.DirectPredicateModifier, type: NSPredicateOperatorType.LikePredicateOperatorType, options: NSComparisonPredicateOptions(0))
+}
+
+public func << (left: NSExpression, right: NSExpression) -> NSPredicate {
+    return NSComparisonPredicate(leftExpression: left, rightExpression: right, modifier: NSComparisonPredicateModifier.DirectPredicateModifier, type: NSPredicateOperatorType.InPredicateOperatorType, options: NSComparisonPredicateOptions(0))
+}

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

@@ -0,0 +1,210 @@
+//
+//  QKAttribute.h
+//  QueryKit
+//
+//  Created by Kyle Fuller on 30/04/2013.
+//
+//
+
+#import <Foundation/Foundation.h>
+
+/** A helper class to generate predicates and sort descriptors for attributes
+ on a managed object.
+ */
+@interface QKAttribute : NSObject <NSSecureCoding, NSCopying>
+
+@property (nonatomic, strong, readonly) NSString *name;
+
+/// Initialized the attribute from multiple other attributes
+- (instancetype)initWithAttributes:(QKAttribute *)attribute, ... NS_REQUIRES_NIL_TERMINATION;
+
+/// Initialized the attribute with the given name
+- (instancetype)initWithName:(NSString *)name __attribute((nonnull));
+
+/** Returns a Boolean value that indicates whether a given attribute is equal to the receiver
+ @param attribute The attribute to compare against the receiver
+ @return YES if attribute is equivalent to the receiver
+ */
+- (BOOL)isEqualToAttribute:(QKAttribute *)attribute;
+
+/** Returns an expression for the attributes key-value path */
+- (NSExpression *)expression;
+
+@end
+
+@interface QKAttribute (Predicate)
+
+/** Returns a predicate for an equality comparison against the supplied value
+ @param value To compare against the attribute
+ @param options NSComparisonPredicateOptions to apply to the comparison
+ @return The predicate for this comparison
+ @see equal:
+ */
+- (NSPredicate *)equal:(id)value options:(NSComparisonPredicateOptions)options;
+
+/** Returns a predicate for an equality comparison against the supplied value
+ @param value To compare against the attribute
+ @return The predicate for this comparison
+ @see equal:options:
+ */
+- (NSPredicate *)equal:(id)value;
+
+/** Returns a predicate for an unequal comparison against the supplied value
+ @param value To compare against the attribute
+ @param options NSComparisonPredicateOptions to apply to the comparison
+ @return The predicate for this comparison
+ @see notEqual:
+ */
+- (NSPredicate *)notEqual:(id)value options:(NSComparisonPredicateOptions)options;
+
+/** Returns a predicate for an unequal comparison against the supplied value
+ @param value To compare against the attribute
+ @return The predicate for this comparison
+ @see notEqual:options:
+ */
+- (NSPredicate *)notEqual:(id)value;
+
+/** Returns a predicate for a like comparison against the supplied value
+ @param value To compare against the attribute
+ @param options NSComparisonPredicateOptions to apply to the comparison
+ @return The predicate for this comparison
+ @see like:
+ */
+- (NSPredicate *)like:(id)value options:(NSComparisonPredicateOptions)options;
+
+/** Returns a predicate for a like comparison against the supplied value
+ @param value To compare against the attribute
+ @return The predicate for this comparison
+ @see like:options:
+ */
+- (NSPredicate *)like:(id)value;
+
+/** Returns a predicate for a matches comparison against the supplied value
+ @param value To compare against the attribute
+ @param options NSComparisonPredicateOptions to apply to the comparison
+ @return The predicate for this comparison
+ @see like:
+ */
+- (NSPredicate *)matches:(id)value options:(NSComparisonPredicateOptions)options;
+
+/** Returns a predicate for a matches comparison against the supplied value
+ @param value To compare against the attribute
+ @return The predicate for this comparison
+ @see like:options:
+ */
+- (NSPredicate *)matches:(id)value;
+
+/** Returns a predicate for a begins with comparison against the supplied value
+ @param value To compare against the attribute
+ @param options NSComparisonPredicateOptions to apply to the comparison
+ @return The predicate for this comparison
+ @see like:
+ */
+- (NSPredicate *)beginsWith:(id)value options:(NSComparisonPredicateOptions)options;
+
+/** Returns a predicate for a begins with comparison against the supplied value
+ @param value To compare against the attribute
+ @return The predicate for this comparison
+ @see like:options:
+ */
+- (NSPredicate *)beginsWith:(id)value;
+
+/** Returns a predicate for a ends with comparison against the supplied value
+ @param value To compare against the attribute
+ @param options NSComparisonPredicateOptions to apply to the comparison
+ @return The predicate for this comparison
+ @see like:
+ */
+- (NSPredicate *)endsWith:(id)value options:(NSComparisonPredicateOptions)options;
+
+/** Returns a predicate for a ends with comparison against the supplied value
+ @param value To compare against the attribute
+ @return The predicate for this comparison
+ @see like:options:
+ */
+- (NSPredicate *)endsWith:(id)value;
+
+/** Returns a predicate for greater than the supplied value
+ @param value To compare against the attribute
+ @return The predicate for this comparison
+ @see greaterThanOrEqualTo:
+ */
+- (NSPredicate *)greaterThan:(id)value;
+
+/** Returns a predicate for greater than or equal to the supplied value
+ @param value To compare against the attribute
+ @return The predicate for this comparison
+ @see greaterThan:
+ */
+- (NSPredicate *)greaterThanOrEqualTo:(id)value;
+
+/** Returns a predicate for less than the supplied value
+ @param value To compare against the attribute
+ @return The predicate for this comparison
+ @see lessThanOrEqualTo:
+ */
+- (NSPredicate *)lessThan:(id)value;
+
+/** Returns a predicate for less than or equal to the supplied value
+ @param value To compare against the attribute
+ @return The predicate for this comparison
+ @see lessThan:
+ */
+- (NSPredicate *)lessThanOrEqualTo:(id)value;
+
+/** Returns a predicate for attribute being between two values
+ @param minimumValue
+ @param maximumValue
+ @return The predicate for this comparison
+ */
+- (NSPredicate *)between:(id)minimumValue and:(id)maxiumValue;
+
+/** Returns an IN predicate for attribute
+ @param set An enumerable object containing a set ob objects
+ @return The predicate for this comparison
+ */
+- (NSPredicate *)in:(id<NSFastEnumeration>)set;
+
+/** Returns a predicate for a contains with comparison against the supplied value
+ @param value To compare against the attribute
+ @param options NSComparisonPredicateOptions to apply to the comparison
+ @return The predicate for this comparison
+ @see contains:
+ */
+- (NSPredicate *)contains:(id)value options:(NSComparisonPredicateOptions)options;
+
+/** Returns a predicate for a contains with comparison against the supplied value
+ @param value To compare against the attribute
+ @return The predicate for this comparison
+ @see contains:options:
+ */
+- (NSPredicate *)contains:(id)value;
+
+/** Returns a predicate for if the attribute being equal to nil
+ @return The predicate for the attribute being nil.
+ */
+- (NSPredicate *)isNil;
+
+/** Returns a predicate for if the attribute being equal to YES
+ @return The predicate for the attribute being YES.
+ @see isNO
+ */
+- (NSPredicate *)isYes;
+
+/** Returns a predicate for if the attribute being equal to NO
+ @return The predicate for the attribute being NO.
+ @see isYes
+ */
+- (NSPredicate *)isNo;
+
+@end
+
+@interface QKAttribute (Sorting)
+
+/** Returns an ascending sort descriptor for this attribute */
+- (NSSortDescriptor *)ascending;
+
+/** Returns a descending sort descriptor for this attribute */
+- (NSSortDescriptor *)descending;
+
+@end

data/spec/fixtures/Project/Frameworks/Pods/QueryKit/QueryKit/ObjectiveC/QKAttribute.m

@@ -0,0 +1,315 @@
+//
+//  QKAttribute.m
+//  QueryKit
+//
+//  Created by Kyle Fuller on 30/04/2013.
+//
+//
+
+#import "QKAttribute.h"
+
+@implementation QKAttribute
+
+#pragma mark - NSCoding
+
++ (BOOL)supportsSecureCoding {
+    return YES;
+}
+
+- (void)encodeWithCoder:(NSCoder *)encoder {
+    [encoder encodeObject:self.name forKey:@"name"];
+}
+
+- (instancetype)initWithCoder:(NSCoder *)decoder {
+    NSString *name = [decoder decodeObjectOfClass:[NSString class] forKey:@"name"];
+    return [self initWithName:name];
+}
+
+#pragma mark - NSCopying
+
+- (instancetype)copyWithZone:(NSZone *)zone {
+    NSString *name = [self.name copyWithZone:zone];
+    return [[[self class] alloc] initWithName:name];
+}
+
+#pragma mark -
+
+- (instancetype)initWithAttributes:(QKAttribute *)attribute, ... {
+    NSParameterAssert(attribute != nil);
+
+    NSMutableArray *attributes = [NSMutableArray arrayWithObject:attribute.name];
+
+    va_list attributeList;
+    va_start(attributeList, attribute);
+    while ((attribute = va_arg(attributeList, id))) {
+        [attributes addObject:attribute.name];
+    }
+    va_end(attributeList);
+
+    NSString *name = [attributes componentsJoinedByString:@"."];
+
+    if (self = [super init]) {
+        _name = name;
+    }
+
+    return self;
+}
+
+- (instancetype)initWithName:(NSString *)name {
+    if (self = [super init]) {
+        _name = name;
+    }
+
+    return self;
+}
+
+- (NSExpression *)expression {
+    return [NSExpression expressionForKeyPath:self.name];
+}
+
+#pragma mark - Equality
+
+- (NSUInteger)hash {
+    return [self.name hash];
+}
+
+- (BOOL)isEqualToAttribute:(QKAttribute *)attribute {
+    return [self.name isEqualToString:attribute.name];
+}
+
+- (BOOL)isEqual:(id)object {
+    return object == self || ([object isKindOfClass:[QKAttribute class]] && [self isEqualToAttribute:object]);
+}
+
+#pragma mark -
+
+// The following methods are implemented so that `[NSPredicate predicateWithFormat:@"%K", attribute]` will work
+
+- (NSString *)description {
+    return self.name;
+}
+
+- (NSRange)rangeOfString:(NSString *)aString {
+    return [self.name rangeOfString:aString];
+}
+
+- (NSArray *)componentsSeparatedByString:(NSString *)separator {
+    return [self.name componentsSeparatedByString:separator];
+}
+
+- (NSUInteger)length {
+    return [self.name length];
+}
+
+#pragma mark - Comparison
+
+- (NSPredicate *)predicateWithRightExpression:(NSExpression *)expression
+                                     modifier:(NSComparisonPredicateModifier)modifier
+                                         type:(NSPredicateOperatorType)type
+                                      options:(NSComparisonPredicateOptions)options
+{
+    NSExpression *leftExpression = [self expression];
+
+    return [NSComparisonPredicate predicateWithLeftExpression:leftExpression
+                                              rightExpression:expression
+                                                     modifier:modifier
+                                                         type:type
+                                                      options:options];
+}
+
+@end
+
+@implementation QKAttribute (Predicate)
+
+- (NSPredicate *)equal:(id)value options:(NSComparisonPredicateOptions)options {
+    NSExpression *expression = [NSExpression expressionForConstantValue:value];
+
+    return [self predicateWithRightExpression:expression
+                                     modifier:NSDirectPredicateModifier
+                                         type:NSEqualToPredicateOperatorType
+                                      options:options];
+}
+
+- (NSPredicate *)equal:(id)value {
+    return [self equal:value options:0];
+}
+
+- (NSPredicate *)notEqual:(id)value options:(NSComparisonPredicateOptions)options {
+    NSExpression *expression = [NSExpression expressionForConstantValue:value];
+
+    return [self predicateWithRightExpression:expression
+                                     modifier:NSDirectPredicateModifier
+                                         type:NSNotEqualToPredicateOperatorType
+                                      options:options];
+}
+
+- (NSPredicate *)notEqual:(id)value {
+    return [self notEqual:value options:0];
+}
+
+- (NSPredicate *)beginsWith:(id)value options:(NSComparisonPredicateOptions)options {
+    NSExpression *expression = [NSExpression expressionForConstantValue:value];
+
+    return [self predicateWithRightExpression:expression
+                                     modifier:NSDirectPredicateModifier
+                                         type:NSBeginsWithPredicateOperatorType
+                                      options:options];
+}
+
+- (NSPredicate *)beginsWith:(id)value {
+    return [self beginsWith:value options:0];
+}
+
+- (NSPredicate *)endsWith:(id)value options:(NSComparisonPredicateOptions)options {
+    NSExpression *expression = [NSExpression expressionForConstantValue:value];
+
+    return [self predicateWithRightExpression:expression
+                                     modifier:NSDirectPredicateModifier
+                                         type:NSEndsWithPredicateOperatorType
+                                      options:options];
+}
+
+- (NSPredicate *)endsWith:(id)value {
+    return [self endsWith:value options:0];
+}
+
+- (NSPredicate *)like:(id)value options:(NSComparisonPredicateOptions)options {
+    NSExpression *expression = [NSExpression expressionForConstantValue:value];
+
+    return [self predicateWithRightExpression:expression
+                                     modifier:NSDirectPredicateModifier
+                                         type:NSLikePredicateOperatorType
+                                      options:options];
+}
+
+- (NSPredicate *)like:(id)value {
+    return [self like:value options:0];
+}
+
+- (NSPredicate *)matches:(id)value options:(NSComparisonPredicateOptions)options {
+    NSExpression *expression = [NSExpression expressionForConstantValue:value];
+
+    return [self predicateWithRightExpression:expression
+                                     modifier:NSDirectPredicateModifier
+                                         type:NSMatchesPredicateOperatorType
+                                      options:options];
+}
+
+- (NSPredicate *)matches:(id)value {
+    return [self matches:value options:0];
+}
+
+- (NSPredicate *)greaterThan:(id)value {
+    NSExpression *expression = [NSExpression expressionForConstantValue:value];
+
+    return [self predicateWithRightExpression:expression
+                                     modifier:NSDirectPredicateModifier
+                                         type:NSGreaterThanPredicateOperatorType
+                                      options:0];
+}
+
+- (NSPredicate *)greaterThanOrEqualTo:(id)value {
+    NSExpression *expression = [NSExpression expressionForConstantValue:value];
+
+    return [self predicateWithRightExpression:expression
+                                     modifier:NSDirectPredicateModifier
+                                         type:NSGreaterThanOrEqualToPredicateOperatorType
+                                      options:0];
+}
+
+- (NSPredicate *)lessThan:(id)value {
+    NSExpression *expression = [NSExpression expressionForConstantValue:value];
+
+    return [self predicateWithRightExpression:expression
+                                     modifier:NSDirectPredicateModifier
+                                         type:NSLessThanPredicateOperatorType
+                                      options:0];
+}
+
+- (NSPredicate *)lessThanOrEqualTo:(id)value {
+    NSExpression *expression = [NSExpression expressionForConstantValue:value];
+
+    return [self predicateWithRightExpression:expression
+                                     modifier:NSDirectPredicateModifier
+                                         type:NSLessThanOrEqualToPredicateOperatorType
+                                      options:0];
+}
+
+- (NSPredicate *)isNil {
+    NSExpression *expression = [NSExpression expressionForConstantValue:nil];
+
+    return [self predicateWithRightExpression:expression
+                                     modifier:NSDirectPredicateModifier
+                                         type:NSEqualToPredicateOperatorType
+                                      options:0];
+}
+
+- (NSPredicate *)between:(id)minimumValue and:(id)maxiumValue {
+    NSParameterAssert(minimumValue != nil);
+    NSParameterAssert(maxiumValue != nil);
+
+    NSExpression *expression = [NSExpression expressionForConstantValue:@[minimumValue, maxiumValue]];
+
+    return [self predicateWithRightExpression:expression
+                                     modifier:NSDirectPredicateModifier
+                                         type:NSBetweenPredicateOperatorType
+                                      options:0];
+}
+
+- (NSPredicate *)in:(id<NSFastEnumeration>)set {
+    NSParameterAssert(set != nil);
+
+    NSExpression *expression = [NSExpression expressionForConstantValue:set];
+
+    return [self predicateWithRightExpression:expression
+                                     modifier:NSDirectPredicateModifier
+                                         type:NSInPredicateOperatorType
+                                      options:0];
+}
+
+- (NSPredicate *)contains:(id)value options:(NSComparisonPredicateOptions)options {
+    NSParameterAssert(value != nil);
+
+    NSExpression *expression = [NSExpression expressionForConstantValue:value];
+
+    return [self predicateWithRightExpression:expression
+                                     modifier:NSDirectPredicateModifier
+                                         type:NSContainsPredicateOperatorType
+                                      options:options];
+}
+
+- (NSPredicate *)contains:(id)value {
+    return [self contains:value options:0];
+}
+
+- (NSPredicate *)isYes {
+    NSExpression *expression = [NSExpression expressionForConstantValue:@YES];
+
+    return [self predicateWithRightExpression:expression
+                                     modifier:NSDirectPredicateModifier
+                                         type:NSEqualToPredicateOperatorType
+                                      options:0];
+}
+
+- (NSPredicate *)isNo {
+    NSExpression *expression = [NSExpression expressionForConstantValue:@NO];
+
+    return [self predicateWithRightExpression:expression
+                                     modifier:NSDirectPredicateModifier
+                                         type:NSEqualToPredicateOperatorType
+                                      options:0];
+}
+
+@end
+
+@implementation QKAttribute (Sorting)
+
+- (NSSortDescriptor *)ascending {
+    return [[NSSortDescriptor alloc] initWithKey:self.name ascending:YES];
+}
+
+- (NSSortDescriptor *)descending {
+    return [[NSSortDescriptor alloc] initWithKey:self.name ascending:NO];
+}
+
+@end