Project import
diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..bfcbe8a --- /dev/null +++ b/CHANGELOG.md
@@ -0,0 +1,417 @@ +# 2.0 + +This release of ReactiveCocoa contains major breaking changes that we were +unable to make after freezing the 1.0 API. All changes are focused on +eliminating bad code and bad usage patterns, reducing confusion, and increasing +flexibility in the framework. + +For a complete list of changes in ReactiveCocoa 2.0, see [the +milestone](https://github.com/ReactiveCocoa/ReactiveCocoa/issues?milestone=3&state=closed). + +**[Breaking changes](#breaking-changes)** + + 1. [Simplified and safer KVO](#simplified-and-safer-kvo) + 1. [Safer commands with less state](#safer-commands-with-less-state) + 1. [Fallback nil value for RAC macro](#fallback-nil-values-for-rac-macro) + 1. [Explicit schedulers for time-based operators](#explicit-schedulers-for-time-based-operators) + 1. [More powerful selector signals](#more-powerful-selector-signals) + 1. [Simpler two-way bindings](#simpler-two-way-bindings) + 1. [Better bindings for AppKit](#better-bindings-for-appkit) + 1. [More obvious sequencing operator](#more-obvious-sequencing-operator) + 1. [Renamed signal binding method](#renamed-signal-binding-method) + 1. [Consistent selector lifting](#consistent-selector-lifting) + 1. [Renamed scheduled signal constructors](#renamed-scheduled-signal-constructors) + 1. [Notification immediately before object deallocation](#notification-immediately-before-object-deallocation) + 1. [Extensible queue-based schedulers](#extensible-queue-based-schedulers) + 1. [GCD time values replaced with NSDate](#gcd-time-values-replaced-with-nsdate) + 1. [Windows and numbered buffers removed](#windows-and-numbered-buffers-removed) + 1. [NSTask extension removed](#nstask-extension-removed) + 1. [RACSubscriber class now private](#racsubscriber-class-now-private) + +**[Additions and improvements](#additions-and-improvements)** + + 1. [Commands for UIButton](#commands-for-uibutton) + 1. [Signal for UIActionSheet button clicks](#signal-for-uiactionsheet-button-clicks) + 1. [Better documentation for asynchronous backtraces](#better-documentation-for-asynchronous-backtraces) + 1. [Fixed libextobjc duplicated symbols](#fixed-libextobjc-duplicated-symbols) + 1. [Bindings for UIKit classes](#bindings-for-uikit-classes) + 1. [Signal subscription side effects](#signal-subscription-side-effects) + 1. [Test scheduler](#test-scheduler) + +## Breaking changes + +### Simplified and safer KVO + +`RACAble` and `RACAbleWithStart` have been replaced with a single +[RACObserve](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/601) macro. +`RACObserve` always starts with the current value of the property, and will +[notice the +deallocation](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/678) of `weak` +properties (unlike vanilla KVO). + +Unlike the previous macros, which only required one argument for key paths on +`self`, `RACObserve` always requires two arguments. + +**To update:** + + * Replace uses of `RACAbleWithStart(self.key)` with `RACObserve(self, key)`. + * Replace uses of `RACAble(self.key)` with `[RACObserve(self, key) skip:1]` (if + skipping the starting value is necessary). + +### Safer commands with less state + +`RACCommand` has been [completely +refactored](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/733). It is no +longer a `RACSignal`, and the behavior of `-addSignalBlock:` has been moved to +the initializer, making the class almost entirely immutable. + +Reflecting the most common use case, KVO-notifying properties have been changed +into signals instead. During the change, `canExecute` was also renamed to +`enabled`, which should make its purpose more obvious for binding to the UI. + +In addition, changes to `executing`, `errors`, and `enabled` are now guaranteed +to fire on the main thread, so UI observers no longer [run in the background +unexpectedly](https://github.com/ReactiveCocoa/ReactiveCocoa/issues/533). + +All together, these improvements should make `RACCommand` more composable and +less imperative, so it fits into the framework better. + +**To update:** + + * Move execution logic from `-addSignalBlock:` or `-subscribeNext:` into the + `signalBlock` passed to the initializer. + * Instead of subscribing to the result of `-addSignalBlock:`, subscribe to + `executionSignals` or the result of `-execute:` instead. + * Replace uses of `RACAbleWithStart(command, executing)` with + `command.executing`. + * Replace uses of `RACAbleWithStart(command, canExecute)` with + `command.enabled`. + * Remove uses of `deliverOn:RACScheduler.mainThreadScheduler` on + `RACCommand` properties, as they are now unnecessary. + +### Fallback nil values for RAC macro + +The `RAC` macro now [always +requires](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/670) two or three +arguments: + + 1. The object to bind to. + 1. The key path to set when new values are sent. + 1. (Optional) A value to set when `nil` is sent on the signal. + +This is necessary to avoid a `-setNilValueForKey:` exception when observing +a primitive property _through_ an intermediate object which gets set to `nil`. + +This is not actually a change in key-value observing behavior — it's a caveat +with KVO regardless — but `RACObserve` makes it more prominent, because the +deallocation of `weak` properties will be considered a change to `nil`. + +**To update:** + + * Replace uses of `RAC(self.objectProperty)` with `RAC(self, objectProperty)`. + * When binding a signal that might send nil (like a key path observation) to + a primitive property, provide a default value: `RAC(self, integerProperty, @5)` + +### Explicit schedulers for time-based operators + +`-bufferWithTime:`, `+interval:`, and `-timeout:` have been unintuitive and +error-prone because of their implicit use of a background scheduler. + +All of the aforementioned methods now require [a scheduler +argument](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/588), so that it's +clear how events should be delivered. + +**To update:** + + * To match the previous behavior exactly, pass in `[RACScheduler scheduler]`. + Note that this creates a _new_ background scheduler for events to arrive upon. + * If you were already using `-deliverOn:` to force one of the above operators + to deliver onto a specific scheduler, you can eliminate that hop and pass the + scheduler into the operator directly. + +### More powerful selector signals + +`-rac_signalForSelector:` has been [completely +refactored](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/590) to support +listening for invocations of existing methods, new and existing methods with +multiple arguments, and existing methods with return values. + +`+rac_signalForSelector:` (the class method variant) was removed, because +swizzling class methods is dangerous and difficult to do correctly. + +**To update:** + + * Most existing uses of `-rac_signalForSelector:` shouldn't require + any changes. However, the `super` implementation (if available) of any targeted selector will + now be invoked, where it wasn't previously. Verify that existing uses can + handle this case. + * Replace uses of `+rac_signalForSelector:` by implementing the class method + and sending arguments onto a `RACSubject` instead. + +### Simpler two-way bindings + +`RACPropertySubject` and `RACBinding` have been +[replaced](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/695) with +`RACChannel` and `RACChannelTerminal`. Similarly, `RACObservablePropertySubject` +has been replaced with `RACKVOChannel`. + +In addition to slightly better terminology and more obvious usage, channels only +offer two-way bindings by default, which is a simplification over the previous N-way binding +interface. + +Because of the sweeping conceptual changes, the old APIs have been completely +removed without deprecation. + +**To update:** + + * Instead of creating a `RACPropertySubject`, create a `RACChannel`. Replace + N-way property subjects (where N is greater than 2) with multiple + `RACChannel`s. + * Instead of creating a `RACObservablePropertySubject`, create + a `RACKVOChannel` or use the `RACChannelTo` macro. + * Replace uses of `RACBinding` with `RACChannelTerminal`. + * Replace uses of `RACBind(self.objectProperty)` with `RACChannelTo(self, + objectProperty)`. Add a default value for primitive properties: + `RACChannelTo(self, integerProperty, @5)` + * Replace uses of `-bindTo:` with the explicit subscription of two endpoints: + +```objc +[binding1.followingEndpoint subscribe:binding2.leadingEndpoint]; +[[binding2.leadingEndpoint skip:1] subscribe:binding1.followingEndpoint]; +``` + +### Better bindings for AppKit + +`-rac_bind:toObject:withKeyPath:` and related methods have been +[replaced](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/638) with +`-rac_channelToBinding:options:`, which returns a `RACChannelTerminal` that can be used as +a two-way binding or a one-way signal. + +**To update:** + + * If possible, refactor code to use the new `RACChannel` interface. This + bridges Cocoa Bindings with the full power of ReactiveCocoa. + * For a direct conversion, use `-bind:toObject:withKeyPath:options:` with the + following options: + 1. `@{ NSContinuouslyUpdatesValueBindingOption: @YES }` for `-rac_bind:toObject:withKeyPath:` + 1. `@{ NSContinuouslyUpdatesValueBindingOption: @YES, NSNullPlaceholderBindingOption: nilValue }` for `-rac_bind:toObject:withKeyPath:nilValue:` + 1. `@{ NSContinuouslyUpdatesValueBindingOption: @YES, NSValueTransformerBindingOption: valueTransformer }` for `-rac_bind:toObject:withKeyPath:transform:` + 1. `@{ NSContinuouslyUpdatesValueBindingOption: @YES, NSValueTransformerBindingOption: NSNegateBooleanTransformerName }` for `-rac_bind:toObject:withNegatedKeyPath:` + +### More obvious sequencing operator + +To make the sequencing and transformation operators less confusing, +`-sequenceMany:` has been removed, and `-sequenceNext:` has been +[renamed](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/635) to `-then:`. + +**To update:** + + * Replace uses of `-sequenceMany:` with `-flattenMap:` and a block that doesn't + use its argument. + * Replace uses of `-sequenceNext:` with `-then:`. + +### Renamed signal binding method + +`-toProperty:onObject:` and `-[NSObject rac_deriveProperty:from:]` have been +[combined](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/617) into a new +`-[RACSignal setKeyPath:onObject:nilValue:]` method. + +The `nilValue` parameter was added in parallel with the +[RAC](#fallback-nil-values-for-rac-macro) macro, but the semantics are otherwise +identical. + +**To update:** + + * Replace `-toProperty:onObject:` and `-rac_deriveProperty:from:` with + `-setKeyPath:onObject:`. + * When binding a signal that might send nil (like a key path observation) to + a primitive property, provide a default value: `[signal setKeyPath:@"integerProperty" onObject:self nilValue:@5]` + +### Consistent selector lifting + +In the interests of [parametricity](http://en.wikipedia.org/wiki/Parametricity), +`-rac_liftSelector:withObjects:` has been +[replaced](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/609) with +`-rac_liftSelector:withSignals:`, which requires all arguments to be signals. +This makes usage more consistent. + +`-rac_liftBlock:withArguments:` has been removed, because it's redundant with +`RACSignal` operators. + +The `-rac_lift` proxy has also been removed, because there's no way to [make it +consistent](https://github.com/ReactiveCocoa/ReactiveCocoa/issues/520) in the +same way. + +**To update:** + + * Wrap non-signal arguments with `+[RACSignal return:]` and add a nil + terminator. + * Replace block lifting with `+combineLatest:reduce:`. + * Replace uses of `-rac_lift` with `-rac_liftSelector:withSignals:`. + +### Renamed scheduled signal constructors + +`+start:`, `+startWithScheduler:block`, and `+startWithScheduler:subjectBlock:` +have been combined into a single +[+startEagerlyWithScheduler:block:](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/536) +constructor. + +The key improvements here are a more intuitive name, a required `RACScheduler` +to make it clear where the block is executed, and use of `<RACSubscriber>` +instead of `RACSubject` to make it more obvious how to use the block argument. + +**To update:** + + * Use `[RACScheduler scheduler]` to match the previous implicit scheduling + behavior of `+start:`. + * Refactor blocks that return values and set `success`/`error`, to send events + to the given `<RACSubscriber>` instead. + +### Notification immediately before object deallocation + +`-rac_didDeallocSignal` has been +[removed](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/585) in favor of +[-rac_willDeallocSignal](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/580), +because most teardown should happen _before_ the object becomes invalid. + +`-rac_addDeallocDisposable:` has also been +[removed](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/586) in favor of +using the object's `rac_deallocDisposable` directly. + +**To update:** + + * Replace uses of `-rac_didDeallocSignal` with `rac_willDeallocSignal`. + * Replace uses of `-rac_addDeallocDisposable:` by invoking `-addDisposable:` on + the object's `rac_deallocDisposable` instead. + +### Extensible queue-based schedulers + +`RACQueueScheduler` has been [exposed as a public +class](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/561), so consumers can create +their own scheduler implementations using GCD queues. + +The +[RACTargetQueueScheduler](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/561) +subclass replaces the `+schedulerWithQueue:name:` method. + +**To update:** + +Replace uses of `+schedulerWithQueue:name:` with `-[RACTargetQueueScheduler initWithName:targetQueue:]`. + +### GCD time values replaced with NSDate + +`NSDate` now [replaces](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/664) +`dispatch_time_t` values in `RACScheduler`, because dates are easier to use, more +convertible to other formats, and can be used to implement a [virtualized time +scheduler](https://github.com/ReactiveCocoa/ReactiveCocoa/issues/171). + +**To update:** + +Replace `dispatch_time_t` calculations with `NSDate`. + +### Windows and numbered buffers removed + +`-windowWithStart:close:` and `-buffer:` have been +[removed](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/616) because +they're not well-tested, and their functionality can be achieved with other +operators. + +`-bufferWithTime:` is still supported. + +**To update:** + + * Refactor uses of `-windowWithStart:close:` with different patterns. + * Replace uses of `-buffer:` with [take, collect, and + repeat](https://github.com/ReactiveCocoa/ReactiveCocoa/issues/587). + +### NSTask extension removed + +`NSTask+RACSupport` has been +[removed](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/556), because it +was buggy and unsupported. + +**To update:** + +Use a vanilla `NSTask`, and send events onto `RACSubject`s instead. + +### RACSubscriber class now private + +The `RACSubscriber` class (not to be confused with the protocol) should never be +used directly, so it has been +[hidden](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/584). + +**To update:** + +Replace uses of `RACSubscriber` with `id<RACSubscriber>` or `RACSubject`. + +## Additions and improvements + +### Commands for UIButton + +`UIButton` now has a [rac_command +property](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/558). + +Any command set will be executed when the button is tapped, and the button will +be disabled whenever the command is unable to execute. + +### Signal for UIActionSheet button clicks + +`UIActionSheet` now has a [rac_buttonClickedSignal +property](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/611), which will +fire whenever one of the sheet's buttons is clicked. + +### Better documentation for asynchronous backtraces + +Documentation has been +[added](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/680) to +`RACBacktrace` explaining how to start collecting backtraces and print them out +in the debugger. + +The `+captureBacktrace…` methods have been renamed to `+backtrace…`, and +`+printBacktrace` has been removed in favor of using `po [RACBacktrace backtrace]` +from the debugger. + +The `rac_` GCD functions which collect backtraces have also been exposed, +primarily for use on iOS. + +### Fixed libextobjc duplicated symbols + +If [libextobjc](https://github.com/jspahrsummers/libextobjc) was used in +a project that statically linked ReactiveCocoa, duplicate symbol errors could +result. + +To avoid this issue, RAC now +[renames](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/612) the +libextobjc symbols that it uses. + +### Bindings for UIKit classes + +RACChannel interfaces have been [added](https://github.com/ReactiveCocoa/pull/686) +to many UIKit classes, greatly simplifying glue code between your models and views. + +For example, assuming you want to bind a `person` model's `name` property: + +```objc +UITextField *nameField = ...; +RACChannelTerminal *nameTerminal = RACChannelTo(model, name); +RACChannelTerminal *nameFieldTerminal = [nameField rac_newTextChannel]; +[nameTerminal subscribe:nameFieldTerminal]; +[nameFieldTerminal subscribe:nameTerminal]; +``` + +You may also bind multiple controls to the same property, for example a UISlider for +coarse editing and a UIStepper for fine-grained editing. + +### Signal subscription side effects + +`RACSignal` now has the +[-initially:](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/685) +operator, which executes a given block each time the signal is subscribed to. +This is symmetric to `-finally:`. + +### Test scheduler + +`RACTestScheduler` is a [new kind](https://github.com/ReactiveCocoa/ReactiveCocoa/pull/716) of scheduler that +virtualizes time. Enqueued blocks can be stepped through at any pace, no matter +how far in the future they're scheduled for, making it easy to test time-based +behavior without actually waiting in unit tests.
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 0000000..9956451 --- /dev/null +++ b/CONTRIBUTING.md
@@ -0,0 +1,23 @@ +We love that you're interested in contributing to this project! + +To make the process as painless as possible, we have just a couple of guidelines +that should make life easier for everyone involved. + +## Prefer Pull Requests + +If you know exactly how to implement the feature being suggested or fix the bug +being reported, please open a pull request instead of an issue. Pull requests are easier than +patches or inline code blocks for discussing and merging the changes. + +If you can't make the change yourself, please open an issue after making sure +that one isn't already logged. + +## Contributing Code + +Fork this repository, make it awesomer (preferably in a branch named for the +topic), send a pull request! + +All code contributions should match our [coding +conventions](https://github.com/github/objective-c-conventions). + +Thanks for contributing! :boom::camel:
diff --git a/Documentation/BasicOperators.md b/Documentation/BasicOperators.md new file mode 100644 index 0000000..03a4ca0 --- /dev/null +++ b/Documentation/BasicOperators.md
@@ -0,0 +1,364 @@ +# Basic Operators + +This document explains some of the most common operators used in ReactiveCocoa, +and includes examples demonstrating their use. + +Operators that apply to [sequences][Sequences] _and_ [signals][Signals] are +known as [stream][Streams] operators. + +**[Performing side effects with signals](#performing-side-effects-with-signals)** + + 1. [Subscription](#subscription) + 1. [Injecting effects](#injecting-effects) + +**[Transforming streams](#transforming-streams)** + + 1. [Mapping](#mapping) + 1. [Filtering](#filtering) + +**[Combining streams](#combining-streams)** + + 1. [Concatenating](#concatenating) + 1. [Flattening](#flattening) + 1. [Mapping and flattening](#mapping-and-flattening) + +**[Combining signals](#combining-signals)** + + 1. [Sequencing](#sequencing) + 1. [Merging](#merging) + 1. [Combining latest values](#combining-latest-values) + 1. [Switching](#switching) + +## Performing side effects with signals + +Most signals start out "cold," which means that they will not do any work until +[subscription](#subscription). + +Upon subscription, a signal or its [subscribers][Subscription] can perform _side +effects_, like logging to the console, making a network request, updating the +user interface, etc. + +Side effects can also be [injected](#injecting-effects) into a signal, where +they won't be performed immediately, but will instead take effect with each +subscription later. + +### Subscription + +The [-subscribe…][RACSignal] methods give you access to the current and future values in a signal: + +```objc +RACSignal *letters = [@"A B C D E F G H I" componentsSeparatedByString:@" "].rac_sequence.signal; + +// Outputs: A B C D E F G H I +[letters subscribeNext:^(NSString *x) { + NSLog(@"%@", x); +}]; +``` + +For a cold signal, side effects will be performed once _per subscription_: + +```objc +__block unsigned subscriptions = 0; + +RACSignal *loggingSignal = [RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) { + subscriptions++; + [subscriber sendCompleted]; + return nil; +}]; + +// Outputs: +// subscription 1 +[loggingSignal subscribeCompleted:^{ + NSLog(@"subscription %u", subscriptions); +}]; + +// Outputs: +// subscription 2 +[loggingSignal subscribeCompleted:^{ + NSLog(@"subscription %u", subscriptions); +}]; +``` + +This behavior can be changed using a [connection][Connections]. + +### Injecting effects + +The [-do…][RACSignal+Operations] methods add side effects to a signal without actually +subscribing to it: + +```objc +__block unsigned subscriptions = 0; + +RACSignal *loggingSignal = [RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) { + subscriptions++; + [subscriber sendCompleted]; + return nil; +}]; + +// Does not output anything yet +loggingSignal = [loggingSignal doCompleted:^{ + NSLog(@"about to complete subscription %u", subscriptions); +}]; + +// Outputs: +// about to complete subscription 1 +// subscription 1 +[loggingSignal subscribeCompleted:^{ + NSLog(@"subscription %u", subscriptions); +}]; +``` + +## Transforming streams + +These operators transform a single stream into a new stream. + +### Mapping + +The [-map:][RACStream] method is used to transform the values in a stream, and +create a new stream with the results: + +```objc +RACSequence *letters = [@"A B C D E F G H I" componentsSeparatedByString:@" "].rac_sequence; + +// Contains: AA BB CC DD EE FF GG HH II +RACSequence *mapped = [letters map:^(NSString *value) { + return [value stringByAppendingString:value]; +}]; +``` + +### Filtering + +The [-filter:][RACStream] method uses a block to test each value, including it +into the resulting stream only if the test passes: + +```objc +RACSequence *numbers = [@"1 2 3 4 5 6 7 8 9" componentsSeparatedByString:@" "].rac_sequence; + +// Contains: 2 4 6 8 +RACSequence *filtered = [numbers filter:^ BOOL (NSString *value) { + return (value.intValue % 2) == 0; +}]; +``` + +## Combining streams + +These operators combine multiple streams into a single new stream. + +### Concatenating + +The [-concat:][RACStream] method appends one stream's values to another: + +```objc +RACSequence *letters = [@"A B C D E F G H I" componentsSeparatedByString:@" "].rac_sequence; +RACSequence *numbers = [@"1 2 3 4 5 6 7 8 9" componentsSeparatedByString:@" "].rac_sequence; + +// Contains: A B C D E F G H I 1 2 3 4 5 6 7 8 9 +RACSequence *concatenated = [letters concat:numbers]; +``` + +### Flattening + +The [-flatten][RACStream] operator is applied to a stream-of-streams, and +combines their values into a single new stream. + +Sequences are [concatenated](#concatenating): + +```objc +RACSequence *letters = [@"A B C D E F G H I" componentsSeparatedByString:@" "].rac_sequence; +RACSequence *numbers = [@"1 2 3 4 5 6 7 8 9" componentsSeparatedByString:@" "].rac_sequence; +RACSequence *sequenceOfSequences = @[ letters, numbers ].rac_sequence; + +// Contains: A B C D E F G H I 1 2 3 4 5 6 7 8 9 +RACSequence *flattened = [sequenceOfSequences flatten]; +``` + +Signals are [merged](#merging): + +```objc +RACSubject *letters = [RACSubject subject]; +RACSubject *numbers = [RACSubject subject]; +RACSignal *signalOfSignals = [RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) { + [subscriber sendNext:letters]; + [subscriber sendNext:numbers]; + [subscriber sendCompleted]; + return nil; +}]; + +RACSignal *flattened = [signalOfSignals flatten]; + +// Outputs: A 1 B C 2 +[flattened subscribeNext:^(NSString *x) { + NSLog(@"%@", x); +}]; + +[letters sendNext:@"A"]; +[numbers sendNext:@"1"]; +[letters sendNext:@"B"]; +[letters sendNext:@"C"]; +[numbers sendNext:@"2"]; +``` + +### Mapping and flattening + +[Flattening](#flattening) isn't that interesting on its own, but understanding +how it works is important for [-flattenMap:][RACStream]. + +`-flattenMap:` is used to transform each of a stream's values into _a new +stream_. Then, all of the streams returned will be flattened down into a single +stream. In other words, it's [-map:](#mapping) followed by [-flatten](#flattening). + +This can be used to extend or edit sequences: + +```objc +RACSequence *numbers = [@"1 2 3 4 5 6 7 8 9" componentsSeparatedByString:@" "].rac_sequence; + +// Contains: 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 +RACSequence *extended = [numbers flattenMap:^(NSString *num) { + return @[ num, num ].rac_sequence; +}]; + +// Contains: 1_ 3_ 5_ 7_ 9_ +RACSequence *edited = [numbers flattenMap:^(NSString *num) { + if (num.intValue % 2 == 0) { + return [RACSequence empty]; + } else { + NSString *newNum = [num stringByAppendingString:@"_"]; + return [RACSequence return:newNum]; + } +}]; +``` + +Or create multiple signals of work which are automatically recombined: + +```objc +RACSignal *letters = [@"A B C D E F G H I" componentsSeparatedByString:@" "].rac_sequence.signal; + +[[letters + flattenMap:^(NSString *letter) { + return [database saveEntriesForLetter:letter]; + }] + subscribeCompleted:^{ + NSLog(@"All database entries saved successfully."); + }]; +``` + +## Combining signals + +These operators combine multiple signals into a single new [RACSignal][]. + +### Sequencing + +[-then:][RACSignal+Operations] starts the original signal, +waits for it to complete, and then only forwards the values from a new signal: + +```objc +RACSignal *letters = [@"A B C D E F G H I" componentsSeparatedByString:@" "].rac_sequence.signal; + +// The new signal only contains: 1 2 3 4 5 6 7 8 9 +// +// But when subscribed to, it also outputs: A B C D E F G H I +RACSignal *sequenced = [[letters + doNext:^(NSString *letter) { + NSLog(@"%@", letter); + }] + then:^{ + return [@"1 2 3 4 5 6 7 8 9" componentsSeparatedByString:@" "].rac_sequence.signal; + }]; +``` + +This is most useful for executing all the side effects of one signal, then +starting another, and only returning the second signal's values. + +### Merging + +The [+merge:][RACSignal+Operations] method will forward the values from many +signals into a single stream, as soon as those values arrive: + +```objc +RACSubject *letters = [RACSubject subject]; +RACSubject *numbers = [RACSubject subject]; +RACSignal *merged = [RACSignal merge:@[ letters, numbers ]]; + +// Outputs: A 1 B C 2 +[merged subscribeNext:^(NSString *x) { + NSLog(@"%@", x); +}]; + +[letters sendNext:@"A"]; +[numbers sendNext:@"1"]; +[letters sendNext:@"B"]; +[letters sendNext:@"C"]; +[numbers sendNext:@"2"]; +``` + +### Combining latest values + +The [+combineLatest:][RACSignal+Operations] and `+combineLatest:reduce:` methods +will watch multiple signals for changes, and then send the latest values from +_all_ of them when a change occurs: + +```objc +RACSubject *letters = [RACSubject subject]; +RACSubject *numbers = [RACSubject subject]; +RACSignal *combined = [RACSignal + combineLatest:@[ letters, numbers ] + reduce:^(NSString *letter, NSString *number) { + return [letter stringByAppendingString:number]; + }]; + +// Outputs: B1 B2 C2 C3 +[combined subscribeNext:^(id x) { + NSLog(@"%@", x); +}]; + +[letters sendNext:@"A"]; +[letters sendNext:@"B"]; +[numbers sendNext:@"1"]; +[numbers sendNext:@"2"]; +[letters sendNext:@"C"]; +[numbers sendNext:@"3"]; +``` + +Note that the combined signal will only send its first value when all of the +inputs have sent at least one. In the example above, `@"A"` was never +forwarded because `numbers` had not sent a value yet. + +### Switching + +The [-switchToLatest][RACSignal+Operations] operator is applied to +a signal-of-signals, and always forwards the values from the latest signal: + +```objc +RACSubject *letters = [RACSubject subject]; +RACSubject *numbers = [RACSubject subject]; +RACSubject *signalOfSignals = [RACSubject subject]; + +RACSignal *switched = [signalOfSignals switchToLatest]; + +// Outputs: A B 1 D +[switched subscribeNext:^(NSString *x) { + NSLog(@"%@", x); +}]; + +[signalOfSignals sendNext:letters]; +[letters sendNext:@"A"]; +[letters sendNext:@"B"]; + +[signalOfSignals sendNext:numbers]; +[letters sendNext:@"C"]; +[numbers sendNext:@"1"]; + +[signalOfSignals sendNext:letters]; +[numbers sendNext:@"2"]; +[letters sendNext:@"D"]; +``` + +[Connections]: FrameworkOverview.md#connections +[RACSequence]: ../ReactiveCocoaFramework/ReactiveCocoa/RACSequence.h +[RACSignal]: ../ReactiveCocoaFramework/ReactiveCocoa/RACSignal.h +[RACSignal+Operations]: ../ReactiveCocoaFramework/ReactiveCocoa/RACSignal+Operations.h +[RACStream]: ../ReactiveCocoaFramework/ReactiveCocoa/RACStream.h +[Sequences]: FrameworkOverview.md#sequences +[Signals]: FrameworkOverview.md#signals +[Streams]: FrameworkOverview.md#streams +[Subscription]: FrameworkOverview.md#subscription
diff --git a/Documentation/DesignGuidelines.md b/Documentation/DesignGuidelines.md new file mode 100644 index 0000000..106e845 --- /dev/null +++ b/Documentation/DesignGuidelines.md
@@ -0,0 +1,751 @@ +# Design Guidelines + +This document contains guidelines for projects that want to make use of +ReactiveCocoa. The content here is heavily inspired by the [Rx Design +Guidelines](http://blogs.msdn.com/b/rxteam/archive/2010/10/28/rx-design-guidelines.aspx). + +This document assumes basic familiarity +with the features of ReactiveCocoa. The [Framework Overview][] is a better +resource for getting up to speed on the functionality provided by RAC. + +**[The RACSequence contract](#the-racsequence-contract)** + + 1. [Evaluation occurs lazily by default](#evaluation-occurs-lazily-by-default) + 1. [Evaluation blocks the caller](#evaluation-blocks-the-caller) + 1. [Side effects occur only once](#side-effects-occur-only-once) + +**[The RACSignal contract](#the-racsignal-contract)** + + 1. [Signal events are serialized](#signal-events-are-serialized) + 1. [Subscription will always occur on a scheduler](#subscription-will-always-occur-on-a-scheduler) + 1. [Errors are propagated immediately](#errors-are-propagated-immediately) + 1. [Side effects occur for each subscription](#side-effects-occur-for-each-subscription) + 1. [Subscriptions are automatically disposed upon completion or error](#subscriptions-are-automatically-disposed-upon-completion-or-error) + 1. [Disposal cancels in-progress work and cleans up resources](#disposal-cancels-in-progress-work-and-cleans-up-resources) + +**[Best practices](#best-practices)** + + 1. [Use descriptive declarations for methods and properties that return a signal](#use-descriptive-declarations-for-methods-and-properties-that-return-a-signal) + 1. [Indent stream operations consistently](#indent-stream-operations-consistently) + 1. [Use the same type for all the values of a stream](#use-the-same-type-for-all-the-values-of-a-stream) + 1. [Avoid retaining streams for too long](#avoid-retaining-streams-for-too-long) + 1. [Process only as much of a stream as needed](#process-only-as-much-of-a-stream-as-needed) + 1. [Deliver signal events onto a known scheduler](#deliver-signal-events-onto-a-known-scheduler) + 1. [Switch schedulers in as few places as possible](#switch-schedulers-in-as-few-places-as-possible) + 1. [Make the side effects of a signal explicit](#make-the-side-effects-of-a-signal-explicit) + 1. [Share the side effects of a signal by multicasting](#share-the-side-effects-of-a-signal-by-multicasting) + 1. [Debug streams by giving them names](#debug-streams-by-giving-them-names) + 1. [Avoid explicit subscriptions and disposal](#avoid-explicit-subscriptions-and-disposal) + 1. [Avoid using subjects when possible](#avoid-using-subjects-when-possible) + +**[Implementing new operators](#implementing-new-operators)** + + 1. [Prefer building on RACStream methods](#prefer-building-on-racstream-methods) + 1. [Compose existing operators when possible](#compose-existing-operators-when-possible) + 1. [Avoid introducing concurrency](#avoid-introducing-concurrency) + 1. [Cancel work and clean up all resources in a disposable](#cancel-work-and-clean-up-all-resources-in-a-disposable) + 1. [Do not block in an operator](#do-not-block-in-an-operator) + 1. [Avoid stack overflow from deep recursion](#avoid-stack-overflow-from-deep-recursion) + +## The RACSequence contract + +[RACSequence][] is a _pull-driven_ stream. Sequences behave similarly to +built-in collections, but with a few unique twists. + +### Evaluation occurs lazily by default + +Sequences are evaluated lazily by default. For example, in this sequence: + +```objc +NSArray *strings = @[ @"A", @"B", @"C" ]; +RACSequence *sequence = [strings.rac_sequence map:^(NSString *str) { + return [str stringByAppendingString:@"_"]; +}]; +``` + +… no string appending is actually performed until the values of the sequence are +needed. Accessing `sequence.head` will perform the concatenation of `A_`, +accessing `sequence.tail.head` will perform the concatenation of `B_`, and so +on. + +This generally avoids performing unnecessary work (since values that are never +used are never calculated), but means that sequence processing [should be +limited only to what's actually +needed](#process-only-as-much-of-a-stream-as-needed). + +Once evaluated, the values in a sequence are memoized and do not need to be +recalculated. Accessing `sequence.head` multiple times will only do the work of +one string concatenation. + +If lazy evaluation is undesirable – for instance, because limiting memory usage +is more important than avoiding unnecessary work – the +[eagerSequence][RACSequence] property can be used to force a sequence (and any +sequences derived from it afterward) to evaluate eagerly. + +### Evaluation blocks the caller + +Regardless of whether a sequence is lazy or eager, evaluation of any part of +a sequence will block the calling thread until completed. This is necessary +because values must be synchronously retrieved from a sequence. + +If evaluating a sequence is expensive enough that it might block the thread for +a significant amount of time, consider creating a signal with +[-signalWithScheduler:][RACSequence] and using that instead. + +### Side effects occur only once + +When the block passed to a sequence operator involves side effects, it is +important to realize that those side effects will only occur once per value +– namely, when the value is evaluated: + +```objc +NSArray *strings = @[ @"A", @"B", @"C" ]; +RACSequence *sequence = [strings.rac_sequence map:^(NSString *str) { + NSLog(@"%@", str); + return [str stringByAppendingString:@"_"]; +}]; + +// Logs "A" during this call. +NSString *concatA = sequence.head; + +// Logs "B" during this call. +NSString *concatB = sequence.tail.head; + +// Does not log anything. +NSString *concatB2 = sequence.tail.head; + +RACSequence *derivedSequence = [sequence map:^(NSString *str) { + return [@"_" stringByAppendingString:str]; +}]; + +// Still does not log anything, because "B_" was already evaluated, and the log +// statement associated with it will never be re-executed. +NSString *concatB3 = derivedSequence.tail.head; +``` + +## The RACSignal contract + +[RACSignal][] is a _push-driven_ stream with a focus on asynchronous event +delivery through _subscriptions_. For more information about signals and +subscriptions, see the [Framework Overview][]. + +### Signal events are serialized + +A signal may choose to deliver its events on any thread. Consecutive events are +even allowed to arrive on different threads or schedulers, unless explicitly +[delivered onto a particular +scheduler](#deliver-signal-events-onto-a-known-scheduler). + +However, RAC guarantees that no two signal events will ever arrive concurrently. +While an event is being processed, no other events will be delivered. The +senders of any other events will be forced to wait until the current event has +been handled. + +Most notably, this means that the blocks passed to +[-subscribeNext:error:completed:][RACSignal] do not need to be synchronized with +respect to each other, because they will never be invoked simultaneously. + +### Subscription will always occur on a scheduler + +To ensure consistent behavior for the `+createSignal:` and `-subscribe:` +methods, each [RACSignal][] subscription is guaranteed to take place on +a valid [RACScheduler][]. + +If the subscriber's thread already has a [+currentScheduler][RACScheduler], +scheduling takes place immediately; otherwise, scheduling occurs as soon as +possible on a background scheduler. Note that the main thread is always +associated with the [+mainThreadScheduler][RACScheduler], so subscription will +always be immediate there. + +See the documentation for [-subscribe:][RACSignal] for more information. + +### Errors are propagated immediately + +In RAC, `error` events have exception semantics. When an error is sent on +a signal, it will be immediately forwarded to all dependent signals, causing the +entire chain to terminate. + +[Operators][RACSignal+Operations] whose primary purpose is to change +error-handling behavior – like `-catch:`, `-catchTo:`, or `-materialize` – are +obviously not subject to this rule. + +### Side effects occur for each subscription + +Each new subscription to a [RACSignal][] will trigger its side effects. This +means that any side effects will happen as many times as subscriptions to the +signal itself. + +Consider this example: +```objc +__block int aNumber = 0; + +// Signal that will have the side effect of incrementing `aNumber` block +// variable for each subscription before sending it. +RACSignal *aSignal = [RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) { + aNumber++; + [subscriber sendNext:@(aNumber)]; + [subscriber sendCompleted]; + return nil; +}]; + +// This will print "subscriber one: 1" +[aSignal subscribeNext:^(id x) { + NSLog(@"subscriber one: %@", x); +}]; + +// This will print "subscriber two: 2" +[aSignal subscribeNext:^(id x) { + NSLog(@"subscriber two: %@", x); +}]; +``` + +Side effects are repeated for each subscription. The same applies to +[stream][RACStream] and [signal][RACSignal+Operations] operators: + +```objc +__block int missilesToLaunch = 0; + +// Signal that will have the side effect of changing `missilesToLaunch` on +// subscription. +RACSignal *processedSignal = [[RACSignal + return:@"missiles"] + map:^(id x) { + missilesToLaunch++; + return [NSString stringWithFormat:@"will launch %d %@", missilesToLaunch, x]; + }]; + +// This will print "First will launch 1 missiles" +[processedSignal subscribeNext:^(id x) { + NSLog(@"First %@", x); +}]; + +// This will print "Second will launch 2 missiles" +[processedSignal subscribeNext:^(id x) { + NSLog(@"Second %@", x); +}]; +``` + +To suppress this behavior and have multiple subscriptions to a signal execute +its side effects only once, a signal can be +[multicasted](#share-the-side-effects-of-a-signal-by-multicasting). + +Side effects can be insidious and produce problems that are difficult to +diagnose. For this reason it is suggested to +[make side effects explicit](#make-the-side-effects-of-a-signal-explicit) when +possible. + +### Subscriptions are automatically disposed upon completion or error + +When a [subscriber][RACSubscriber] is sent a `completed` or `error` event, the +associated subscription will automatically be disposed. This behavior usually +eliminates the need to manually dispose of subscriptions. + +See the [Memory Management][] document for more information about signal +lifetime. + +### Disposal cancels in-progress work and cleans up resources + +When a subscription is disposed, manually or automatically, any in-progress or +outstanding work associated with that subscription is gracefully cancelled as +soon as possible, and any resources associated with the subscription are cleaned +up. + +Disposing of the subscription to a signal representing a file upload, for +example, would cancel any in-flight network request, and free the file data from +memory. + +## Best practices + +The following recommendations are intended to help keep RAC-based code +predictable, understandable, and performant. + +They are, however, only guidelines. Use best judgement when determining whether +to apply the recommendations here to a given piece of code. + +### Use descriptive declarations for methods and properties that return a signal + +When a method or property has a return type of [RACSignal][], it can be +difficult to understand the signal's semantics at a glance. + +There are three key questions that can inform a declaration: + + 1. Is the signal _hot_ (already activated by the time it's returned to the + caller) or _cold_ (activated when subscribed to)? + 1. Will the signal include zero, one, or more values? + 1. Does the signal have side effects? + +**Hot signals without side effects** should typically be properties instead of +methods. The use of a property indicates that no initialization is needed before +subscribing to the signal's events, and that additional subscribers will not +change the semantics. Signal properties should usually be named after events +(e.g., `textChanged`). + +**Cold signals without side effects** should be returned from methods that have +noun-like names (e.g., `-currentText`). A method declaration indicates that the +signal might not be kept around, hinting that work is performed at the time of +subscription. If the signal sends multiple values, the noun should be pluralized +(e.g., `-currentModels`). + +**Signals with side effects** should be returned from methods that have +verb-like names (e.g., `-logIn`). The verb indicates that the method is not +idempotent and that callers must be careful to call it only when the side +effects are desired. If the signal will send one or more values, include a noun +that describes them (e.g., `-loadConfiguration`, `-fetchLatestEvents`). + +### Indent stream operations consistently + +It's easy for stream-heavy code to become very dense and confusing if not +properly formatted. Use consistent indentation to highlight where chains of +streams begin and end. + +When invoking a single method upon a stream, no additional indentation is +necessary (block arguments aside): + +```objc +RACStream *result = [stream startWith:@0]; + +RACStream *result2 = [stream map:^(NSNumber *value) { + return @(value.integerValue + 1); +}]; +``` + +When transforming the same stream multiple times, ensure that all of the +steps are aligned. Complex operators like [+zip:reduce:][RACStream] or +[+combineLatest:reduce:][RACSignal+Operations] may be split over multiple lines +for readability: + +```objc +RACStream *result = [[[RACStream + zip:@[ firstStream, secondStream ] + reduce:^(NSNumber *first, NSNumber *second) { + return @(first.integerValue + second.integerValue); + }] + filter:^ BOOL (NSNumber *value) { + return value.integerValue >= 0; + }] + map:^(NSNumber *value) { + return @(value.integerValue + 1); + }]; +``` + +Of course, streams nested within block arguments should start at the natural +indentation of the block: + +```objc +[[signal + then:^{ + @strongify(self); + + return [[self + doSomethingElse] + catch:^(NSError *error) { + @strongify(self); + [self presentError:error]; + + return [RACSignal empty]; + }]; + }] + subscribeCompleted:^{ + NSLog(@"All done."); + }]; +``` + +### Use the same type for all the values of a stream + +[RACStream][] (and, by extension, [RACSignal][] and [RACSequence][]) allows +streams to be composed of heterogenous objects, just like Cocoa collections do. +However, using different object types within the same stream complicates the use +of operators and +puts an additional burden on any consumers of that stream, who must be careful to +only invoke supported methods. + +Whenever possible, streams should only contain objects of the same type. + +### Avoid retaining streams for too long + +Retaining any [RACStream][] longer than it's needed will cause any dependencies +to be retained as well, potentially keeping memory usage much higher than it +would be otherwise. + +A [RACSequence][] should be retained only for as long as the `head` of the +sequence is needed. If the head will no longer be used, retain the `tail` of the +node instead of the node itself. + +See the [Memory Management][] guide for more information on object lifetime. + +### Process only as much of a stream as needed + +As well as [consuming additional +memory](#avoid-retaining-streams-for-too-long), unnecessarily +keeping a stream or [RACSignal][] subscription alive can result in increased CPU +usage, as unnecessary work is performed for results that will never be used. + +If only a certain number of values are needed from a stream, the +[-take:][RACStream] operator can be used to retrieve only that many values, and +then automatically terminate the stream immediately thereafter. + +Operators like `-take:` and [-takeUntil:][RACSignal+Operations] automatically propagate cancellation +up the stack as well. If nothing else needs the rest of the values, any +dependencies will be terminated too, potentially saving a significant amount of +work. + +### Deliver signal events onto a known scheduler + +When a signal is returned from a method, or combined with such a signal, it can +be difficult to know which thread events will be delivered upon. Although +events are [guaranteed to be serial](#signal-events-are-serialized), sometimes +stronger guarantees are needed, like when performing UI updates (which must +occur on the main thread). + +Whenever such a guarantee is important, the [-deliverOn:][RACSignal+Operations] +operator should be used to force a signal's events to arrive on a specific +[RACScheduler][]. + +### Switch schedulers in as few places as possible + +Notwithstanding the above, events should only be delivered to a specific +[scheduler][RACScheduler] when absolutely necessary. Switching schedulers can +introduce unnecessary delays and cause an increase in CPU load. + +Generally, the use of [-deliverOn:][RACSignal+Operations] should be restricted +to the end of a signal chain – e.g., before subscription, or before the values +are bound to a property. + +### Make the side effects of a signal explicit + +As much as possible, [RACSignal][] side effects should be avoided, because +subscribers may find the [behavior of side +effects](#side-effects-occur-for-each-subscription) unexpected. + +However, because Cocoa is predominantly imperative, it is sometimes useful to +perform side effects when signal events occur. Although most [RACStream][] and +[RACSignal][RACSignal+Operations] operators accept arbitrary blocks (which can +contain side effects), the use of `-doNext:`, `-doError:`, and `-doCompleted:` +will make side effects more explicit and self-documenting: + +```objc +NSMutableArray *nexts = [NSMutableArray array]; +__block NSError *receivedError = nil; +__block BOOL success = NO; + +RACSignal *bookkeepingSignal = [[[valueSignal + doNext:^(id x) { + [nexts addObject:x]; + }] + doError:^(NSError *error) { + receivedError = error; + }] + doCompleted:^{ + success = YES; + }]; + +RAC(self, value) = bookkeepingSignal; +``` + +### Share the side effects of a signal by multicasting + +[Side effects occur for each +subscription](#side-effects-occur-for-each-subscription) by default, but there +are certain situations where side effects should only occur once – for example, +a network request typically should not be repeated when a new subscriber is +added. + +The `-publish` and `-multicast:` operators of [RACSignal][RACSignal+Operations] +allow a single subscription to be shared to any number of subscribers by using +a [RACMulticastConnection][]: + +```objc +// This signal starts a new request on each subscription. +RACSignal *networkRequest = [RACSignal createSignal:^(id<RACSubscriber> subscriber) { + AFHTTPRequestOperation *operation = [client + HTTPRequestOperationWithRequest:request + success:^(AFHTTPRequestOperation *operation, id response) { + [subscriber sendNext:response]; + [subscriber sendCompleted]; + } + failure:^(AFHTTPRequestOperation *operation, NSError *error) { + [subscriber sendError:error]; + }]; + + [client enqueueHTTPRequestOperation:operation]; + return [RACDisposable disposableWithBlock:^{ + [operation cancel]; + }]; +}]; + +// Starts a single request, no matter how many subscriptions `connection.signal` +// gets. This is equivalent to the -replay operator, or similar to +// +startEagerlyWithScheduler:block:. +RACMulticastConnection *connection = [networkRequest multicast:[RACReplaySubject subject]]; +[connection connect]; + +[connection.signal subscribeNext:^(id response) { + NSLog(@"subscriber one: %@", response); +}]; + +[connection.signal subscribeNext:^(id response) { + NSLog(@"subscriber two: %@", response); +}]; +``` + +### Debug streams by giving them names + +Every [RACStream][] has a `name` property to assist with debugging. A stream's +`-description` includes its name, and all operators provided by RAC will +automatically add to the name. This usually makes it possible to identify +a stream from its default name alone. + +For example, this snippet: + +```objc +RACSignal *signal = [[[RACObserve(self, username) + distinctUntilChanged] + take:3] + filter:^(NSString *newUsername) { + return [newUsername isEqualToString:@"joshaber"]; + }]; + +NSLog(@"%@", signal); +``` + +… would log a name similar to `[[[RACObserve(self, username)] -distinctUntilChanged] +-take: 3] -filter:`. + +Names can also be manually applied by using [-setNameWithFormat:][RACStream]. + +[RACSignal][] also offers `-logNext`, `-logError`, +`-logCompleted`, and `-logAll` methods, which will automatically log signal +events as they occur, and include the name of the signal in the messages. This +can be used to conveniently inspect a signal in real-time. + +### Avoid explicit subscriptions and disposal + +Although [-subscribeNext:error:completed:][RACSignal] and its variants are the +most basic way to process a signal, their use can complicate code by +being less declarative, encouraging the use of side effects, and potentially +duplicating built-in functionality. + +Likewise, explicit use of the [RACDisposable][] class can quickly lead to +a rat's nest of resource management and cleanup code. + +There are almost always higher-level patterns that can be used instead of manual +subscriptions and disposal: + + * The [RAC()][RAC] or [RACChannelTo()][RACChannelTo] macros can be used to bind + a signal to a property, instead of performing manual updates when changes + occur. + * The [-rac_liftSelector:withSignals:][NSObject+RACLifting] method can be used + to automatically invoke a selector when one or more signals fire. + * Operators like [-takeUntil:][RACSignal+Operations] can be used to + automatically dispose of a subscription when an event occurs (like a "Cancel" + button being pressed in the UI). + +Generally, the use of built-in [stream][RACStream] and +[signal][RACSignal+Operations] operators will lead to simpler and less +error-prone code than replicating the same behaviors in a subscription callback. + +### Avoid using subjects when possible + +[Subjects][] are a powerful tool for bridging imperative code +into the world of signals, but, as the "mutable variables" of RAC, they can +quickly lead to complexity when overused. + +Since they can be manipulated from anywhere, at any time, subjects often break +the linear flow of stream processing and make logic much harder to follow. They +also don't support meaningful +[disposal](#disposal-cancels-in-progress-work-and-cleans-up-resources), which +can result in unnecessary work. + +Subjects can usually be replaced with other patterns from ReactiveCocoa: + + * Instead of feeding initial values into a subject, consider generating the + values in a [+createSignal:][RACSignal] block instead. + * Instead of delivering intermediate results to a subject, try combining the + output of multiple signals with operators like + [+combineLatest:][RACSignal+Operations] or [+zip:][RACStream]. + * Instead of using subjects to share results with multiple subscribers, + [multicast](#share-the-side-effects-of-a-signal-by-multicasting) a base + signal instead. + * Instead of implementing an action method which simply controls a subject, use + a [command][RACCommand] or + [-rac_signalForSelector:][NSObject+RACSelectorSignal] instead. + +When subjects _are_ necessary, they should almost always be the "base" input +for a signal chain, not used in the middle of one. + +## Implementing new operators + +RAC provides a long list of built-in operators for [streams][RACStream] and +[signals][RACSignal+Operations] that should cover most use cases; however, RAC +is not a closed system. It's entirely valid to implement additional operators +for specialized uses, or for consideration in ReactiveCocoa itself. + +Implementing a new operator requires a careful attention to detail and a focus +on simplicity, to avoid introducing bugs into the calling code. + +These guidelines cover some of the common pitfalls and help preserve the +expected API contracts. + +### Prefer building on RACStream methods + +[RACStream][] offers a simpler interface than [RACSequence][] and [RACSignal][], +and all stream operators are automatically applicable to sequences and signals +as well. + +For these reasons, new operators should be implemented using only [RACStream][] +methods whenever possible. The minimal required methods of the class, including +`-bind:`, `+zipWith:`, and `-concat:`, are quite powerful, and many tasks can +be accomplished without needing anything else. + +If a new [RACSignal][] operator needs to handle `error` and `completed` events, +consider using the [-materialize][RACSignal+Operations] method to bring the +events into the stream. All of the events of a materialized signal can be +manipulated by stream operators, which helps minimize the use of non-stream +operators. + +### Compose existing operators when possible + +Considerable thought has been put into the operators provided by RAC, and they +have been validated through automated tests and through their real world use in +other projects. An operator that has been written from scratch may not be as +robust, or might not handle a special case that the built-in operators are aware +of. + +To minimize duplication and possible bugs, use the provided operators as much as +possible in a custom operator implementation. Generally, there should be very +little code written from scratch. + +### Avoid introducing concurrency + +Concurrency is an extremely common source of bugs in programming. To minimize +the potential for deadlocks and race conditions, operators should not +concurrently perform their work. + +Callers always have the ability to subscribe or deliver events on a specific +[RACScheduler][], and RAC offers powerful ways to [parallelize +work][Parallelizing Independent Work] without making operators unnecessarily +complex. + +### Cancel work and clean up all resources in a disposable + +When implementing a signal with the [+createSignal:][RACSignal] method, the +provided block is expected to return a [RACDisposable][]. This disposable +should: + + * As soon as it is convenient, gracefully cancel any in-progress work that was + started by the signal. + * Immediately dispose of any subscriptions to other signals, thus triggering + their cancellation and cleanup code as well. + * Release any memory or other resources that were allocated by the signal. + +This helps fulfill [the RACSignal +contract](#disposal-cancels-in-progress-work-and-cleans-up-resources). + +### Do not block in an operator + +Stream operators should return a new stream more-or-less immediately. Any work +that the operator needs to perform should be part of evaluating the new stream, +_not_ part of the operator invocation itself. + +```objc +// WRONG! +- (RACSequence *)map:(id (^)(id))block { + RACSequence *result = [RACSequence empty]; + for (id obj in self) { + id mappedObj = block(obj); + result = [result concat:[RACSequence return:mappedObj]]; + } + + return result; +} + +// Right! +- (RACSequence *)map:(id (^)(id))block { + return [self flattenMap:^(id obj) { + id mappedObj = block(obj); + return [RACSequence return:mappedObj]; + }]; +} +``` + +This guideline can be safely ignored when the purpose of an operator is to +synchronously retrieve one or more values from a stream (like +[-first][RACSignal+Operations]). + +### Avoid stack overflow from deep recursion + +Any operator that might recurse indefinitely should use the +`-scheduleRecursiveBlock:` method of [RACScheduler][]. This method will +transform recursion into iteration instead, preventing a stack overflow. + +For example, this would be an incorrect implementation of +[-repeat][RACSignal+Operations], due to its potential to overflow the call stack +and cause a crash: + +```objc +- (RACSignal *)repeat { + return [RACSignal createSignal:^(id<RACSubscriber> subscriber) { + RACCompoundDisposable *compoundDisposable = [RACCompoundDisposable compoundDisposable]; + + __block void (^resubscribe)(void) = ^{ + RACDisposable *disposable = [self subscribeNext:^(id x) { + [subscriber sendNext:x]; + } error:^(NSError *error) { + [subscriber sendError:error]; + } completed:^{ + resubscribe(); + }]; + + [compoundDisposable addDisposable:disposable]; + }; + + return compoundDisposable; + }]; +} +``` + +By contrast, this version will avoid a stack overflow: + +```objc +- (RACSignal *)repeat { + return [RACSignal createSignal:^(id<RACSubscriber> subscriber) { + RACCompoundDisposable *compoundDisposable = [RACCompoundDisposable compoundDisposable]; + + RACScheduler *scheduler = RACScheduler.currentScheduler ?: [RACScheduler scheduler]; + RACDisposable *disposable = [scheduler scheduleRecursiveBlock:^(void (^reschedule)(void)) { + RACDisposable *disposable = [self subscribeNext:^(id x) { + [subscriber sendNext:x]; + } error:^(NSError *error) { + [subscriber sendError:error]; + } completed:^{ + reschedule(); + }]; + + [compoundDisposable addDisposable:disposable]; + }]; + + [compoundDisposable addDisposable:disposable]; + return compoundDisposable; + }]; +} +``` + +[Framework Overview]: FrameworkOverview.md +[Memory Management]: MemoryManagement.md +[NSObject+RACLifting]: ../ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACLifting.h +[NSObject+RACSelectorSignal]: ../ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACSelectorSignal.h +[RAC]: ../ReactiveCocoaFramework/ReactiveCocoa/RACSubscriptingAssignmentTrampoline.h +[RACChannelTo]: ../ReactiveCocoaFramework/ReactiveCocoa/RACKVOChannel.h +[RACCommand]: ../ReactiveCocoaFramework/ReactiveCocoa/RACCommand.h +[RACDisposable]: ../ReactiveCocoaFramework/ReactiveCocoa/RACDisposable.h +[RACEvent]: ../ReactiveCocoaFramework/ReactiveCocoa/RACEvent.h +[RACMulticastConnection]: ../ReactiveCocoaFramework/ReactiveCocoa/RACMulticastConnection.h +[RACObserve]: ../ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACPropertySubscribing.h +[RACScheduler]: ../ReactiveCocoaFramework/ReactiveCocoa/RACScheduler.h +[RACSequence]: ../ReactiveCocoaFramework/ReactiveCocoa/RACSequence.h +[RACSignal]: ../ReactiveCocoaFramework/ReactiveCocoa/RACSignal.h +[RACSignal+Operations]: ../ReactiveCocoaFramework/ReactiveCocoa/RACSignal+Operations.h +[RACStream]: ../ReactiveCocoaFramework/ReactiveCocoa/RACStream.h +[RACSubscriber]: ../ReactiveCocoaFramework/ReactiveCocoa/RACSubscriber.h +[Subjects]: FrameworkOverview.md#subjects +[Parallelizing Independent Work]: ../README.md#parallelizing-independent-work
diff --git a/Documentation/DifferencesFromRx.md b/Documentation/DifferencesFromRx.md new file mode 100644 index 0000000..6e94e64 --- /dev/null +++ b/Documentation/DifferencesFromRx.md
@@ -0,0 +1,59 @@ +# Differences from Rx + +ReactiveCocoa (RAC) is significantly inspired by .NET's [Reactive +Extensions](http://msdn.microsoft.com/en-us/data/gg577609.aspx) (Rx), but it is not +a direct port. Some concepts or interfaces presented in RAC may be initially +confusing to a developer already familiar with Rx, but it's usually possible to +express the same algorithms. + +Some of the differences, like the naming of methods and classes, are meant to +keep RAC in line with existing Cocoa conventions. Other differences are intended +as improvements over Rx, or may be inspired by other functional reactive +programming paradigms (like the [Elm programming +language](http://elm-lang.org)). + +Here, we'll attempt to document the high-level differences between RAC and Rx. + +## Interfaces + +RAC does not offer protocols that correspond to the `IEnumerable` and +`IObservable` interfaces in .NET. Instead, the functionality is covered by three +main classes: + + * **[RACStream](https://github.com/ReactiveCocoa/ReactiveCocoa/blob/master/ReactiveCocoaFramework/ReactiveCocoa/RACStream.h)** + is an abstract class that implements stream operations using a few basic + primitives. The equivalents to generic LINQ operators can generally be found + on this class. + * **[RACSignal](https://github.com/ReactiveCocoa/ReactiveCocoa/blob/master/ReactiveCocoaFramework/ReactiveCocoa/RACSignal.h)** + is a concrete subclass of `RACStream` that implements a _push-driven_ stream, + much like `IObservable`. Time-based operators, or methods dealing with the + `completed` and `error` events, can be found on this class or in the + [RACSignal+Operations](https://github.com/ReactiveCocoa/ReactiveCocoa/blob/master/ReactiveCocoaFramework/ReactiveCocoa/RACSignal%2BOperations.h) + category upon it. + * **[RACSequence](https://github.com/ReactiveCocoa/ReactiveCocoa/blob/master/ReactiveCocoaFramework/ReactiveCocoa/RACSequence.h)** + is a concrete subclass of `RACStream` that implements a _pull-driven_ stream, + much like `IEnumerable`. + +## Names of Stream Operations + +RAC generally uses LINQ-style naming for its stream methods. Most of the +exceptions are inspired by significantly better alternatives in Haskell or Elm. + +Notable differences include: + + * `-map:` instead of `Select` + * `-filter:` instead of `Where` + * `-flatten` instead of `Merge` + * `-flattenMap:` instead of `SelectMany` + +LINQ operators that go by different names in RAC (but behave more or less +equivalently) will be referenced from method documentation, like so: + +```objc +// Maps `block` across the values in the receiver. +// +// This corresponds to the `Select` method in Rx. +// +// Returns a new stream with the mapped values. +- (instancetype)map:(id (^)(id value))block; +```
diff --git a/Documentation/FrameworkOverview.md b/Documentation/FrameworkOverview.md new file mode 100644 index 0000000..174303d --- /dev/null +++ b/Documentation/FrameworkOverview.md
@@ -0,0 +1,216 @@ +# Framework Overview + +This document contains a high-level description of the different components +within the ReactiveCocoa framework, and an attempt to explain how they work +together and divide responsibilities. This is meant to be a starting point for +learning about new modules and finding more specific documentation. + +For examples and help understanding how to use RAC, see the [README][] or +the [Design Guidelines][]. + +## Streams + +A **stream**, represented by the [RACStream][] abstract class, is any series of +object values. + +Values may be available immediately or in the future, but must be retrieved +sequentially. There is no way to retrieve the second value of a stream without +evaluating or waiting for the first value. + +Streams are [monads][]. Among other things, this allows complex operations to be +built on a few basic primitives (`-bind:` in particular). [RACStream][] also +implements the equivalent of the [Monoid][] and [MonadZip][] typeclasses from +[Haskell][]. + +[RACStream][] isn't terribly useful on its own. Most streams are treated as +[signals](#signals) or [sequences](#sequences) instead. + +## Signals + +A **signal**, represented by the [RACSignal][] class, is a _push-driven_ +[stream](#streams). + +Signals generally represent data that will be delivered in the future. As work +is performed or data is received, values are _sent_ on the signal, which pushes +them out to any subscribers. Users must [subscribe](#subscription) to a signal +in order to access its values. + +Signals send three different types of events to their subscribers: + + * The **next** event provides a new value from the stream. [RACStream][] + methods only operate on events of this type. Unlike Cocoa collections, it is + completely valid for a signal to include `nil`. + * The **error** event indicates that an error occurred before the signal could + finish. The event may include an `NSError` object that indicates what went + wrong. Errors must be handled specially – they are not included in the + stream's values. + * The **completed** event indicates that the signal finished successfully, and + that no more values will be added to the stream. Completion must be handled + specially – it is not included in the stream of values. + +The lifetime of a signal consists of any number of `next` events, followed by +one `error` or `completed` event (but not both). + +### Subscription + +A **subscriber** is anything that is waiting or capable of waiting for events +from a [signal](#signals). Within RAC, a subscriber is represented as any object +that conforms to the [RACSubscriber][] protocol. + +A **subscription** is created through any call to +[-subscribeNext:error:completed:][RACSignal], or one of the corresponding +convenience methods. Technically, most [RACStream][] and +[RACSignal][RACSignal+Operations] operators create subscriptions as well, but +these intermediate subscriptions are usually an implementation detail. + +Subscriptions [retain their signals][Memory Management], and are automatically +disposed of when the signal completes or errors. Subscriptions can also be +[disposed of manually](#disposables). + +### Subjects + +A **subject**, represented by the [RACSubject][] class, is a [signal](#signals) +that can be manually controlled. + +Subjects can be thought of as the "mutable" variant of a signal, much like +`NSMutableArray` is for `NSArray`. They are extremely useful for bridging +non-RAC code into the world of signals. + +For example, instead of handling application logic in block callbacks, the +blocks can simply send events to a shared subject instead. The subject can then +be returned as a [RACSignal][], hiding the implementation detail of the +callbacks. + +Some subjects offer additional behaviors as well. In particular, +[RACReplaySubject][] can be used to buffer events for future +[subscribers](#subscription), like when a network request finishes before +anything is ready to handle the result. + +### Commands + +A **command**, represented by the [RACCommand][] class, creates and subscribes +to a signal in response to some action. This makes it easy to perform +side-effecting work as the user interacts with the app. + +Usually the action triggering a command is UI-driven, like when a button is +clicked. Commands can also be automatically disabled based on a signal, and this +disabled state can be represented in a UI by disabling any controls associated +with the command. + +On OS X, RAC adds a `rac_command` property to +[NSButton][NSButton+RACCommandSupport] for setting up these behaviors +automatically. + +### Connections + +A **connection**, represented by the [RACMulticastConnection][] class, is +a [subscription](#subscription) that is shared between any number of +subscribers. + +[Signals](#signals) are _cold_ by default, meaning that they start doing work +_each_ time a new subscription is added. This behavior is usually desirable, +because it means that data will be freshly recalculated for each subscriber, but +it can be problematic if the signal has side effects or the work is expensive +(for example, sending a network request). + +A connection is created through the `-publish` or `-multicast:` methods on +[RACSignal][RACSignal+Operations], and ensures that only one underlying +subscription is created, no matter how many times the connection is subscribed +to. Once connected, the connection's signal is said to be _hot_, and the +underlying subscription will remain active until _all_ subscriptions to the +connection are [disposed](#disposables). + +## Sequences + +A **sequence**, represented by the [RACSequence][] class, is a _pull-driven_ +[stream](#streams). + +Sequences are a kind of collection, similar in purpose to `NSArray`. Unlike +an array, the values in a sequence are evaluated _lazily_ (i.e., only when they +are needed) by default, potentially improving performance if only part of +a sequence is used. Just like Cocoa collections, sequences cannot contain `nil`. + +Sequences are similar to [Clojure's sequences][seq] ([lazy-seq][] in particular), or +the [List][] type in [Haskell][]. + +RAC adds a `-rac_sequence` method to most of Cocoa's collection classes, +allowing them to be used as [RACSequences][RACSequence] instead. + +## Disposables + +The **[RACDisposable][]** class is used for cancellation and resource cleanup. + +Disposables are most commonly used to unsubscribe from a [signal](#signals). +When a [subscription](#subscription) is disposed, the corresponding subscriber +will not receive _any_ further events from the signal. Additionally, any work +associated with the subscription (background processing, network requests, etc.) +will be cancelled, since the results are no longer needed. + +For more information about cancellation, see the RAC [Design Guidelines][]. + +## Schedulers + +A **scheduler**, represented by the [RACScheduler][] class, is a serial +execution queue for [signals](#signals) to perform work or deliver their results upon. + +Schedulers are similar to Grand Central Dispatch queues, but schedulers support +cancellation (via [disposables](#disposables)), and always execute serially. +With the exception of the [+immediateScheduler][RACScheduler], schedulers do not +offer synchronous execution. This helps avoid deadlocks, and encourages the use +of [signal operators][RACSignal+Operations] instead of blocking work. + +[RACScheduler][] is also somewhat similar to `NSOperationQueue`, but schedulers +do not allow tasks to be reordered or depend on one another. + +## Value types + +RAC offers a few miscellaneous classes for conveniently representing values in +a [stream](#streams): + + * **[RACTuple][]** is a small, constant-sized collection that can contain + `nil` (represented by `RACTupleNil`). It is generally used to represent + the combined values of multiple streams. + * **[RACUnit][]** is a singleton "empty" value. It is used as a value in + a stream for those times when more meaningful data doesn't exist. + * **[RACEvent][]** represents any [signal event](#signals) as a single value. + It is primarily used by the `-materialize` method of + [RACSignal][RACSignal+Operations]. + +## Asynchronous Backtraces + +Because RAC-based code often involves asynchronous work and queue-hopping, the +framework supports [capturing asynchronous backtraces][RACBacktrace] to make debugging +easier. + +On OS X, backtraces can be automatically captured from any code, including +system libraries. + +On iOS, only queue hops from within RAC and your project will be captured (but +the information is still valuable). + +[Design Guidelines]: DesignGuidelines.md +[Haskell]: http://www.haskell.org +[lazy-seq]: http://clojure.github.com/clojure/clojure.core-api.html#clojure.core/lazy-seq +[List]: http://www.haskell.org/ghc/docs/latest/html/libraries/base-4.6.0.1/Data-List.html +[Memory Management]: MemoryManagement.md +[monads]: http://en.wikipedia.org/wiki/Monad_(functional_programming) +[Monoid]: http://www.haskell.org/ghc/docs/latest/html/libraries/base-4.6.0.1/Data-Monoid.html#t:Monoid +[MonadZip]: http://www.haskell.org/ghc/docs/latest/html/libraries/base-4.6.0.1/Control-Monad-Zip.html#t:MonadZip +[NSButton+RACCommandSupport]: ../ReactiveCocoaFramework/ReactiveCocoa/NSButton+RACCommandSupport.h +[RACBacktrace]: ../ReactiveCocoaFramework/ReactiveCocoa/RACBacktrace.h +[RACCommand]: ../ReactiveCocoaFramework/ReactiveCocoa/RACCommand.h +[RACDisposable]: ../ReactiveCocoaFramework/ReactiveCocoa/RACDisposable.h +[RACEvent]: ../ReactiveCocoaFramework/ReactiveCocoa/RACEvent.h +[RACMulticastConnection]: ../ReactiveCocoaFramework/ReactiveCocoa/RACMulticastConnection.h +[RACReplaySubject]: ../ReactiveCocoaFramework/ReactiveCocoa/RACReplaySubject.h +[RACScheduler]: ../ReactiveCocoaFramework/ReactiveCocoa/RACScheduler.h +[RACSequence]: ../ReactiveCocoaFramework/ReactiveCocoa/RACSequence.h +[RACSignal]: ../ReactiveCocoaFramework/ReactiveCocoa/RACSignal.h +[RACSignal+Operations]: ../ReactiveCocoaFramework/ReactiveCocoa/RACSignal+Operations.h +[RACStream]: ../ReactiveCocoaFramework/ReactiveCocoa/RACStream.h +[RACSubject]: ../ReactiveCocoaFramework/ReactiveCocoa/RACSubject.h +[RACSubscriber]: ../ReactiveCocoaFramework/ReactiveCocoa/RACSubscriber.h +[RACTuple]: ../ReactiveCocoaFramework/ReactiveCocoa/RACTuple.h +[RACUnit]: ../ReactiveCocoaFramework/ReactiveCocoa/RACUnit.h +[README]: ../README.md +[seq]: http://clojure.org/sequences
diff --git a/Documentation/MemoryManagement.md b/Documentation/MemoryManagement.md new file mode 100644 index 0000000..e442b1f --- /dev/null +++ b/Documentation/MemoryManagement.md
@@ -0,0 +1,139 @@ +# Memory Management + +ReactiveCocoa's memory management is quite complex, but the end result is that +**you don't need to retain signals in order to process them**. + +If the framework required you to retain every signal, it'd be much more unwieldy +to use, especially for one-shot signals that are used like futures (e.g., +network requests). You'd have to save any long-lived signal into a property, and +then also make sure to clear it out when you're done with it. Not fun. + +## Subscribers + +Before going any further, it's worth noting that +`subscribeNext:error:completed:` (and all variants thereof) create an _implicit_ +subscriber using the given blocks. Any objects referenced from those blocks will +therefore be retained as part of the subscription. Just like any other object, +`self` won't be retained without a direct or indirect reference to it. + +## Finite or Short-Lived Signals + +The most important guideline to RAC memory management is that a **subscription +is automatically terminated upon completion or error, and the subscriber +removed**. + +For example, if you have some code like this in your view controller: + +```objc +self.disposable = [signal subscribeCompleted:^{ + doSomethingPossiblyInvolving(self); +}]; +``` + +… the memory management will look something like the following: + +``` +view controller -> RACDisposable -> RACSignal -> RACSubscriber -> view controller +``` + +However, the `RACSignal -> RACSubscriber` relationship is torn down as soon as +`signal` finishes, breaking the retain cycle. + +**This is often all you need**, because the lifetime of the `RACSignal` in +memory will naturally match the logical lifetime of the event stream. + +## Infinite Signals + +Infinite signals (or signals that live so long that they might as well be +infinite), however, will never tear down naturally. This is where disposables +shine. + +**Disposing of a subscription will remove the associated subscriber**, and just +generally clean up any resources associated with that subscription. To that one +subscriber, it's just as if the signal had completed or errored, except no final +event is sent on the signal. All other subscribers will remain intact. + +However, as a general rule of thumb, if you have to manually manage +a subscription's lifecycle, [there's probably a better way to do what you want][avoid-explicit-subscriptions-and-disposal]. + +## Signals Derived from `self` + +There's still a bit of a tricky middle case here, though. Any time a signal's +lifetime is tied to the calling scope, you'll have a much harder cycle to break. + +This commonly occurs when using `RACObserve()` on a key +path that's relative to `self`, and then applying a block that needs to capture +`self`. + +The easiest answer here is just to **capture `self` weakly**: + +```objc +__weak id weakSelf = self; +[RACObserve(self, username) subscribeNext:^(NSString *username) { + id strongSelf = weakSelf; + [strongSelf validateUsername]; +}]; +``` + +Or, after importing the included +[EXTScope.h](https://github.com/jspahrsummers/libextobjc/blob/master/extobjc/EXTScope.h) +header: + +```objc +@weakify(self); +[RACObserve(self, username) subscribeNext:^(NSString *username) { + @strongify(self); + [self validateUsername]; +}]; +``` + +*(Replace `__weak` or `@weakify` with `__unsafe_unretained` or `@unsafeify`, +respectively, if the object doesn't support weak references.)* + +However, [there's probably a better pattern you could use instead][avoid-explicit-subscriptions-and-disposal]. For +example, the above sample could perhaps be written like: + +```objc +[self rac_liftSelector:@selector(validateUsername:) withSignals:RACObserve(self, username), nil]; +``` + +or: + +```objc +RACSignal *validated = [RACObserve(self, username) map:^(NSString *username) { + // Put validation logic here. + return @YES; +}]; +``` + +As with infinite signals, there are generally ways you can avoid referencing +`self` (or any object) from blocks in a signal chain. + +---- + +The above information is really all you should need in order to use +ReactiveCocoa effectively. However, there's one more point to address, just for +the technically curious or for anyone interested in contributing to RAC. + +The design goal of "no retaining necessary" begs the question: how do we know +when a signal should be deallocated? What if it was just created, escaped an +autorelease pool, and hasn't been retained yet? + +The real answer is _we don't_, BUT we can usually assume that the caller will +retain the signal within the current run loop iteration if they want to keep it. + +Consequently: + + 1. A created signal is automatically added to a global set of active signals. + 2. The signal will wait for a single pass of the main run loop, and then remove + itself from the active set _if it has no subscribers_. Unless the signal was + retained somehow, it would deallocate at this point. + 3. If something did subscribe in that run loop iteration, the signal stays in + the set. + 4. Later, when all the subscribers are gone, step 2 is triggered again. + +This could backfire if the run loop is spun recursively (like in a modal event +loop on OS X), but it makes the life of the framework consumer much easier for +most or all other cases. + +[avoid-explicit-subscriptions-and-disposal]: DesignGuidelines.md#avoid-explicit-subscriptions-and-disposal
diff --git a/Documentation/README.md b/Documentation/README.md new file mode 100644 index 0000000..4e0d4ed --- /dev/null +++ b/Documentation/README.md
@@ -0,0 +1,2 @@ +This folder contains conceptual documentation and design guidelines that don't +fit well on a single class or in any specific header file.
diff --git a/Instruments/Disposable Growth.tracetemplate b/Instruments/Disposable Growth.tracetemplate new file mode 100644 index 0000000..24dc61c --- /dev/null +++ b/Instruments/Disposable Growth.tracetemplate Binary files differ
diff --git a/Instruments/README.md b/Instruments/README.md new file mode 100644 index 0000000..e2f1d4a --- /dev/null +++ b/Instruments/README.md
@@ -0,0 +1,14 @@ +This folder contains Instruments templates to make it easier to debug +code using ReactiveCocoa. + +To get started with a template, simply double-click it. + +### Signal Names + +The `name` property of `RACSignal` requires that the `RAC_DEBUG_SIGNAL_NAMES` +environment variable be set, which means that you won't have access to +meaningful names in Instruments by default. + +To add signal names, open your application's scheme in Xcode, select the Profile +action, and add `RAC_DEBUG_SIGNAL_NAMES` with a value of `1` to the list of +environment variables.
diff --git a/Instruments/Signal Events.tracetemplate b/Instruments/Signal Events.tracetemplate new file mode 100644 index 0000000..4c90d88 --- /dev/null +++ b/Instruments/Signal Events.tracetemplate Binary files differ
diff --git a/LICENSE.md b/LICENSE.md new file mode 100644 index 0000000..56cda91 --- /dev/null +++ b/LICENSE.md
@@ -0,0 +1,19 @@ +**Copyright (c) 2012 - 2014, GitHub, Inc.** +**All rights reserved.** + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software is furnished to do so, +subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/README.md b/README.md new file mode 100644 index 0000000..c919c15 --- /dev/null +++ b/README.md
@@ -0,0 +1,562 @@ +# ReactiveCocoa + +ReactiveCocoa (RAC) is an Objective-C framework for [Functional Reactive +Programming][]. It provides APIs for **composing and transforming streams of +values**. + +If you're already familiar with functional reactive programming or know the basic +premise of ReactiveCocoa, check out the [Documentation][] folder for a framework +overview and more in-depth information about how it all works in practice. + +## New to ReactiveCocoa? + +ReactiveCocoa is documented like crazy, and there's a wealth of introductory +material available to explain what RAC is and how you can use it. + +If you want to learn more, we recommend these resources, roughly in order: + + 1. [Introduction](#introduction) + 1. [When to use ReactiveCocoa](#when-to-use-reactivecocoa) + 1. [Framework Overview][] + 1. [Basic Operators][] + 1. [Header documentation](ReactiveCocoaFramework/ReactiveCocoa) + 1. Previously answered [Stack Overflow](https://github.com/ReactiveCocoa/ReactiveCocoa/wiki) + questions and [GitHub issues](https://github.com/ReactiveCocoa/ReactiveCocoa/issues?labels=question&state=closed) + 1. The rest of the [Documentation][] folder + 1. [Functional Reactive Programming on iOS](https://leanpub.com/iosfrp/) + (eBook) + +If you have any further questions, please feel free to [file an issue](https://github.com/ReactiveCocoa/ReactiveCocoa/issues/new). + +## Introduction + +ReactiveCocoa is an implementation of [functional reactive +programming](http://blog.maybeapps.com/post/42894317939/input-and-output). +Rather than using mutable variables which are replaced and modified in-place, +RAC provides signals (represented by `RACSignal`) that capture present and +future values. + +By chaining, combining, and reacting to signals, software can be written +declaratively, without the need for code that continually observes and updates +values. + +For example, a text field can be bound to the latest time, even as it changes, +instead of using additional code that watches the clock and updates the +text field every second. It works much like KVO, but with blocks instead of +overriding `-observeValueForKeyPath:ofObject:change:context:`. + +Signals can also represent asynchronous operations, much like [futures and +promises][]. This greatly simplifies asynchronous software, including networking +code. + +One of the major advantages of RAC is that it provides a single, unified +approach to dealing with asynchronous behaviors, including delegate methods, +callback blocks, target-action mechanisms, notifications, and KVO. + +Here's a simple example: + +```objc +// When self.username changes, log the new name to the console. +// +// RACObserve(self, username) creates a new RACSignal that sends the current +// value of self.username, then the new value whenever it changes. +// -subscribeNext: will execute the block whenever the signal sends a value. +[RACObserve(self, username) subscribeNext:^(NSString *newName) { + NSLog(@"%@", newName); +}]; +``` + +But unlike KVO notifications, signals can be chained together and operated on: + +```objc +// Only log names that start with "j". +// +// -filter returns a new RACSignal that only sends a new value when its block +// returns YES. +[[RACObserve(self, username) + filter:^(NSString *newName) { + return [newName hasPrefix:@"j"]; + }] + subscribeNext:^(NSString *newName) { + NSLog(@"%@", newName); + }]; +``` + +Signals can also be used to derive state. Instead of observing properties and +setting other properties in response to the new values, RAC makes it possible to +express properties in terms of signals and operations: + +```objc +// Create a one-way binding so that self.createEnabled will be +// true whenever self.password and self.passwordConfirmation +// are equal. +// +// RAC() is a macro that makes the binding look nicer. +// +// +combineLatest:reduce: takes an array of signals, executes the block with the +// latest value from each signal whenever any of them changes, and returns a new +// RACSignal that sends the return value of that block as values. +RAC(self, createEnabled) = [RACSignal + combineLatest:@[ RACObserve(self, password), RACObserve(self, passwordConfirmation) ] + reduce:^(NSString *password, NSString *passwordConfirm) { + return @([passwordConfirm isEqualToString:password]); + }]; +``` + +Signals can be built on any stream of values over time, not just KVO. For +example, they can also represent button presses: + +```objc +// Log a message whenever the button is pressed. +// +// RACCommand creates signals to represent UI actions. Each signal can +// represent a button press, for example, and have additional work associated +// with it. +// +// -rac_command is an addition to NSButton. The button will send itself on that +// command whenever it's pressed. +self.button.rac_command = [[RACCommand alloc] initWithSignalBlock:^(id _) { + NSLog(@"button was pressed!"); + return [RACSignal empty]; +}] +``` + +Or asynchronous network operations: + +```objc +// Hook up a "Log in" button to log in over the network. +// +// This block will be run whenever the login command is executed, starting +// the login process. +self.loginCommand = [[RACCommand alloc] initWithSignalBlock:^(id sender) { + // The hypothetical -logIn method returns a signal that sends a value when + // the network request finishes. + return [client logIn]; +}]; + +// -executionSignals returns a signal that includes the signals returned from +// the above block, one for each time the command is executed. +[self.loginCommand.executionSignals subscribeNext:^(RACSignal *loginSignal) { + // Log a message whenever we log in successfully. + [loginSignal subscribeCompleted:^ { + NSLog(@"Logged in successfully!"); + }]; +}]; + +// Execute the login command when the button is pressed. +self.loginButton.rac_command = self.loginCommand; +``` + +Signals can also represent timers, other UI events, or anything else that +changes over time. + +Using signals for asynchronous operations makes it possible to build up more +complex behavior by chaining and transforming those signals. Work can easily be +trigged after a group of operations completes: + +```objc +// Perform 2 network operations and log a message to the console when they are +// both completed. +// +// +merge: takes an array of signals and returns a new RACSignal that passes +// through the values of all of the signals and completes when all of the +// signals complete. +// +// -subscribeCompleted: will execute the block when the signal completes. +[[RACSignal + merge:@[ [client fetchUserRepos], [client fetchOrgRepos] ]] + subscribeCompleted:^{ + NSLog(@"They're both done!"); + }]; +``` + +Signals can be chained to sequentially execute asynchronous operations, instead +of nesting callbacks with blocks. This is similar to how [futures and promises][] +are usually used: + +```objc +// Log in the user, then load any cached messages, then fetch the remaining +// messages from the server. After that's all done, log a message to the +// console. +// +// The hypothetical -logInUser methods returns a signal that completes after +// logging in. +// +// -flattenMap: will execute its block whenever the signal sends a value, and +// return a new RACSignal that merges all of the signals returned from the block +// into a single signal. +[[[[client + logInUser] + flattenMap:^(User *user) { + // Return a signal that loads cached messages for the user. + return [client loadCachedMessagesForUser:user]; + }] + flattenMap:^(NSArray *messages) { + // Return a signal that fetches any remaining messages. + return [client fetchMessagesAfterMessage:messages.lastObject]; + }] + subscribeNext:^(NSArray *newMessages) { + NSLog(@"New messages: %@", newMessages); + } completed:^{ + NSLog(@"Fetched all messages."); + }]; +``` + +RAC even makes it easy to bind to the result of an asynchronous operation: + +```objc +// Create a one-way binding so that self.imageView.image will be set the user's +// avatar as soon as it's downloaded. +// +// The hypothetical -fetchUserWithUsername: method returns a signal which sends +// the user. +// +// -deliverOn: creates new signals that will do their work on other queues. In +// this example, it's used to move work to a background queue and then back to the main thread. +// +// -map: calls its block with each user that's fetched and returns a new +// RACSignal that sends values returned from the block. +RAC(self.imageView, image) = [[[[client + fetchUserWithUsername:@"joshaber"] + deliverOn:[RACScheduler scheduler]] + map:^(User *user) { + // Download the avatar (this is done on a background queue). + return [[NSImage alloc] initWithContentsOfURL:user.avatarURL]; + }] + // Now the assignment will be done on the main thread. + deliverOn:RACScheduler.mainThreadScheduler]; +``` + +That demonstrates some of what RAC can do, but it doesn't demonstrate why RAC is +so powerful. It's hard to appreciate RAC from README-sized examples, but it +makes it possible to write code with less state, less boilerplate, better code +locality, and better expression of intent. + +For more sample code, check out [C-41][] or [GroceryList][], which are real iOS +apps written using ReactiveCocoa. Additional information about RAC can be found +in the [Documentation][] folder. + +## When to use ReactiveCocoa + +Upon first glance, ReactiveCocoa is very abstract, and it can be difficult to +understand how to apply it to concrete problems. + +Here are some of the use cases that RAC excels at. + +### Handling asynchronous or event-driven data sources + +Much of Cocoa programming is focused on reacting to user events or changes in +application state. Code that deals with such events can quickly become very +complex and spaghetti-like, with lots of callbacks and state variables to handle +ordering issues. + +Patterns that seem superficially different, like UI callbacks, network +responses, and KVO notifications, actually have a lot in common. [RACSignal][] +unifies all these different APIs so that they can be composed together and +manipulated in the same way. + +For example, the following code: + +```objc + +static void *ObservationContext = &ObservationContext; + +- (void)viewDidLoad { + [super viewDidLoad]; + + [LoginManager.sharedManager addObserver:self forKeyPath:@"loggingIn" options:NSKeyValueObservingOptionInitial context:&ObservationContext]; + [NSNotificationCenter.defaultCenter addObserver:self selector:@selector(loggedOut:) name:UserDidLogOutNotification object:LoginManager.sharedManager]; + + [self.usernameTextField addTarget:self action:@selector(updateLogInButton) forControlEvents:UIControlEventEditingChanged]; + [self.passwordTextField addTarget:self action:@selector(updateLogInButton) forControlEvents:UIControlEventEditingChanged]; + [self.logInButton addTarget:self action:@selector(logInPressed:) forControlEvents:UIControlEventTouchUpInside]; +} + +- (void)dealloc { + [LoginManager.sharedManager removeObserver:self forKeyPath:@"loggingIn" context:ObservationContext]; + [NSNotificationCenter.defaultCenter removeObserver:self]; +} + +- (void)updateLogInButton { + BOOL textFieldsNonEmpty = self.usernameTextField.text.length > 0 && self.passwordTextField.text.length > 0; + BOOL readyToLogIn = !LoginManager.sharedManager.isLoggingIn && !self.loggedIn; + self.logInButton.enabled = textFieldsNonEmpty && readyToLogIn; +} + +- (IBAction)logInPressed:(UIButton *)sender { + [[LoginManager sharedManager] + logInWithUsername:self.usernameTextField.text + password:self.passwordTextField.text + success:^{ + self.loggedIn = YES; + } failure:^(NSError *error) { + [self presentError:error]; + }]; +} + +- (void)loggedOut:(NSNotification *)notification { + self.loggedIn = NO; +} + +- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context { + if (context == ObservationContext) { + [self updateLogInButton]; + } else { + [super observeValueForKeyPath:keyPath ofObject:object change:change context:context]; + } +} +``` + +… could be expressed in RAC like so: + +```objc +- (void)viewDidLoad { + [super viewDidLoad]; + + @weakify(self); + + RAC(self.logInButton, enabled) = [RACSignal + combineLatest:@[ + self.usernameTextField.rac_textSignal, + self.passwordTextField.rac_textSignal, + RACObserve(LoginManager.sharedManager, loggingIn), + RACObserve(self, loggedIn) + ] reduce:^(NSString *username, NSString *password, NSNumber *loggingIn, NSNumber *loggedIn) { + return @(username.length > 0 && password.length > 0 && !loggingIn.boolValue && !loggedIn.boolValue); + }]; + + [[self.logInButton rac_signalForControlEvents:UIControlEventTouchUpInside] subscribeNext:^(UIButton *sender) { + @strongify(self); + + RACSignal *loginSignal = [LoginManager.sharedManager + logInWithUsername:self.usernameTextField.text + password:self.passwordTextField.text]; + + [loginSignal subscribeError:^(NSError *error) { + @strongify(self); + [self presentError:error]; + } completed:^{ + @strongify(self); + self.loggedIn = YES; + }]; + }]; + + RAC(self, loggedIn) = [[NSNotificationCenter.defaultCenter + rac_addObserverForName:UserDidLogOutNotification object:nil] + mapReplace:@NO]; +} +``` + +### Chaining dependent operations + +Dependencies are most often found in network requests, where a previous request +to the server needs to complete before the next one can be constructed, and so +on: + +```objc +[client logInWithSuccess:^{ + [client loadCachedMessagesWithSuccess:^(NSArray *messages) { + [client fetchMessagesAfterMessage:messages.lastObject success:^(NSArray *nextMessages) { + NSLog(@"Fetched all messages."); + } failure:^(NSError *error) { + [self presentError:error]; + }]; + } failure:^(NSError *error) { + [self presentError:error]; + }]; +} failure:^(NSError *error) { + [self presentError:error]; +}]; +``` + +ReactiveCocoa makes this pattern particularly easy: + +```objc +[[[[client logIn] + then:^{ + return [client loadCachedMessages]; + }] + flattenMap:^(NSArray *messages) { + return [client fetchMessagesAfterMessage:messages.lastObject]; + }] + subscribeError:^(NSError *error) { + [self presentError:error]; + } completed:^{ + NSLog(@"Fetched all messages."); + }]; +``` + +### Parallelizing independent work + +Working with independent data sets in parallel and then combining them into +a final result is non-trivial in Cocoa, and often involves a lot of +synchronization: + +```objc +__block NSArray *databaseObjects; +__block NSArray *fileContents; + +NSOperationQueue *backgroundQueue = [[NSOperationQueue alloc] init]; +NSBlockOperation *databaseOperation = [NSBlockOperation blockOperationWithBlock:^{ + databaseObjects = [databaseClient fetchObjectsMatchingPredicate:predicate]; +}]; + +NSBlockOperation *filesOperation = [NSBlockOperation blockOperationWithBlock:^{ + NSMutableArray *filesInProgress = [NSMutableArray array]; + for (NSString *path in files) { + [filesInProgress addObject:[NSData dataWithContentsOfFile:path]]; + } + + fileContents = [filesInProgress copy]; +}]; + +NSBlockOperation *finishOperation = [NSBlockOperation blockOperationWithBlock:^{ + [self finishProcessingDatabaseObjects:databaseObjects fileContents:fileContents]; + NSLog(@"Done processing"); +}]; + +[finishOperation addDependency:databaseOperation]; +[finishOperation addDependency:filesOperation]; +[backgroundQueue addOperation:databaseOperation]; +[backgroundQueue addOperation:filesOperation]; +[backgroundQueue addOperation:finishOperation]; +``` + +The above code can be cleaned up and optimized by simply composing signals: + +```objc +RACSignal *databaseSignal = [[databaseClient + fetchObjectsMatchingPredicate:predicate] + subscribeOn:[RACScheduler scheduler]]; + +RACSignal *fileSignal = [RACSignal startEagerlyWithScheduler:[RACScheduler scheduler] block:^(id<RACSubscriber> subscriber) { + NSMutableArray *filesInProgress = [NSMutableArray array]; + for (NSString *path in files) { + [filesInProgress addObject:[NSData dataWithContentsOfFile:path]]; + } + + [subscriber sendNext:[filesInProgress copy]]; + [subscriber sendCompleted]; +}]; + +[[RACSignal + combineLatest:@[ databaseSignal, fileSignal ] + reduce:^ id (NSArray *databaseObjects, NSArray *fileContents) { + [self finishProcessingDatabaseObjects:databaseObjects fileContents:fileContents]; + return nil; + }] + subscribeCompleted:^{ + NSLog(@"Done processing"); + }]; +``` + +### Simplifying collection transformations + +Higher-order functions like `map`, `filter`, `fold`/`reduce` are sorely missing +from Foundation, leading to loop-focused code like this: + +```objc +NSMutableArray *results = [NSMutableArray array]; +for (NSString *str in strings) { + if (str.length < 2) { + continue; + } + + NSString *newString = [str stringByAppendingString:@"foobar"]; + [results addObject:newString]; +} +``` + +[RACSequence][] allows any Cocoa collection to be manipulated in a uniform and +declarative way: + +```objc +RACSequence *results = [[strings.rac_sequence + filter:^ BOOL (NSString *str) { + return str.length >= 2; + }] + map:^(NSString *str) { + return [str stringByAppendingString:@"foobar"]; + }]; +``` + +## System Requirements + +ReactiveCocoa supports OS X 10.7+ and iOS 5.0+. + +## Importing ReactiveCocoa + +To add RAC to your application: + + 1. Add the ReactiveCocoa repository as a submodule of your application's + repository. + 1. Run `script/bootstrap` from within the ReactiveCocoa folder. + 1. Drag and drop `ReactiveCocoaFramework/ReactiveCocoa.xcodeproj` into your + application's Xcode project or workspace. + 1. On the "Build Phases" tab of your application target, add RAC to the "Link + Binary With Libraries" phase. + * **On iOS**, add `libReactiveCocoa-iOS.a`. + * **On OS X**, add `ReactiveCocoa.framework`. RAC must also be added to any + "Copy Frameworks" build phase. If you don't already have one, simply add + a "Copy Files" build phase and target the "Frameworks" destination. + 1. Add `"$(BUILD_ROOT)/../IntermediateBuildFilesPath/UninstalledProducts/include" + $(inherited)` to the "Header Search Paths" build setting (this is only + necessary for archive builds, but it has no negative effect otherwise). + 1. **For iOS targets**, add `-ObjC` to the "Other Linker Flags" build setting. + 1. **If you added RAC to a project (not a workspace)**, you will also need to + add the appropriate RAC target to the "Target Dependencies" of your + application. + +If you would prefer to use [CocoaPods](http://cocoapods.org), there are some +[ReactiveCocoa +podspecs](https://github.com/CocoaPods/Specs/tree/master/ReactiveCocoa) that +have been generously contributed by third parties. + +To see a project already set up with RAC, check out [C-41][] or [GroceryList][], +which are real iOS apps written using ReactiveCocoa. + +## Standalone Development + +If you’re working on RAC in isolation instead of integrating it into another project, you’ll want to open `ReactiveCocoaFramework/ReactiveCocoa.xcworkspace` and not the `.xcodeproj`. + +## More Info + +ReactiveCocoa is based on .NET's [Reactive +Extensions](http://msdn.microsoft.com/en-us/data/gg577609) (Rx). Most of the +principles of Rx apply to RAC as well. There are some really good Rx resources +out there: + +* [Reactive Extensions MSDN entry](http://msdn.microsoft.com/en-us/library/hh242985.aspx) +* [Reactive Extensions for .NET Introduction](http://leecampbell.blogspot.com/2010/08/reactive-extensions-for-net.html) +* [Rx - Channel 9 videos](http://channel9.msdn.com/tags/Rx/) +* [Reactive Extensions wiki](http://rxwiki.wikidot.com/) +* [101 Rx Samples](http://rxwiki.wikidot.com/101samples) +* [Programming Reactive Extensions and LINQ](http://www.amazon.com/Programming-Reactive-Extensions-Jesse-Liberty/dp/1430237473) + +RAC and Rx are both implementations of functional reactive programming. Here are +some more resources for learning about FRP: + +* [What is FRP? - Elm Language](http://elm-lang.org/learn/What-is-FRP.elm) +* [What is Functional Reactive Programming - Stack Overflow](http://stackoverflow.com/questions/1028250/what-is-functional-reactive-programming/1030631#1030631) +* [Escape from Callback Hell](http://elm-lang.org/learn/Escape-from-Callback-Hell.elm) +* [Principles of Reactive Programming on Coursera](https://www.coursera.org/course/reactive) + +[Basic Operators]: Documentation/BasicOperators.md +[Documentation]: Documentation +[Framework Overview]: Documentation/FrameworkOverview.md +[Functional Reactive Programming]: http://en.wikipedia.org/wiki/Functional_reactive_programming +[GroceryList]: https://github.com/jspahrsummers/GroceryList +[Memory Management]: Documentation/MemoryManagement.md +[NSObject+RACLifting]: ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACLifting.h +[RACDisposable]: ReactiveCocoaFramework/ReactiveCocoa/RACDisposable.h +[RACEvent]: ReactiveCocoaFramework/ReactiveCocoa/RACEvent.h +[RACMulticastConnection]: ReactiveCocoaFramework/ReactiveCocoa/RACMulticastConnection.h +[RACScheduler]: ReactiveCocoaFramework/ReactiveCocoa/RACScheduler.h +[RACSequence]: ReactiveCocoaFramework/ReactiveCocoa/RACSequence.h +[RACSignal+Operations]: ReactiveCocoaFramework/ReactiveCocoa/RACSignal+Operations.h +[RACSignal]: ReactiveCocoaFramework/ReactiveCocoa/RACSignal.h +[RACStream]: ReactiveCocoaFramework/ReactiveCocoa/RACStream.h +[RACSubscriber]: ReactiveCocoaFramework/ReactiveCocoa/RACSubscriber.h +[RAC]: ReactiveCocoaFramework/ReactiveCocoa/RACSubscriptingAssignmentTrampoline.h +[futures and promises]: http://en.wikipedia.org/wiki/Futures_and_promises +[C-41]: https://github.com/AshFurrow/C-41
diff --git a/ReactiveCocoaFramework/ReactiveCocoa.xcodeproj/project.pbxproj b/ReactiveCocoaFramework/ReactiveCocoa.xcodeproj/project.pbxproj new file mode 100644 index 0000000..58014f0 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa.xcodeproj/project.pbxproj
@@ -0,0 +1,3128 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 46; + objects = { + +/* Begin PBXBuildFile section */ + 1646747B17FFA0610036E30B /* UICollectionReusableView+RACSignalSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 1668027817FE75E900C724B4 /* UICollectionReusableView+RACSignalSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 1668028017FE75F900C724B4 /* UICollectionReusableView+RACSignalSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 1668027917FE75E900C724B4 /* UICollectionReusableView+RACSignalSupport.m */; }; + 1668028317FE775200C724B4 /* UICollectionReusableViewRACSupportSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 1668028117FE774800C724B4 /* UICollectionReusableViewRACSupportSpec.m */; }; + 1860F414177C91B500C7B3C9 /* UIKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 1860F413177C91B500C7B3C9 /* UIKit.framework */; }; + 1860F416177C91B500C7B3C9 /* Foundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 1860F415177C91B500C7B3C9 /* Foundation.framework */; }; + 1860F418177C91B500C7B3C9 /* CoreGraphics.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 1860F417177C91B500C7B3C9 /* CoreGraphics.framework */; }; + 1860F41E177C91B500C7B3C9 /* InfoPlist.strings in Resources */ = {isa = PBXBuildFile; fileRef = 1860F41C177C91B500C7B3C9 /* InfoPlist.strings */; }; + 1860F420177C91B500C7B3C9 /* main.m in Sources */ = {isa = PBXBuildFile; fileRef = 1860F41F177C91B500C7B3C9 /* main.m */; }; + 1860F424177C91B500C7B3C9 /* RACAppDelegate.m in Sources */ = {isa = PBXBuildFile; fileRef = 1860F423177C91B500C7B3C9 /* RACAppDelegate.m */; }; + 1860F426177C91B500C7B3C9 /* Default.png in Resources */ = {isa = PBXBuildFile; fileRef = 1860F425177C91B500C7B3C9 /* Default.png */; }; + 1860F428177C91B500C7B3C9 /* Default@2x.png in Resources */ = {isa = PBXBuildFile; fileRef = 1860F427177C91B500C7B3C9 /* Default@2x.png */; }; + 1860F42A177C91B500C7B3C9 /* Default-568h@2x.png in Resources */ = {isa = PBXBuildFile; fileRef = 1860F429177C91B500C7B3C9 /* Default-568h@2x.png */; }; + 1860F432177C91B500C7B3C9 /* SenTestingKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 1860F431177C91B500C7B3C9 /* SenTestingKit.framework */; }; + 1860F433177C91B500C7B3C9 /* UIKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 1860F413177C91B500C7B3C9 /* UIKit.framework */; }; + 1860F434177C91B500C7B3C9 /* Foundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 1860F415177C91B500C7B3C9 /* Foundation.framework */; }; + 1860F43C177C91B500C7B3C9 /* InfoPlist.strings in Resources */ = {isa = PBXBuildFile; fileRef = 1860F43A177C91B500C7B3C9 /* InfoPlist.strings */; }; + 1860F44F177C958300C7B3C9 /* UITextFieldRACSupportSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D0C55CD817758A73008CDDCA /* UITextFieldRACSupportSpec.m */; }; + 1860F450177C958900C7B3C9 /* UITextViewRACSupportSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D0C55CDE17758C2A008CDDCA /* UITextViewRACSupportSpec.m */; }; + 1E893381171647A5009071B0 /* NSObjectRACPropertySubscribingExamples.m in Sources */ = {isa = PBXBuildFile; fileRef = 1E893380171647A5009071B0 /* NSObjectRACPropertySubscribingExamples.m */; }; + 1EC06B17173CB04000365258 /* UIGestureRecognizer+RACSignalSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 1EC06B15173CB04000365258 /* UIGestureRecognizer+RACSignalSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 1EC06B18173CB04000365258 /* UIGestureRecognizer+RACSignalSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 1EC06B16173CB04000365258 /* UIGestureRecognizer+RACSignalSupport.m */; }; + 27A887D11703DC6800040001 /* UIBarButtonItem+RACCommandSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 27A887C81703DB4F00040001 /* UIBarButtonItem+RACCommandSupport.m */; }; + 27A887D21703DDEB00040001 /* UIBarButtonItem+RACCommandSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 27A887C71703DB4F00040001 /* UIBarButtonItem+RACCommandSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 4925E806181BCC71000B2FEE /* NSControllerRACSupportSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 4925E805181BCC71000B2FEE /* NSControllerRACSupportSpec.m */; }; + 554D9E5D181064E200F21262 /* UIRefreshControl+RACCommandSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 554D9E5B181064E200F21262 /* UIRefreshControl+RACCommandSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 554D9E5E181064E200F21262 /* UIRefreshControl+RACCommandSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 554D9E5C181064E200F21262 /* UIRefreshControl+RACCommandSupport.m */; }; + 5564537F18107203002BD2E4 /* RACControlCommandExamples.m in Sources */ = {isa = PBXBuildFile; fileRef = D075A72917BCB7E100C24FB7 /* RACControlCommandExamples.m */; }; + 5564542418107275002BD2E4 /* UIRefreshControlRACSupportSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 5564542318107275002BD2E4 /* UIRefreshControlRACSupportSpec.m */; }; + 557A4B5A177648C7008EF796 /* UIActionSheet+RACSignalSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 557A4B58177648C7008EF796 /* UIActionSheet+RACSignalSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 557A4B5B177648C7008EF796 /* UIActionSheet+RACSignalSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 557A4B59177648C7008EF796 /* UIActionSheet+RACSignalSupport.m */; }; + 55C39DE417F1EC6E006DC60C /* NSData+RACSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 88442C8816090C1500636B49 /* NSData+RACSupport.m */; }; + 55C39DE517F1EC6E006DC60C /* NSFileHandle+RACSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 88442C8A16090C1500636B49 /* NSFileHandle+RACSupport.m */; }; + 55C39DE617F1EC6E006DC60C /* NSNotificationCenter+RACSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 88442C8C16090C1500636B49 /* NSNotificationCenter+RACSupport.m */; }; + 55C39DE717F1EC6E006DC60C /* NSString+RACSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 88442C8E16090C1500636B49 /* NSString+RACSupport.m */; }; + 55C39DE817F1EC6E006DC60C /* NSData+RACSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 88442C8816090C1500636B49 /* NSData+RACSupport.m */; }; + 55C39DE917F1EC6E006DC60C /* NSFileHandle+RACSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 88442C8A16090C1500636B49 /* NSFileHandle+RACSupport.m */; }; + 55C39DEA17F1EC6E006DC60C /* NSNotificationCenter+RACSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 88442C8C16090C1500636B49 /* NSNotificationCenter+RACSupport.m */; }; + 55C39DEB17F1EC6E006DC60C /* NSString+RACSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 88442C8E16090C1500636B49 /* NSString+RACSupport.m */; }; + 55C39DEC17F1EC84006DC60C /* NSData+RACSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 88442C8716090C1500636B49 /* NSData+RACSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 55C39DED17F1EC84006DC60C /* NSFileHandle+RACSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 88442C8916090C1500636B49 /* NSFileHandle+RACSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 55C39DEE17F1EC84006DC60C /* NSNotificationCenter+RACSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 88442C8B16090C1500636B49 /* NSNotificationCenter+RACSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 55C39DEF17F1EC84006DC60C /* NSString+RACSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 88442C8D16090C1500636B49 /* NSString+RACSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 55C39DF017F1EC84006DC60C /* NSData+RACSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 88442C8716090C1500636B49 /* NSData+RACSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 55C39DF117F1EC84006DC60C /* NSFileHandle+RACSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 88442C8916090C1500636B49 /* NSFileHandle+RACSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 55C39DF217F1EC84006DC60C /* NSNotificationCenter+RACSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 88442C8B16090C1500636B49 /* NSNotificationCenter+RACSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 55C39DF317F1EC84006DC60C /* NSString+RACSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 88442C8D16090C1500636B49 /* NSString+RACSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 5EE9A7931760D61300EAF5A2 /* UIButton+RACCommandSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 5EE9A7911760D61300EAF5A2 /* UIButton+RACCommandSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 5EE9A7941760D61300EAF5A2 /* UIButton+RACCommandSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 5EE9A7921760D61300EAF5A2 /* UIButton+RACCommandSupport.m */; }; + 5EE9A79B1760D88500EAF5A2 /* UIButtonRACSupportSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 5EE9A79A1760D88500EAF5A2 /* UIButtonRACSupportSpec.m */; }; + 5F016DF717B10AA8002EEC69 /* UIControl+RACSignalSupportPrivate.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F016DF317B10AA8002EEC69 /* UIControl+RACSignalSupportPrivate.m */; }; + 5F2447AD167E87C50062180C /* RACKVOChannelSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F2447AC167E87C50062180C /* RACKVOChannelSpec.m */; }; + 5F45A885168CFA3E00B58A2B /* RACKVOChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 5F45A883168CFA3E00B58A2B /* RACKVOChannel.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 5F45A886168CFA3E00B58A2B /* RACKVOChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 5F45A883168CFA3E00B58A2B /* RACKVOChannel.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 5F45A887168CFA3E00B58A2B /* RACKVOChannel.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F45A884168CFA3E00B58A2B /* RACKVOChannel.m */; }; + 5F45A888168CFA3E00B58A2B /* RACKVOChannel.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F45A884168CFA3E00B58A2B /* RACKVOChannel.m */; }; + 5F6FE8531692568A00A8D7A6 /* RACChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 5F6FE8511692568A00A8D7A6 /* RACChannel.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 5F6FE8541692568A00A8D7A6 /* RACChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 5F6FE8511692568A00A8D7A6 /* RACChannel.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 5F6FE8551692568A00A8D7A6 /* RACChannel.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F6FE8521692568A00A8D7A6 /* RACChannel.m */; }; + 5F6FE8561692568A00A8D7A6 /* RACChannel.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F6FE8521692568A00A8D7A6 /* RACChannel.m */; }; + 5F70B2AF17AB1829009AEDF9 /* UIDatePicker+RACSignalSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 5F70B2AD17AB1829009AEDF9 /* UIDatePicker+RACSignalSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 5F70B2B017AB1829009AEDF9 /* UIDatePicker+RACSignalSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F70B2AE17AB1829009AEDF9 /* UIDatePicker+RACSignalSupport.m */; }; + 5F70B2BE17AB1857009AEDF9 /* UISegmentedControl+RACSignalSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 5F70B2B617AB1856009AEDF9 /* UISegmentedControl+RACSignalSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 5F70B2BF17AB1857009AEDF9 /* UISegmentedControl+RACSignalSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F70B2B717AB1856009AEDF9 /* UISegmentedControl+RACSignalSupport.m */; }; + 5F70B2C017AB1857009AEDF9 /* UISlider+RACSignalSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 5F70B2B817AB1856009AEDF9 /* UISlider+RACSignalSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 5F70B2C117AB1857009AEDF9 /* UISlider+RACSignalSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F70B2B917AB1856009AEDF9 /* UISlider+RACSignalSupport.m */; }; + 5F70B2C217AB1857009AEDF9 /* UIStepper+RACSignalSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 5F70B2BA17AB1857009AEDF9 /* UIStepper+RACSignalSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 5F70B2C317AB1857009AEDF9 /* UIStepper+RACSignalSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F70B2BB17AB1857009AEDF9 /* UIStepper+RACSignalSupport.m */; }; + 5F70B2C417AB1857009AEDF9 /* UISwitch+RACSignalSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 5F70B2BC17AB1857009AEDF9 /* UISwitch+RACSignalSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 5F70B2C517AB1857009AEDF9 /* UISwitch+RACSignalSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F70B2BD17AB1857009AEDF9 /* UISwitch+RACSignalSupport.m */; }; + 5F773DEA169B46670023069D /* NSEnumerator+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = 5F773DE8169B46670023069D /* NSEnumerator+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 5F773DEB169B46670023069D /* NSEnumerator+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = 5F773DE8169B46670023069D /* NSEnumerator+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 5F773DEC169B46670023069D /* NSEnumerator+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F773DE9169B46670023069D /* NSEnumerator+RACSequenceAdditions.m */; }; + 5F773DED169B46670023069D /* NSEnumerator+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F773DE9169B46670023069D /* NSEnumerator+RACSequenceAdditions.m */; }; + 5F773DF0169B48830023069D /* NSEnumeratorRACSequenceAdditionsSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F773DEF169B48830023069D /* NSEnumeratorRACSequenceAdditionsSpec.m */; }; + 5F7EFECF168FBC4B0037E500 /* RACChannelExamples.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F7EFECD168FBC4B0037E500 /* RACChannelExamples.m */; }; + 5F7EFED0168FBC4B0037E500 /* RACChannelSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F7EFECE168FBC4B0037E500 /* RACChannelSpec.m */; }; + 5F9743F91694A2460024EB82 /* RACEagerSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F9743F61694A2460024EB82 /* RACEagerSequence.m */; }; + 5F9743FA1694A2460024EB82 /* RACEagerSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F9743F61694A2460024EB82 /* RACEagerSequence.m */; }; + 5FAF5224174D4C2000CAC810 /* SenTestingKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 88CDF7DD15000FCF00163A9F /* SenTestingKit.framework */; }; + 5FAF523E174D4D3200CAC810 /* NSEnumeratorRACSequenceAdditionsSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F773DEF169B48830023069D /* NSEnumeratorRACSequenceAdditionsSpec.m */; }; + 5FAF523F174D4D3600CAC810 /* NSNotificationCenterRACSupportSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D0700F4B1672994D00D7CD30 /* NSNotificationCenterRACSupportSpec.m */; }; + 5FAF5240174D4D5600CAC810 /* NSObjectRACDeallocatingSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 6E58405E16F3414200F588A6 /* NSObjectRACDeallocatingSpec.m */; }; + 5FAF5241174D4D5600CAC810 /* NSObjectRACLiftingSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 8801E7501644BDE200A155FE /* NSObjectRACLiftingSpec.m */; }; + 5FAF5242174D4D5600CAC810 /* NSObjectRACPropertySubscribingExamples.m in Sources */ = {isa = PBXBuildFile; fileRef = 1E893380171647A5009071B0 /* NSObjectRACPropertySubscribingExamples.m */; }; + 5FAF5243174D4D5600CAC810 /* NSObjectRACPropertySubscribingSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 8851A38A16161D500050D47F /* NSObjectRACPropertySubscribingSpec.m */; }; + 5FAF5244174D4D5600CAC810 /* NSStringRACKeyPathUtilitiesSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 5FDC350E1736F81800792E52 /* NSStringRACKeyPathUtilitiesSpec.m */; }; + 5FAF5246174D4D5600CAC810 /* RACBacktraceSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D0870C6E16884A0600D0E11D /* RACBacktraceSpec.m */; }; + 5FAF5247174D4D5600CAC810 /* RACBlockTrampolineSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 886CEACC163DE669007632D1 /* RACBlockTrampolineSpec.m */; }; + 5FAF5248174D4D5600CAC810 /* RACCommandSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 882CCA1D15F1564D00937D6E /* RACCommandSpec.m */; }; + 5FAF5249174D4D5600CAC810 /* RACCompoundDisposableSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 881E86B91669350B00667F7B /* RACCompoundDisposableSpec.m */; }; + 5FAF524A174D4D5600CAC810 /* RACEventSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D077A171169B79A900057BB1 /* RACEventSpec.m */; }; + 5FAF524B174D4D5600CAC810 /* RACKVOWrapperSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D041376815D2281C004BBF80 /* RACKVOWrapperSpec.m */; }; + 5FAF524C174D4D5600CAC810 /* RACMulticastConnectionSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 88C5A02816924BFC0045EF05 /* RACMulticastConnectionSpec.m */; }; + 5FAF524D174D4D5600CAC810 /* RACKVOChannelSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F2447AC167E87C50062180C /* RACKVOChannelSpec.m */; }; + 5FAF524E174D4D5600CAC810 /* RACPropertySignalExamples.m in Sources */ = {isa = PBXBuildFile; fileRef = D0EDE76616968AB10072A780 /* RACPropertySignalExamples.m */; }; + 5FAF524F174D4D5600CAC810 /* RACChannelExamples.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F7EFECD168FBC4B0037E500 /* RACChannelExamples.m */; }; + 5FAF5250174D4D5600CAC810 /* RACChannelSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F7EFECE168FBC4B0037E500 /* RACChannelSpec.m */; }; + 5FAF5251174D4D5600CAC810 /* RACSchedulerSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 8803C010166732BA00C36839 /* RACSchedulerSpec.m */; }; + 5FAF5252174D4D5600CAC810 /* RACSequenceAdditionsSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D0C70F8F164337A2007027B4 /* RACSequenceAdditionsSpec.m */; }; + 5FAF5253174D4D5600CAC810 /* RACSequenceExamples.m in Sources */ = {isa = PBXBuildFile; fileRef = D0C70F92164337E3007027B4 /* RACSequenceExamples.m */; }; + 5FAF5254174D4D5600CAC810 /* RACSequenceSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D0D487051642651400DD7605 /* RACSequenceSpec.m */; }; + 5FAF5255174D4D5600CAC810 /* RACSignalSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 8820937B1501C8A600796685 /* RACSignalSpec.m */; }; + 5FAF5256174D4D5600CAC810 /* RACStreamExamples.m in Sources */ = {isa = PBXBuildFile; fileRef = D0487AB2164314430085D890 /* RACStreamExamples.m */; }; + 5FAF5257174D4D5600CAC810 /* RACSubjectSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 889D0A7F15974B2A00F833E3 /* RACSubjectSpec.m */; }; + 5FAF5258174D4D5600CAC810 /* RACSubscriberExamples.m in Sources */ = {isa = PBXBuildFile; fileRef = D0C70EC516659333005AAD03 /* RACSubscriberExamples.m */; }; + 5FAF5259174D4D5600CAC810 /* RACSubscriberSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D0C70EC7166595AD005AAD03 /* RACSubscriberSpec.m */; }; + 5FAF525A174D4D5600CAC810 /* RACSubscriptingAssignmentTrampolineSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 88FC735A16114FFB00F8A774 /* RACSubscriptingAssignmentTrampolineSpec.m */; }; + 5FAF525B174D4D5600CAC810 /* RACTestObject.m in Sources */ = {isa = PBXBuildFile; fileRef = 88442A331608A9AD00636B49 /* RACTestObject.m */; }; + 5FAF525C174D4D5600CAC810 /* RACTupleSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D02221611678910900DBD031 /* RACTupleSpec.m */; }; + 5FAF525D174D4D5600CAC810 /* NSObjectRACSelectorSignalSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 880D7A6516F7BB1A004A3361 /* NSObjectRACSelectorSignalSpec.m */; }; + 5FAF525E174D4D5600CAC810 /* RACSubclassObject.m in Sources */ = {isa = PBXBuildFile; fileRef = 880D7A6816F7BCC7004A3361 /* RACSubclassObject.m */; }; + 5FAF5262174D4D8F00CAC810 /* UIBarButtonItemRACSupportSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 5FAF5261174D4D8E00CAC810 /* UIBarButtonItemRACSupportSpec.m */; }; + 5FAF5265174D500D00CAC810 /* libReactiveCocoa-iOS.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 88F440AB153DAC820097B4C3 /* libReactiveCocoa-iOS.a */; }; + 5FAF5289174E9CD300CAC810 /* CoreGraphics.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 5FAF5288174E9CD200CAC810 /* CoreGraphics.framework */; }; + 5FD7DC7A174F9EAF008710B4 /* Foundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 88CDF7C415000FCE00163A9F /* Foundation.framework */; }; + 5FD7DC7C174F9EEB008710B4 /* UIKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 5FD7DC7B174F9EEB008710B4 /* UIKit.framework */; }; + 5FD7DC7F174F9FC8008710B4 /* UIKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 5FD7DC7B174F9EEB008710B4 /* UIKit.framework */; }; + 5FDC35051736F54700792E52 /* NSString+RACKeyPathUtilities.m in Sources */ = {isa = PBXBuildFile; fileRef = 5FDC35021736F54700792E52 /* NSString+RACKeyPathUtilities.m */; }; + 5FDC35061736F54700792E52 /* NSString+RACKeyPathUtilities.m in Sources */ = {isa = PBXBuildFile; fileRef = 5FDC35021736F54700792E52 /* NSString+RACKeyPathUtilities.m */; }; + 5FDC350F1736F81900792E52 /* NSStringRACKeyPathUtilitiesSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 5FDC350E1736F81800792E52 /* NSStringRACKeyPathUtilitiesSpec.m */; }; + 6E58405516F22D7500F588A6 /* NSObject+RACDeallocating.h in Headers */ = {isa = PBXBuildFile; fileRef = 6E58405316F22D7500F588A6 /* NSObject+RACDeallocating.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 6E58405616F22D7500F588A6 /* NSObject+RACDeallocating.m in Sources */ = {isa = PBXBuildFile; fileRef = 6E58405416F22D7500F588A6 /* NSObject+RACDeallocating.m */; }; + 6E58405D16F22F7800F588A6 /* NSObject+RACDeallocating.m in Sources */ = {isa = PBXBuildFile; fileRef = 6E58405416F22D7500F588A6 /* NSObject+RACDeallocating.m */; }; + 6E58405F16F3414200F588A6 /* NSObjectRACDeallocatingSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 6E58405E16F3414200F588A6 /* NSObjectRACDeallocatingSpec.m */; }; + 6EA0C08216F4AEC1006EBEB2 /* NSObject+RACDeallocating.h in Headers */ = {isa = PBXBuildFile; fileRef = 6E58405316F22D7500F588A6 /* NSObject+RACDeallocating.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 7479F6E8186177D200575CDB /* RACIndexSetSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = 7479F6E4186177D200575CDB /* RACIndexSetSequence.m */; }; + 7479F6E9186177D200575CDB /* RACIndexSetSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = 7479F6E4186177D200575CDB /* RACIndexSetSequence.m */; }; + 7479F6EA186177D200575CDB /* RACIndexSetSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = 7479F6E4186177D200575CDB /* RACIndexSetSequence.m */; }; + 74F17318186024A900BC937C /* NSIndexSet+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = 74F17316186024A900BC937C /* NSIndexSet+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 74F17319186024A900BC937C /* NSIndexSet+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = 74F17316186024A900BC937C /* NSIndexSet+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 74F1731A186024A900BC937C /* NSIndexSet+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = 74F17316186024A900BC937C /* NSIndexSet+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 74F1731B186024A900BC937C /* NSIndexSet+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = 74F17317186024A900BC937C /* NSIndexSet+RACSequenceAdditions.m */; }; + 74F1731C186024A900BC937C /* NSIndexSet+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = 74F17317186024A900BC937C /* NSIndexSet+RACSequenceAdditions.m */; }; + 74F1731D186024A900BC937C /* NSIndexSet+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = 74F17317186024A900BC937C /* NSIndexSet+RACSequenceAdditions.m */; }; + 8801E7511644BDE200A155FE /* NSObjectRACLiftingSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 8801E7501644BDE200A155FE /* NSObjectRACLiftingSpec.m */; }; + 88037F8415056328001A5B19 /* Cocoa.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 88CDF7BF15000FCE00163A9F /* Cocoa.framework */; }; + 88037FB81505645C001A5B19 /* ReactiveCocoa.h in Headers */ = {isa = PBXBuildFile; fileRef = 88037F8C15056328001A5B19 /* ReactiveCocoa.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 88037FBB1505646C001A5B19 /* NSObject+RACPropertySubscribing.h in Headers */ = {isa = PBXBuildFile; fileRef = 88CDF82C15008C0500163A9F /* NSObject+RACPropertySubscribing.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 88037FBC1505646C001A5B19 /* RACSignal.h in Headers */ = {isa = PBXBuildFile; fileRef = 88CDF80415001CA800163A9F /* RACSignal.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 88037FBE1505646C001A5B19 /* RACSubscriber.h in Headers */ = {isa = PBXBuildFile; fileRef = 88CDF7FA150019CA00163A9F /* RACSubscriber.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 88037FC11505646C001A5B19 /* RACCommand.h in Headers */ = {isa = PBXBuildFile; fileRef = 882093E91501E6EE00796685 /* RACCommand.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 88037FC21505646C001A5B19 /* NSControl+RACCommandSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 882093E61501E6CB00796685 /* NSControl+RACCommandSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 88037FC71505647E001A5B19 /* NSObject+RACKVOWrapper.m in Sources */ = {isa = PBXBuildFile; fileRef = 88CDF82915008BB900163A9F /* NSObject+RACKVOWrapper.m */; }; + 88037FC91505648C001A5B19 /* RACSubscriber.m in Sources */ = {isa = PBXBuildFile; fileRef = 88CDF7FB150019CA00163A9F /* RACSubscriber.m */; }; + 88037FCC1505648C001A5B19 /* RACCommand.m in Sources */ = {isa = PBXBuildFile; fileRef = 882093EA1501E6EE00796685 /* RACCommand.m */; }; + 88037FCD1505648C001A5B19 /* NSControl+RACCommandSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 882093E71501E6CB00796685 /* NSControl+RACCommandSupport.m */; }; + 88037FD9150564D9001A5B19 /* ReactiveCocoa.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 88037F8315056328001A5B19 /* ReactiveCocoa.framework */; }; + 8803C011166732BA00C36839 /* RACSchedulerSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 8803C010166732BA00C36839 /* RACSchedulerSpec.m */; }; + 880B9176150B09190008488E /* RACSubject.h in Headers */ = {isa = PBXBuildFile; fileRef = 880B9174150B09190008488E /* RACSubject.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 880B9177150B09190008488E /* RACSubject.m in Sources */ = {isa = PBXBuildFile; fileRef = 880B9175150B09190008488E /* RACSubject.m */; }; + 880D7A5A16F7B351004A3361 /* NSObject+RACSelectorSignal.h in Headers */ = {isa = PBXBuildFile; fileRef = 880D7A5816F7B351004A3361 /* NSObject+RACSelectorSignal.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 880D7A5B16F7B351004A3361 /* NSObject+RACSelectorSignal.h in Headers */ = {isa = PBXBuildFile; fileRef = 880D7A5816F7B351004A3361 /* NSObject+RACSelectorSignal.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 880D7A5C16F7B351004A3361 /* NSObject+RACSelectorSignal.m in Sources */ = {isa = PBXBuildFile; fileRef = 880D7A5916F7B351004A3361 /* NSObject+RACSelectorSignal.m */; }; + 880D7A5D16F7B351004A3361 /* NSObject+RACSelectorSignal.m in Sources */ = {isa = PBXBuildFile; fileRef = 880D7A5916F7B351004A3361 /* NSObject+RACSelectorSignal.m */; }; + 880D7A6616F7BB1A004A3361 /* NSObjectRACSelectorSignalSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 880D7A6516F7BB1A004A3361 /* NSObjectRACSelectorSignalSpec.m */; }; + 880D7A6916F7BCC7004A3361 /* RACSubclassObject.m in Sources */ = {isa = PBXBuildFile; fileRef = 880D7A6816F7BCC7004A3361 /* RACSubclassObject.m */; }; + 881B37CC152260BF0079220B /* RACUnit.h in Headers */ = {isa = PBXBuildFile; fileRef = 881B37CA152260BF0079220B /* RACUnit.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 881B37CD152260BF0079220B /* RACUnit.m in Sources */ = {isa = PBXBuildFile; fileRef = 881B37CB152260BF0079220B /* RACUnit.m */; }; + 881E86A21669304800667F7B /* RACCompoundDisposable.h in Headers */ = {isa = PBXBuildFile; fileRef = 881E86A01669304700667F7B /* RACCompoundDisposable.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 881E86A41669304800667F7B /* RACCompoundDisposable.m in Sources */ = {isa = PBXBuildFile; fileRef = 881E86A11669304700667F7B /* RACCompoundDisposable.m */; }; + 881E86A51669304800667F7B /* RACCompoundDisposable.m in Sources */ = {isa = PBXBuildFile; fileRef = 881E86A11669304700667F7B /* RACCompoundDisposable.m */; }; + 881E86BA1669350B00667F7B /* RACCompoundDisposableSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 881E86B91669350B00667F7B /* RACCompoundDisposableSpec.m */; }; + 881E87AC16695C5600667F7B /* RACQueueScheduler.h in Headers */ = {isa = PBXBuildFile; fileRef = 881E87AA16695C5600667F7B /* RACQueueScheduler.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 881E87AE16695C5600667F7B /* RACQueueScheduler.m in Sources */ = {isa = PBXBuildFile; fileRef = 881E87AB16695C5600667F7B /* RACQueueScheduler.m */; }; + 881E87AF16695C5600667F7B /* RACQueueScheduler.m in Sources */ = {isa = PBXBuildFile; fileRef = 881E87AB16695C5600667F7B /* RACQueueScheduler.m */; }; + 881E87B416695EDF00667F7B /* RACImmediateScheduler.m in Sources */ = {isa = PBXBuildFile; fileRef = 881E87B116695EDF00667F7B /* RACImmediateScheduler.m */; }; + 881E87B516695EDF00667F7B /* RACImmediateScheduler.m in Sources */ = {isa = PBXBuildFile; fileRef = 881E87B116695EDF00667F7B /* RACImmediateScheduler.m */; }; + 881E87C41669636000667F7B /* RACSubscriptionScheduler.h in Headers */ = {isa = PBXBuildFile; fileRef = 881E87C21669635F00667F7B /* RACSubscriptionScheduler.h */; }; + 881E87C61669636000667F7B /* RACSubscriptionScheduler.m in Sources */ = {isa = PBXBuildFile; fileRef = 881E87C31669636000667F7B /* RACSubscriptionScheduler.m */; }; + 881E87C71669636000667F7B /* RACSubscriptionScheduler.m in Sources */ = {isa = PBXBuildFile; fileRef = 881E87C31669636000667F7B /* RACSubscriptionScheduler.m */; }; + 8820937C1501C8A600796685 /* RACSignalSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 8820937B1501C8A600796685 /* RACSignalSpec.m */; }; + 882CCA1E15F1564D00937D6E /* RACCommandSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 882CCA1D15F1564D00937D6E /* RACCommandSpec.m */; }; + 882D071917614FA7009EDA69 /* RACTargetQueueScheduler.h in Headers */ = {isa = PBXBuildFile; fileRef = 882D071717614FA7009EDA69 /* RACTargetQueueScheduler.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 882D071A17614FA7009EDA69 /* RACTargetQueueScheduler.m in Sources */ = {isa = PBXBuildFile; fileRef = 882D071817614FA7009EDA69 /* RACTargetQueueScheduler.m */; }; + 882D071F17615139009EDA69 /* RACTargetQueueScheduler.m in Sources */ = {isa = PBXBuildFile; fileRef = 882D071817614FA7009EDA69 /* RACTargetQueueScheduler.m */; }; + 882D072117615381009EDA69 /* RACQueueScheduler+Subclass.h in Headers */ = {isa = PBXBuildFile; fileRef = 882D07201761521B009EDA69 /* RACQueueScheduler+Subclass.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 88302BFD1762A9E6003633BD /* RACTestExampleScheduler.m in Sources */ = {isa = PBXBuildFile; fileRef = 88302BFC1762A9E6003633BD /* RACTestExampleScheduler.m */; }; + 88302BFE1762A9E6003633BD /* RACTestExampleScheduler.m in Sources */ = {isa = PBXBuildFile; fileRef = 88302BFC1762A9E6003633BD /* RACTestExampleScheduler.m */; }; + 88302C2E1762C180003633BD /* RACTargetQueueSchedulerSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 88302C2D1762C180003633BD /* RACTargetQueueSchedulerSpec.m */; }; + 88302C2F1762C180003633BD /* RACTargetQueueSchedulerSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 88302C2D1762C180003633BD /* RACTargetQueueSchedulerSpec.m */; }; + 88302C961762EC79003633BD /* RACQueueScheduler.h in Headers */ = {isa = PBXBuildFile; fileRef = 881E87AA16695C5600667F7B /* RACQueueScheduler.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 88302C9B1762EC7E003633BD /* RACQueueScheduler+Subclass.h in Headers */ = {isa = PBXBuildFile; fileRef = 882D07201761521B009EDA69 /* RACQueueScheduler+Subclass.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 88302CA21762F62D003633BD /* RACTargetQueueScheduler.h in Headers */ = {isa = PBXBuildFile; fileRef = 882D071717614FA7009EDA69 /* RACTargetQueueScheduler.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 8837EA1816A5A33300FC3CDF /* RACKVOTrampoline.m in Sources */ = {isa = PBXBuildFile; fileRef = 8837EA1516A5A33300FC3CDF /* RACKVOTrampoline.m */; }; + 8837EA1916A5A33300FC3CDF /* RACKVOTrampoline.m in Sources */ = {isa = PBXBuildFile; fileRef = 8837EA1516A5A33300FC3CDF /* RACKVOTrampoline.m */; }; + 883A84DA1513964B006DB4C7 /* RACBehaviorSubject.h in Headers */ = {isa = PBXBuildFile; fileRef = 883A84D81513964B006DB4C7 /* RACBehaviorSubject.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 883A84DB1513964B006DB4C7 /* RACBehaviorSubject.m in Sources */ = {isa = PBXBuildFile; fileRef = 883A84D91513964B006DB4C7 /* RACBehaviorSubject.m */; }; + 883A84DF1513B5EC006DB4C7 /* RACDisposable.h in Headers */ = {isa = PBXBuildFile; fileRef = 883A84DD1513B5EC006DB4C7 /* RACDisposable.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 883A84E01513B5EC006DB4C7 /* RACDisposable.m in Sources */ = {isa = PBXBuildFile; fileRef = 883A84DE1513B5EC006DB4C7 /* RACDisposable.m */; }; + 88442A341608A9AD00636B49 /* RACTestObject.m in Sources */ = {isa = PBXBuildFile; fileRef = 88442A331608A9AD00636B49 /* RACTestObject.m */; }; + 884476E4152367D100958F44 /* RACScopedDisposable.h in Headers */ = {isa = PBXBuildFile; fileRef = 884476E2152367D100958F44 /* RACScopedDisposable.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 884476E5152367D100958F44 /* RACScopedDisposable.m in Sources */ = {isa = PBXBuildFile; fileRef = 884476E3152367D100958F44 /* RACScopedDisposable.m */; }; + 884848B615F658B800B11BD0 /* NSControlRACSupportSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 884848B515F658B800B11BD0 /* NSControlRACSupportSpec.m */; }; + 8851A38B16161D500050D47F /* NSObjectRACPropertySubscribingSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 8851A38A16161D500050D47F /* NSObjectRACPropertySubscribingSpec.m */; }; + 886678711518DCD800DE77EC /* NSObject+RACPropertySubscribing.m in Sources */ = {isa = PBXBuildFile; fileRef = 886678701518DCD800DE77EC /* NSObject+RACPropertySubscribing.m */; }; + 886CEACD163DE669007632D1 /* RACBlockTrampolineSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 886CEACC163DE669007632D1 /* RACBlockTrampolineSpec.m */; }; + 886CEAE2163DE942007632D1 /* NSObject+RACLifting.h in Headers */ = {isa = PBXBuildFile; fileRef = 886CEAE0163DE942007632D1 /* NSObject+RACLifting.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 886CEAE4163DE942007632D1 /* NSObject+RACLifting.m in Sources */ = {isa = PBXBuildFile; fileRef = 886CEAE1163DE942007632D1 /* NSObject+RACLifting.m */; }; + 886CEAE5163DE942007632D1 /* NSObject+RACLifting.m in Sources */ = {isa = PBXBuildFile; fileRef = 886CEAE1163DE942007632D1 /* NSObject+RACLifting.m */; }; + 886F702A1551CF920045D68B /* RACGroupedSignal.h in Headers */ = {isa = PBXBuildFile; fileRef = 886F70281551CF920045D68B /* RACGroupedSignal.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 886F702B1551CF920045D68B /* RACGroupedSignal.m in Sources */ = {isa = PBXBuildFile; fileRef = 886F70291551CF920045D68B /* RACGroupedSignal.m */; }; + 886F702C1551CF9D0045D68B /* RACGroupedSignal.m in Sources */ = {isa = PBXBuildFile; fileRef = 886F70291551CF920045D68B /* RACGroupedSignal.m */; }; + 887ACDA9165878A8009190AD /* NSInvocation+RACTypeParsing.m in Sources */ = {isa = PBXBuildFile; fileRef = 887ACDA6165878A7009190AD /* NSInvocation+RACTypeParsing.m */; }; + 887ACDAA165878A8009190AD /* NSInvocation+RACTypeParsing.m in Sources */ = {isa = PBXBuildFile; fileRef = 887ACDA6165878A7009190AD /* NSInvocation+RACTypeParsing.m */; }; + 8882D4601673B0450080E7CD /* RACBlockTrampoline.m in Sources */ = {isa = PBXBuildFile; fileRef = 888439A21634E10D00DED0DB /* RACBlockTrampoline.m */; }; + 8884DD651756ACF600F6C379 /* RACSignalStartExamples.m in Sources */ = {isa = PBXBuildFile; fileRef = 8884DD641756ACF600F6C379 /* RACSignalStartExamples.m */; }; + 8884DD6B1756B65300F6C379 /* RACSignalStartExamples.m in Sources */ = {isa = PBXBuildFile; fileRef = 8884DD641756ACF600F6C379 /* RACSignalStartExamples.m */; }; + 88977C3E1512914A00A09EC5 /* RACSignal.m in Sources */ = {isa = PBXBuildFile; fileRef = 88977C3D1512914A00A09EC5 /* RACSignal.m */; }; + 889D0A8015974B2A00F833E3 /* RACSubjectSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 889D0A7F15974B2A00F833E3 /* RACSubjectSpec.m */; }; + 88A0B6D2165B2B09005DE8F3 /* RACBlockTrampoline.m in Sources */ = {isa = PBXBuildFile; fileRef = 888439A21634E10D00DED0DB /* RACBlockTrampoline.m */; }; + 88A0B6D3165B2B77005DE8F3 /* RACSubscriptingAssignmentTrampoline.h in Headers */ = {isa = PBXBuildFile; fileRef = 88FC735316114F9C00F8A774 /* RACSubscriptingAssignmentTrampoline.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 88B76F8E153726B00053EAE2 /* RACTuple.h in Headers */ = {isa = PBXBuildFile; fileRef = 88B76F8C153726B00053EAE2 /* RACTuple.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 88B76F8F153726B00053EAE2 /* RACTuple.m in Sources */ = {isa = PBXBuildFile; fileRef = 88B76F8D153726B00053EAE2 /* RACTuple.m */; }; + 88C5A0241692460A0045EF05 /* RACMulticastConnection.h in Headers */ = {isa = PBXBuildFile; fileRef = 88C5A0231692460A0045EF05 /* RACMulticastConnection.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 88C5A026169246140045EF05 /* RACMulticastConnection.m in Sources */ = {isa = PBXBuildFile; fileRef = 88C5A025169246140045EF05 /* RACMulticastConnection.m */; }; + 88C5A027169246140045EF05 /* RACMulticastConnection.m in Sources */ = {isa = PBXBuildFile; fileRef = 88C5A025169246140045EF05 /* RACMulticastConnection.m */; }; + 88C5A02916924BFC0045EF05 /* RACMulticastConnectionSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 88C5A02816924BFC0045EF05 /* RACMulticastConnectionSpec.m */; }; + 88CDF7DE15000FCF00163A9F /* SenTestingKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 88CDF7DD15000FCF00163A9F /* SenTestingKit.framework */; }; + 88CDF7DF15000FCF00163A9F /* Cocoa.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 88CDF7BF15000FCE00163A9F /* Cocoa.framework */; }; + 88CDF7E715000FCF00163A9F /* InfoPlist.strings in Resources */ = {isa = PBXBuildFile; fileRef = 88CDF7E515000FCF00163A9F /* InfoPlist.strings */; }; + 88D4AB3E1510F6C30011494F /* RACReplaySubject.h in Headers */ = {isa = PBXBuildFile; fileRef = 88D4AB3C1510F6C30011494F /* RACReplaySubject.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 88D4AB3F1510F6C30011494F /* RACReplaySubject.m in Sources */ = {isa = PBXBuildFile; fileRef = 88D4AB3D1510F6C30011494F /* RACReplaySubject.m */; }; + 88DA309815071CBA00C19D0F /* RACValueTransformer.m in Sources */ = {isa = PBXBuildFile; fileRef = 88DA309615071CBA00C19D0F /* RACValueTransformer.m */; }; + 88E2C6B4153C771C00C7493C /* RACScheduler.h in Headers */ = {isa = PBXBuildFile; fileRef = 88E2C6B2153C771C00C7493C /* RACScheduler.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 88E2C6B5153C771C00C7493C /* RACScheduler.m in Sources */ = {isa = PBXBuildFile; fileRef = 88E2C6B3153C771C00C7493C /* RACScheduler.m */; }; + 88F440BA153DAD570097B4C3 /* RACCommand.m in Sources */ = {isa = PBXBuildFile; fileRef = 882093EA1501E6EE00796685 /* RACCommand.m */; }; + 88F440BC153DAD5A0097B4C3 /* RACSubscriber.m in Sources */ = {isa = PBXBuildFile; fileRef = 88CDF7FB150019CA00163A9F /* RACSubscriber.m */; }; + 88F440BD153DAD5C0097B4C3 /* RACSignal.m in Sources */ = {isa = PBXBuildFile; fileRef = 88977C3D1512914A00A09EC5 /* RACSignal.m */; }; + 88F440C0153DAD630097B4C3 /* RACSubject.m in Sources */ = {isa = PBXBuildFile; fileRef = 880B9175150B09190008488E /* RACSubject.m */; }; + 88F440C1153DAD640097B4C3 /* RACReplaySubject.m in Sources */ = {isa = PBXBuildFile; fileRef = 88D4AB3D1510F6C30011494F /* RACReplaySubject.m */; }; + 88F440C3153DAD690097B4C3 /* RACBehaviorSubject.m in Sources */ = {isa = PBXBuildFile; fileRef = 883A84D91513964B006DB4C7 /* RACBehaviorSubject.m */; }; + 88F440C5153DAD6C0097B4C3 /* RACDisposable.m in Sources */ = {isa = PBXBuildFile; fileRef = 883A84DE1513B5EC006DB4C7 /* RACDisposable.m */; }; + 88F440C6153DAD6E0097B4C3 /* RACScopedDisposable.m in Sources */ = {isa = PBXBuildFile; fileRef = 884476E3152367D100958F44 /* RACScopedDisposable.m */; }; + 88F440C9153DAD740097B4C3 /* RACUnit.m in Sources */ = {isa = PBXBuildFile; fileRef = 881B37CB152260BF0079220B /* RACUnit.m */; }; + 88F440CA153DAD760097B4C3 /* RACTuple.m in Sources */ = {isa = PBXBuildFile; fileRef = 88B76F8D153726B00053EAE2 /* RACTuple.m */; }; + 88F440CB153DAD780097B4C3 /* RACScheduler.m in Sources */ = {isa = PBXBuildFile; fileRef = 88E2C6B3153C771C00C7493C /* RACScheduler.m */; }; + 88F440CE153DAD830097B4C3 /* NSObject+RACKVOWrapper.m in Sources */ = {isa = PBXBuildFile; fileRef = 88CDF82915008BB900163A9F /* NSObject+RACKVOWrapper.m */; }; + 88F440CF153DAD850097B4C3 /* NSObject+RACPropertySubscribing.m in Sources */ = {isa = PBXBuildFile; fileRef = 886678701518DCD800DE77EC /* NSObject+RACPropertySubscribing.m */; }; + 88F440D3153DADEA0097B4C3 /* NSObject+RACAppKitBindings.h in Headers */ = {isa = PBXBuildFile; fileRef = 88F440D1153DADEA0097B4C3 /* NSObject+RACAppKitBindings.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 88F440D4153DADEA0097B4C3 /* NSObject+RACAppKitBindings.m in Sources */ = {isa = PBXBuildFile; fileRef = 88F440D2153DADEA0097B4C3 /* NSObject+RACAppKitBindings.m */; }; + 88F44263153DC2C70097B4C3 /* UIControl+RACSignalSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 88F44260153DC0450097B4C3 /* UIControl+RACSignalSupport.m */; }; + 88F44267153DCAC50097B4C3 /* UITextField+RACSignalSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 88F44265153DCAC50097B4C3 /* UITextField+RACSignalSupport.m */; }; + 88FC735716114F9C00F8A774 /* RACSubscriptingAssignmentTrampoline.m in Sources */ = {isa = PBXBuildFile; fileRef = 88FC735416114F9C00F8A774 /* RACSubscriptingAssignmentTrampoline.m */; }; + 88FC735816114F9C00F8A774 /* RACSubscriptingAssignmentTrampoline.m in Sources */ = {isa = PBXBuildFile; fileRef = 88FC735416114F9C00F8A774 /* RACSubscriptingAssignmentTrampoline.m */; }; + 88FC735B16114FFB00F8A774 /* RACSubscriptingAssignmentTrampolineSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = 88FC735A16114FFB00F8A774 /* RACSubscriptingAssignmentTrampolineSpec.m */; }; + A1FCC27715666AA3008C9686 /* UITextView+RACSignalSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = A1FCC27315666AA3008C9686 /* UITextView+RACSignalSupport.m */; }; + A1FCC374156754A7008C9686 /* RACObjCRuntime.m in Sources */ = {isa = PBXBuildFile; fileRef = A1FCC371156754A7008C9686 /* RACObjCRuntime.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; }; + A1FCC375156754A7008C9686 /* RACObjCRuntime.m in Sources */ = {isa = PBXBuildFile; fileRef = A1FCC371156754A7008C9686 /* RACObjCRuntime.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; }; + A1FCC37B1567DED0008C9686 /* RACDelegateProxy.m in Sources */ = {isa = PBXBuildFile; fileRef = A1FCC3771567DED0008C9686 /* RACDelegateProxy.m */; }; + AC65FD52176DECB1005ED22B /* UIAlertViewRACSupportSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = AC65FD51176DECB1005ED22B /* UIAlertViewRACSupportSpec.m */; }; + ACB0EAF31797DDD400942FFC /* UIAlertView+RACSignalSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = ACB0EAF11797DDD400942FFC /* UIAlertView+RACSignalSupport.m */; }; + ACB0EAF41797DDD400942FFC /* UIAlertView+RACSignalSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = ACB0EAF21797DDD400942FFC /* UIAlertView+RACSignalSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + BE527E9318636F7F006349E8 /* NSUserDefaults+RACSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = BE527E9118636F7F006349E8 /* NSUserDefaults+RACSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + BE527E9418636F7F006349E8 /* NSUserDefaults+RACSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = BE527E9118636F7F006349E8 /* NSUserDefaults+RACSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + BE527E9518636F7F006349E8 /* NSUserDefaults+RACSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = BE527E9118636F7F006349E8 /* NSUserDefaults+RACSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + BE527E9618636F7F006349E8 /* NSUserDefaults+RACSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = BE527E9218636F7F006349E8 /* NSUserDefaults+RACSupport.m */; }; + BE527E9718636F7F006349E8 /* NSUserDefaults+RACSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = BE527E9218636F7F006349E8 /* NSUserDefaults+RACSupport.m */; }; + BE527E9818636F7F006349E8 /* NSUserDefaults+RACSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = BE527E9218636F7F006349E8 /* NSUserDefaults+RACSupport.m */; }; + BE527E9F1863705B006349E8 /* NSUserDefaultsRACSupportSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = BE527E9E1863705B006349E8 /* NSUserDefaultsRACSupportSpec.m */; }; + BE527EA01863706B006349E8 /* NSUserDefaultsRACSupportSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = BE527E9E1863705B006349E8 /* NSUserDefaultsRACSupportSpec.m */; }; + CD11C6F318714CD0007C7CFD /* UITableViewHeaderFooterView+RACSignalSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = CD11C6F118714CD0007C7CFD /* UITableViewHeaderFooterView+RACSignalSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + CD11C6F418714CD0007C7CFD /* UITableViewHeaderFooterView+RACSignalSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = CD11C6F218714CD0007C7CFD /* UITableViewHeaderFooterView+RACSignalSupport.m */; }; + CD11C6FF18714F00007C7CFD /* RACTestTableViewController.m in Sources */ = {isa = PBXBuildFile; fileRef = CD11C6FD18714DFB007C7CFD /* RACTestTableViewController.m */; }; + CD11C700187151AE007C7CFD /* UITableViewHeaderFooterViewRACSupportSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = CD11C6F918714DC1007C7CFD /* UITableViewHeaderFooterViewRACSupportSpec.m */; }; + D004BC9C177E1A2B00A5B8C5 /* UIActionSheetRACSupportSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D004BC9B177E1A2B00A5B8C5 /* UIActionSheetRACSupportSpec.m */; }; + D005A259169A3B7D00A9D2DB /* RACBacktrace.h in Headers */ = {isa = PBXBuildFile; fileRef = D02538A115E2D7FB005BACB8 /* RACBacktrace.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D00930791788AB7B00EE7E8B /* RACTestScheduler.h in Headers */ = {isa = PBXBuildFile; fileRef = D00930771788AB7B00EE7E8B /* RACTestScheduler.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D009307A1788AB7B00EE7E8B /* RACTestScheduler.h in Headers */ = {isa = PBXBuildFile; fileRef = D00930771788AB7B00EE7E8B /* RACTestScheduler.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D009307B1788AB7B00EE7E8B /* RACTestScheduler.m in Sources */ = {isa = PBXBuildFile; fileRef = D00930781788AB7B00EE7E8B /* RACTestScheduler.m */; }; + D009307C1788AB7B00EE7E8B /* RACTestScheduler.m in Sources */ = {isa = PBXBuildFile; fileRef = D00930781788AB7B00EE7E8B /* RACTestScheduler.m */; }; + D011F9D01782AFD400EE7E38 /* NSObjectRACAppKitBindingsSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D011F9CF1782AFD400EE7E38 /* NSObjectRACAppKitBindingsSpec.m */; }; + D013A3D91807B5ED0072B6CE /* RACErrorSignal.m in Sources */ = {isa = PBXBuildFile; fileRef = D013A3D51807B5ED0072B6CE /* RACErrorSignal.m */; }; + D013A3DA1807B5ED0072B6CE /* RACErrorSignal.m in Sources */ = {isa = PBXBuildFile; fileRef = D013A3D51807B5ED0072B6CE /* RACErrorSignal.m */; }; + D013A3DB1807B5ED0072B6CE /* RACErrorSignal.m in Sources */ = {isa = PBXBuildFile; fileRef = D013A3D51807B5ED0072B6CE /* RACErrorSignal.m */; }; + D013A3E11807B7450072B6CE /* RACEmptySignal.m in Sources */ = {isa = PBXBuildFile; fileRef = D013A3DD1807B7450072B6CE /* RACEmptySignal.m */; }; + D013A3E21807B7450072B6CE /* RACEmptySignal.m in Sources */ = {isa = PBXBuildFile; fileRef = D013A3DD1807B7450072B6CE /* RACEmptySignal.m */; }; + D013A3E31807B7450072B6CE /* RACEmptySignal.m in Sources */ = {isa = PBXBuildFile; fileRef = D013A3DD1807B7450072B6CE /* RACEmptySignal.m */; }; + D013A3E91807B7C30072B6CE /* RACReturnSignal.m in Sources */ = {isa = PBXBuildFile; fileRef = D013A3E51807B7C30072B6CE /* RACReturnSignal.m */; }; + D013A3EA1807B7C30072B6CE /* RACReturnSignal.m in Sources */ = {isa = PBXBuildFile; fileRef = D013A3E51807B7C30072B6CE /* RACReturnSignal.m */; }; + D013A3EB1807B7C30072B6CE /* RACReturnSignal.m in Sources */ = {isa = PBXBuildFile; fileRef = D013A3E51807B7C30072B6CE /* RACReturnSignal.m */; }; + D013A3F21807B9690072B6CE /* RACDynamicSignal.m in Sources */ = {isa = PBXBuildFile; fileRef = D013A3EE1807B9690072B6CE /* RACDynamicSignal.m */; }; + D013A3F31807B9690072B6CE /* RACDynamicSignal.m in Sources */ = {isa = PBXBuildFile; fileRef = D013A3EE1807B9690072B6CE /* RACDynamicSignal.m */; }; + D013A3F41807B9690072B6CE /* RACDynamicSignal.m in Sources */ = {isa = PBXBuildFile; fileRef = D013A3EE1807B9690072B6CE /* RACDynamicSignal.m */; }; + D020F3DB17F6A3E40092BED2 /* RACCompoundDisposableProvider.d in Sources */ = {isa = PBXBuildFile; fileRef = D020F3DA17F6A3E40092BED2 /* RACCompoundDisposableProvider.d */; }; + D020F3DC17F6A3E40092BED2 /* RACCompoundDisposableProvider.d in Sources */ = {isa = PBXBuildFile; fileRef = D020F3DA17F6A3E40092BED2 /* RACCompoundDisposableProvider.d */; }; + D02221621678910900DBD031 /* RACTupleSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D02221611678910900DBD031 /* RACTupleSpec.m */; }; + D028DB74179E53CB00D1042F /* RACSerialDisposable.h in Headers */ = {isa = PBXBuildFile; fileRef = D028DB72179E53CB00D1042F /* RACSerialDisposable.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D028DB75179E53CB00D1042F /* RACSerialDisposable.h in Headers */ = {isa = PBXBuildFile; fileRef = D028DB72179E53CB00D1042F /* RACSerialDisposable.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D028DB76179E53CB00D1042F /* RACSerialDisposable.m in Sources */ = {isa = PBXBuildFile; fileRef = D028DB73179E53CB00D1042F /* RACSerialDisposable.m */; }; + D028DB77179E53CB00D1042F /* RACSerialDisposable.m in Sources */ = {isa = PBXBuildFile; fileRef = D028DB73179E53CB00D1042F /* RACSerialDisposable.m */; }; + D028DB7D179E591E00D1042F /* RACSerialDisposableSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D028DB7C179E591E00D1042F /* RACSerialDisposableSpec.m */; }; + D028DB7E179E591E00D1042F /* RACSerialDisposableSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D028DB7C179E591E00D1042F /* RACSerialDisposableSpec.m */; }; + D028DB87179E616700D1042F /* UITableViewCell+RACSignalSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = D028DB85179E616700D1042F /* UITableViewCell+RACSignalSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D028DB88179E616700D1042F /* UITableViewCell+RACSignalSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = D028DB86179E616700D1042F /* UITableViewCell+RACSignalSupport.m */; }; + D0307EDF1731AAE100D83211 /* RACTupleSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0307EDC1731AAE100D83211 /* RACTupleSequence.m */; }; + D0307EE01731AAE100D83211 /* RACTupleSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0307EDC1731AAE100D83211 /* RACTupleSequence.m */; }; + D03525D417E2EBC90099CBAB /* RACSignalProvider.d in Sources */ = {isa = PBXBuildFile; fileRef = D03525D317E2EBC90099CBAB /* RACSignalProvider.d */; }; + D03525D917E2FAAD0099CBAB /* RACSignalProvider.d in Sources */ = {isa = PBXBuildFile; fileRef = D03525D317E2EBC90099CBAB /* RACSignalProvider.d */; }; + D041376915D2281C004BBF80 /* RACKVOWrapperSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D041376815D2281C004BBF80 /* RACKVOWrapperSpec.m */; }; + D0487AB3164314430085D890 /* RACStreamExamples.m in Sources */ = {isa = PBXBuildFile; fileRef = D0487AB2164314430085D890 /* RACStreamExamples.m */; }; + D049804217F91F42001EE042 /* EXTRuntimeExtensions.m in Sources */ = {isa = PBXBuildFile; fileRef = D05F9D3417984EC000FD7982 /* EXTRuntimeExtensions.m */; }; + D05AD39617F2D5700080895B /* Cocoa.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = D05AD39517F2D5700080895B /* Cocoa.framework */; }; + D05AD3BF17F2DA2A0080895B /* RACSubscriber.m in Sources */ = {isa = PBXBuildFile; fileRef = 88CDF7FB150019CA00163A9F /* RACSubscriber.m */; }; + D05AD3C017F2DA300080895B /* RACSubscriber.h in Headers */ = {isa = PBXBuildFile; fileRef = 88CDF7FA150019CA00163A9F /* RACSubscriber.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD3C117F2DB100080895B /* RACPassthroughSubscriber.m in Sources */ = {isa = PBXBuildFile; fileRef = D0A0E22D176A8CD6007273ED /* RACPassthroughSubscriber.m */; }; + D05AD3C217F2DB100080895B /* RACBlockTrampoline.m in Sources */ = {isa = PBXBuildFile; fileRef = 888439A21634E10D00DED0DB /* RACBlockTrampoline.m */; }; + D05AD3C317F2DB100080895B /* RACUnit.h in Headers */ = {isa = PBXBuildFile; fileRef = 881B37CA152260BF0079220B /* RACUnit.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD3C417F2DB100080895B /* RACUnit.m in Sources */ = {isa = PBXBuildFile; fileRef = 881B37CB152260BF0079220B /* RACUnit.m */; }; + D05AD3C517F2DB100080895B /* RACTuple.h in Headers */ = {isa = PBXBuildFile; fileRef = 88B76F8C153726B00053EAE2 /* RACTuple.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD3C617F2DB100080895B /* RACTuple.m in Sources */ = {isa = PBXBuildFile; fileRef = 88B76F8D153726B00053EAE2 /* RACTuple.m */; }; + D05AD3C717F2DB100080895B /* RACBacktrace.h in Headers */ = {isa = PBXBuildFile; fileRef = D02538A115E2D7FB005BACB8 /* RACBacktrace.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD3C817F2DB100080895B /* RACBacktrace.m in Sources */ = {isa = PBXBuildFile; fileRef = D0DFBCCD15DD6D40009DADB3 /* RACBacktrace.m */; }; + D05AD3C917F2DB100080895B /* RACSubscriptingAssignmentTrampoline.h in Headers */ = {isa = PBXBuildFile; fileRef = 88FC735316114F9C00F8A774 /* RACSubscriptingAssignmentTrampoline.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD3CA17F2DB100080895B /* RACSubscriptingAssignmentTrampoline.m in Sources */ = {isa = PBXBuildFile; fileRef = 88FC735416114F9C00F8A774 /* RACSubscriptingAssignmentTrampoline.m */; }; + D05AD3CB17F2DB100080895B /* NSObject+RACDeallocating.h in Headers */ = {isa = PBXBuildFile; fileRef = 6E58405316F22D7500F588A6 /* NSObject+RACDeallocating.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD3CC17F2DB100080895B /* NSObject+RACDeallocating.m in Sources */ = {isa = PBXBuildFile; fileRef = 6E58405416F22D7500F588A6 /* NSObject+RACDeallocating.m */; }; + D05AD3CD17F2DB100080895B /* NSObject+RACLifting.h in Headers */ = {isa = PBXBuildFile; fileRef = 886CEAE0163DE942007632D1 /* NSObject+RACLifting.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD3CE17F2DB100080895B /* NSObject+RACLifting.m in Sources */ = {isa = PBXBuildFile; fileRef = 886CEAE1163DE942007632D1 /* NSObject+RACLifting.m */; }; + D05AD3CF17F2DB100080895B /* NSInvocation+RACTypeParsing.m in Sources */ = {isa = PBXBuildFile; fileRef = 887ACDA6165878A7009190AD /* NSInvocation+RACTypeParsing.m */; }; + D05AD3D017F2DB100080895B /* RACStream.h in Headers */ = {isa = PBXBuildFile; fileRef = D0D486FF1642550100DD7605 /* RACStream.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD3D117F2DB100080895B /* RACStream.m in Sources */ = {isa = PBXBuildFile; fileRef = D0D487001642550100DD7605 /* RACStream.m */; }; + D05AD3D217F2DB1D0080895B /* RACSignal.h in Headers */ = {isa = PBXBuildFile; fileRef = 88CDF80415001CA800163A9F /* RACSignal.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD3D317F2DB1D0080895B /* RACSignal.m in Sources */ = {isa = PBXBuildFile; fileRef = 88977C3D1512914A00A09EC5 /* RACSignal.m */; }; + D05AD3D417F2DB1D0080895B /* RACSignal+Operations.h in Headers */ = {isa = PBXBuildFile; fileRef = D0D910CC15F915BD00AD2DDA /* RACSignal+Operations.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD3D517F2DB1D0080895B /* RACSignal+Operations.m in Sources */ = {isa = PBXBuildFile; fileRef = D0D910CD15F915BD00AD2DDA /* RACSignal+Operations.m */; }; + D05AD3D617F2DB1D0080895B /* RACEvent.h in Headers */ = {isa = PBXBuildFile; fileRef = D077A16B169B740200057BB1 /* RACEvent.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD3D717F2DB1D0080895B /* RACEvent.m in Sources */ = {isa = PBXBuildFile; fileRef = D077A16C169B740200057BB1 /* RACEvent.m */; }; + D05AD3D817F2DB1D0080895B /* RACMulticastConnection.h in Headers */ = {isa = PBXBuildFile; fileRef = 88C5A0231692460A0045EF05 /* RACMulticastConnection.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD3D917F2DB1D0080895B /* RACMulticastConnection.m in Sources */ = {isa = PBXBuildFile; fileRef = 88C5A025169246140045EF05 /* RACMulticastConnection.m */; }; + D05AD3DA17F2DB1D0080895B /* RACGroupedSignal.h in Headers */ = {isa = PBXBuildFile; fileRef = 886F70281551CF920045D68B /* RACGroupedSignal.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD3DB17F2DB1D0080895B /* RACGroupedSignal.m in Sources */ = {isa = PBXBuildFile; fileRef = 886F70291551CF920045D68B /* RACGroupedSignal.m */; }; + D05AD3DC17F2DB1D0080895B /* RACSubject.h in Headers */ = {isa = PBXBuildFile; fileRef = 880B9174150B09190008488E /* RACSubject.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD3DD17F2DB1D0080895B /* RACSubject.m in Sources */ = {isa = PBXBuildFile; fileRef = 880B9175150B09190008488E /* RACSubject.m */; }; + D05AD3DE17F2DB1D0080895B /* RACReplaySubject.h in Headers */ = {isa = PBXBuildFile; fileRef = 88D4AB3C1510F6C30011494F /* RACReplaySubject.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD3DF17F2DB1D0080895B /* RACReplaySubject.m in Sources */ = {isa = PBXBuildFile; fileRef = 88D4AB3D1510F6C30011494F /* RACReplaySubject.m */; }; + D05AD3E017F2DB1D0080895B /* RACBehaviorSubject.h in Headers */ = {isa = PBXBuildFile; fileRef = 883A84D81513964B006DB4C7 /* RACBehaviorSubject.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD3E117F2DB1D0080895B /* RACBehaviorSubject.m in Sources */ = {isa = PBXBuildFile; fileRef = 883A84D91513964B006DB4C7 /* RACBehaviorSubject.m */; }; + D05AD3E217F2DB230080895B /* RACDisposable.h in Headers */ = {isa = PBXBuildFile; fileRef = 883A84DD1513B5EC006DB4C7 /* RACDisposable.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD3E317F2DB230080895B /* RACDisposable.m in Sources */ = {isa = PBXBuildFile; fileRef = 883A84DE1513B5EC006DB4C7 /* RACDisposable.m */; }; + D05AD3E417F2DB230080895B /* RACScopedDisposable.h in Headers */ = {isa = PBXBuildFile; fileRef = 884476E2152367D100958F44 /* RACScopedDisposable.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD3E517F2DB230080895B /* RACScopedDisposable.m in Sources */ = {isa = PBXBuildFile; fileRef = 884476E3152367D100958F44 /* RACScopedDisposable.m */; }; + D05AD3E617F2DB230080895B /* RACCompoundDisposable.h in Headers */ = {isa = PBXBuildFile; fileRef = 881E86A01669304700667F7B /* RACCompoundDisposable.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD3E717F2DB230080895B /* RACCompoundDisposable.m in Sources */ = {isa = PBXBuildFile; fileRef = 881E86A11669304700667F7B /* RACCompoundDisposable.m */; }; + D05AD3E817F2DB230080895B /* RACSerialDisposable.h in Headers */ = {isa = PBXBuildFile; fileRef = D028DB72179E53CB00D1042F /* RACSerialDisposable.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD3E917F2DB230080895B /* RACSerialDisposable.m in Sources */ = {isa = PBXBuildFile; fileRef = D028DB73179E53CB00D1042F /* RACSerialDisposable.m */; }; + D05AD3EA17F2DB270080895B /* RACCommand.h in Headers */ = {isa = PBXBuildFile; fileRef = 882093E91501E6EE00796685 /* RACCommand.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD3EB17F2DB270080895B /* RACCommand.m in Sources */ = {isa = PBXBuildFile; fileRef = 882093EA1501E6EE00796685 /* RACCommand.m */; }; + D05AD3EE17F2DB4F0080895B /* RACSequence.h in Headers */ = {isa = PBXBuildFile; fileRef = D0E967671641EF9C00FCFF06 /* RACSequence.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD3EF17F2DB4F0080895B /* RACSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E967681641EF9C00FCFF06 /* RACSequence.m */; }; + D05AD3F017F2DB4F0080895B /* RACArraySequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E967621641EF9C00FCFF06 /* RACArraySequence.m */; }; + D05AD3F117F2DB4F0080895B /* RACDynamicSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E967641641EF9C00FCFF06 /* RACDynamicSequence.m */; }; + D05AD3F217F2DB4F0080895B /* RACEagerSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F9743F61694A2460024EB82 /* RACEagerSequence.m */; }; + D05AD3F317F2DB4F0080895B /* RACEmptySequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E967661641EF9C00FCFF06 /* RACEmptySequence.m */; }; + D05AD3F417F2DB4F0080895B /* RACStringSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E9676A1641EF9C00FCFF06 /* RACStringSequence.m */; }; + D05AD3F517F2DB4F0080895B /* RACSignalSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0EE284A164D906B006954A4 /* RACSignalSequence.m */; }; + D05AD3F617F2DB4F0080895B /* RACTupleSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0307EDC1731AAE100D83211 /* RACTupleSequence.m */; }; + D05AD3F717F2DB4F0080895B /* RACUnarySequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D07CD7151731BA3900DE2394 /* RACUnarySequence.m */; }; + D05AD3FA17F2DB5D0080895B /* RACScheduler.h in Headers */ = {isa = PBXBuildFile; fileRef = 88E2C6B2153C771C00C7493C /* RACScheduler.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD3FB17F2DB5D0080895B /* RACScheduler.m in Sources */ = {isa = PBXBuildFile; fileRef = 88E2C6B3153C771C00C7493C /* RACScheduler.m */; }; + D05AD3FC17F2DB5D0080895B /* RACQueueScheduler.h in Headers */ = {isa = PBXBuildFile; fileRef = 881E87AA16695C5600667F7B /* RACQueueScheduler.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD3FD17F2DB5D0080895B /* RACQueueScheduler+Subclass.h in Headers */ = {isa = PBXBuildFile; fileRef = 882D07201761521B009EDA69 /* RACQueueScheduler+Subclass.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD3FE17F2DB5D0080895B /* RACQueueScheduler.m in Sources */ = {isa = PBXBuildFile; fileRef = 881E87AB16695C5600667F7B /* RACQueueScheduler.m */; }; + D05AD3FF17F2DB5D0080895B /* RACTargetQueueScheduler.h in Headers */ = {isa = PBXBuildFile; fileRef = 882D071717614FA7009EDA69 /* RACTargetQueueScheduler.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD40017F2DB5D0080895B /* RACTargetQueueScheduler.m in Sources */ = {isa = PBXBuildFile; fileRef = 882D071817614FA7009EDA69 /* RACTargetQueueScheduler.m */; }; + D05AD40217F2DB5D0080895B /* RACImmediateScheduler.m in Sources */ = {isa = PBXBuildFile; fileRef = 881E87B116695EDF00667F7B /* RACImmediateScheduler.m */; }; + D05AD40317F2DB5D0080895B /* RACSubscriptionScheduler.h in Headers */ = {isa = PBXBuildFile; fileRef = 881E87C21669635F00667F7B /* RACSubscriptionScheduler.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD40417F2DB5D0080895B /* RACSubscriptionScheduler.m in Sources */ = {isa = PBXBuildFile; fileRef = 881E87C31669636000667F7B /* RACSubscriptionScheduler.m */; }; + D05AD40517F2DB5D0080895B /* RACTestScheduler.h in Headers */ = {isa = PBXBuildFile; fileRef = D00930771788AB7B00EE7E8B /* RACTestScheduler.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD40617F2DB5D0080895B /* RACTestScheduler.m in Sources */ = {isa = PBXBuildFile; fileRef = D00930781788AB7B00EE7E8B /* RACTestScheduler.m */; }; + D05AD40717F2DB6A0080895B /* NSArray+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = D0E967571641EF9C00FCFF06 /* NSArray+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD40817F2DB6A0080895B /* NSArray+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E967581641EF9C00FCFF06 /* NSArray+RACSequenceAdditions.m */; }; + D05AD40917F2DB6A0080895B /* NSData+RACSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 88442C8716090C1500636B49 /* NSData+RACSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD40A17F2DB6A0080895B /* NSData+RACSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 88442C8816090C1500636B49 /* NSData+RACSupport.m */; }; + D05AD40B17F2DB6A0080895B /* NSDictionary+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = D0E967591641EF9C00FCFF06 /* NSDictionary+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD40C17F2DB6A0080895B /* NSDictionary+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E9675A1641EF9C00FCFF06 /* NSDictionary+RACSequenceAdditions.m */; }; + D05AD40D17F2DB6A0080895B /* NSEnumerator+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = 5F773DE8169B46670023069D /* NSEnumerator+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD40E17F2DB6A0080895B /* NSEnumerator+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F773DE9169B46670023069D /* NSEnumerator+RACSequenceAdditions.m */; }; + D05AD40F17F2DB6A0080895B /* NSFileHandle+RACSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 88442C8916090C1500636B49 /* NSFileHandle+RACSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD41017F2DB6A0080895B /* NSFileHandle+RACSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 88442C8A16090C1500636B49 /* NSFileHandle+RACSupport.m */; }; + D05AD41117F2DB6A0080895B /* NSNotificationCenter+RACSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 88442C8B16090C1500636B49 /* NSNotificationCenter+RACSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD41217F2DB6A0080895B /* NSNotificationCenter+RACSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 88442C8C16090C1500636B49 /* NSNotificationCenter+RACSupport.m */; }; + D05AD41317F2DB6A0080895B /* NSObject+RACDescription.m in Sources */ = {isa = PBXBuildFile; fileRef = D0D243B61741FA0E004359C6 /* NSObject+RACDescription.m */; }; + D05AD41417F2DB6A0080895B /* NSObject+RACSelectorSignal.h in Headers */ = {isa = PBXBuildFile; fileRef = 880D7A5816F7B351004A3361 /* NSObject+RACSelectorSignal.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD41517F2DB6A0080895B /* NSObject+RACSelectorSignal.m in Sources */ = {isa = PBXBuildFile; fileRef = 880D7A5916F7B351004A3361 /* NSObject+RACSelectorSignal.m */; }; + D05AD41617F2DB6A0080895B /* NSOrderedSet+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = D0E9675B1641EF9C00FCFF06 /* NSOrderedSet+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD41717F2DB6A0080895B /* NSOrderedSet+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E9675C1641EF9C00FCFF06 /* NSOrderedSet+RACSequenceAdditions.m */; }; + D05AD41817F2DB6A0080895B /* NSSet+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = D0E9675D1641EF9C00FCFF06 /* NSSet+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD41917F2DB6A0080895B /* NSSet+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E9675E1641EF9C00FCFF06 /* NSSet+RACSequenceAdditions.m */; }; + D05AD41A17F2DB6A0080895B /* NSString+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = D0E9675F1641EF9C00FCFF06 /* NSString+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD41B17F2DB6A0080895B /* NSString+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E967601641EF9C00FCFF06 /* NSString+RACSequenceAdditions.m */; }; + D05AD41C17F2DB6A0080895B /* NSString+RACSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 88442C8D16090C1500636B49 /* NSString+RACSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD41D17F2DB6A0080895B /* NSString+RACSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 88442C8E16090C1500636B49 /* NSString+RACSupport.m */; }; + D05AD41E17F2DB6E0080895B /* NSControl+RACCommandSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 882093E61501E6CB00796685 /* NSControl+RACCommandSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD41F17F2DB6E0080895B /* NSControl+RACCommandSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 882093E71501E6CB00796685 /* NSControl+RACCommandSupport.m */; }; + D05AD42017F2DB6E0080895B /* NSControl+RACTextSignalSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = D0A0B03916EAA9AC00C47593 /* NSControl+RACTextSignalSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD42117F2DB6E0080895B /* NSControl+RACTextSignalSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = D0A0B03A16EAA9AC00C47593 /* NSControl+RACTextSignalSupport.m */; }; + D05AD42217F2DB6E0080895B /* NSObject+RACAppKitBindings.h in Headers */ = {isa = PBXBuildFile; fileRef = 88F440D1153DADEA0097B4C3 /* NSObject+RACAppKitBindings.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD42317F2DB6E0080895B /* NSObject+RACAppKitBindings.m in Sources */ = {isa = PBXBuildFile; fileRef = 88F440D2153DADEA0097B4C3 /* NSObject+RACAppKitBindings.m */; }; + D05AD42417F2DB6E0080895B /* NSText+RACSignalSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = D0A0B01316EAA3D100C47593 /* NSText+RACSignalSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD42517F2DB6E0080895B /* NSText+RACSignalSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = D0A0B01416EAA3D100C47593 /* NSText+RACSignalSupport.m */; }; + D05AD42617F2DB840080895B /* RACChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 5F6FE8511692568A00A8D7A6 /* RACChannel.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD42717F2DB840080895B /* RACChannel.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F6FE8521692568A00A8D7A6 /* RACChannel.m */; }; + D05AD42817F2DB840080895B /* RACKVOChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 5F45A883168CFA3E00B58A2B /* RACKVOChannel.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD42917F2DB840080895B /* RACKVOChannel.m in Sources */ = {isa = PBXBuildFile; fileRef = 5F45A884168CFA3E00B58A2B /* RACKVOChannel.m */; }; + D05AD42B17F2DB840080895B /* NSObject+RACKVOWrapper.m in Sources */ = {isa = PBXBuildFile; fileRef = 88CDF82915008BB900163A9F /* NSObject+RACKVOWrapper.m */; }; + D05AD42C17F2DB840080895B /* NSString+RACKeyPathUtilities.m in Sources */ = {isa = PBXBuildFile; fileRef = 5FDC35021736F54700792E52 /* NSString+RACKeyPathUtilities.m */; }; + D05AD42D17F2DB840080895B /* RACKVOTrampoline.m in Sources */ = {isa = PBXBuildFile; fileRef = 8837EA1516A5A33300FC3CDF /* RACKVOTrampoline.m */; }; + D05AD42E17F2DB840080895B /* NSObject+RACPropertySubscribing.h in Headers */ = {isa = PBXBuildFile; fileRef = 88CDF82C15008C0500163A9F /* NSObject+RACPropertySubscribing.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D05AD42F17F2DB840080895B /* NSObject+RACPropertySubscribing.m in Sources */ = {isa = PBXBuildFile; fileRef = 886678701518DCD800DE77EC /* NSObject+RACPropertySubscribing.m */; }; + D05AD43017F2DB840080895B /* RACValueTransformer.m in Sources */ = {isa = PBXBuildFile; fileRef = 88DA309615071CBA00C19D0F /* RACValueTransformer.m */; }; + D05AD43117F2DB950080895B /* RACObjCRuntime.m in Sources */ = {isa = PBXBuildFile; fileRef = A1FCC371156754A7008C9686 /* RACObjCRuntime.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; }; + D05AD43217F2DBCA0080895B /* RACSignalProvider.d in Sources */ = {isa = PBXBuildFile; fileRef = D03525D317E2EBC90099CBAB /* RACSignalProvider.d */; }; + D05F9D3717984EC000FD7982 /* EXTRuntimeExtensions.m in Sources */ = {isa = PBXBuildFile; fileRef = D05F9D3417984EC000FD7982 /* EXTRuntimeExtensions.m */; }; + D05F9D3817984EC000FD7982 /* EXTRuntimeExtensions.m in Sources */ = {isa = PBXBuildFile; fileRef = D05F9D3417984EC000FD7982 /* EXTRuntimeExtensions.m */; }; + D066C796176D262500C242D2 /* UIControlRACSupportSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D066C795176D262500C242D2 /* UIControlRACSupportSpec.m */; }; + D066C79D176D263D00C242D2 /* RACTestUIButton.m in Sources */ = {isa = PBXBuildFile; fileRef = D066C79C176D263D00C242D2 /* RACTestUIButton.m */; }; + D0700F4C1672994D00D7CD30 /* NSNotificationCenterRACSupportSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D0700F4B1672994D00D7CD30 /* NSNotificationCenterRACSupportSpec.m */; }; + D070CBC517FB5E370017F121 /* RACCompoundDisposableProvider.d in Sources */ = {isa = PBXBuildFile; fileRef = D020F3DA17F6A3E40092BED2 /* RACCompoundDisposableProvider.d */; }; + D07200251788C57200987F70 /* RACTestSchedulerSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D07200241788C57200987F70 /* RACTestSchedulerSpec.m */; }; + D07200261788C57200987F70 /* RACTestSchedulerSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D07200241788C57200987F70 /* RACTestSchedulerSpec.m */; }; + D075A72A17BCB7E100C24FB7 /* RACControlCommandExamples.m in Sources */ = {isa = PBXBuildFile; fileRef = D075A72917BCB7E100C24FB7 /* RACControlCommandExamples.m */; }; + D075A72B17BCB7E100C24FB7 /* RACControlCommandExamples.m in Sources */ = {isa = PBXBuildFile; fileRef = D075A72917BCB7E100C24FB7 /* RACControlCommandExamples.m */; }; + D077A16D169B740200057BB1 /* RACEvent.h in Headers */ = {isa = PBXBuildFile; fileRef = D077A16B169B740200057BB1 /* RACEvent.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D077A16E169B740200057BB1 /* RACEvent.h in Headers */ = {isa = PBXBuildFile; fileRef = D077A16B169B740200057BB1 /* RACEvent.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D077A16F169B740200057BB1 /* RACEvent.m in Sources */ = {isa = PBXBuildFile; fileRef = D077A16C169B740200057BB1 /* RACEvent.m */; }; + D077A170169B740200057BB1 /* RACEvent.m in Sources */ = {isa = PBXBuildFile; fileRef = D077A16C169B740200057BB1 /* RACEvent.m */; }; + D077A172169B79A900057BB1 /* RACEventSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D077A171169B79A900057BB1 /* RACEventSpec.m */; }; + D07CD7181731BA3900DE2394 /* RACUnarySequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D07CD7151731BA3900DE2394 /* RACUnarySequence.m */; }; + D07CD7191731BA3900DE2394 /* RACUnarySequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D07CD7151731BA3900DE2394 /* RACUnarySequence.m */; }; + D0870C6F16884A0600D0E11D /* RACBacktraceSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D0870C6E16884A0600D0E11D /* RACBacktraceSpec.m */; }; + D08FF264169A32D100743C6D /* ReactiveCocoa.h in Headers */ = {isa = PBXBuildFile; fileRef = 88037F8C15056328001A5B19 /* ReactiveCocoa.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D08FF265169A32DC00743C6D /* RACSubscriber.h in Headers */ = {isa = PBXBuildFile; fileRef = 88CDF7FA150019CA00163A9F /* RACSubscriber.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D08FF267169A330000743C6D /* RACUnit.h in Headers */ = {isa = PBXBuildFile; fileRef = 881B37CA152260BF0079220B /* RACUnit.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D08FF268169A330000743C6D /* RACTuple.h in Headers */ = {isa = PBXBuildFile; fileRef = 88B76F8C153726B00053EAE2 /* RACTuple.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D08FF269169A330000743C6D /* RACBacktrace.h in Headers */ = {isa = PBXBuildFile; fileRef = D02538A115E2D7FB005BACB8 /* RACBacktrace.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D08FF26A169A330000743C6D /* RACSubscriptingAssignmentTrampoline.h in Headers */ = {isa = PBXBuildFile; fileRef = 88FC735316114F9C00F8A774 /* RACSubscriptingAssignmentTrampoline.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D08FF26B169A330000743C6D /* NSObject+RACLifting.h in Headers */ = {isa = PBXBuildFile; fileRef = 886CEAE0163DE942007632D1 /* NSObject+RACLifting.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D08FF26C169A331A00743C6D /* RACStream.h in Headers */ = {isa = PBXBuildFile; fileRef = D0D486FF1642550100DD7605 /* RACStream.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D08FF26D169A331A00743C6D /* RACSignal.h in Headers */ = {isa = PBXBuildFile; fileRef = 88CDF80415001CA800163A9F /* RACSignal.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D08FF26E169A331A00743C6D /* RACSignal+Operations.h in Headers */ = {isa = PBXBuildFile; fileRef = D0D910CC15F915BD00AD2DDA /* RACSignal+Operations.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D08FF26F169A331A00743C6D /* RACMulticastConnection.h in Headers */ = {isa = PBXBuildFile; fileRef = 88C5A0231692460A0045EF05 /* RACMulticastConnection.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D08FF270169A331A00743C6D /* RACGroupedSignal.h in Headers */ = {isa = PBXBuildFile; fileRef = 886F70281551CF920045D68B /* RACGroupedSignal.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D08FF271169A331A00743C6D /* RACSubject.h in Headers */ = {isa = PBXBuildFile; fileRef = 880B9174150B09190008488E /* RACSubject.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D08FF272169A331A00743C6D /* RACReplaySubject.h in Headers */ = {isa = PBXBuildFile; fileRef = 88D4AB3C1510F6C30011494F /* RACReplaySubject.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D08FF273169A331A00743C6D /* RACBehaviorSubject.h in Headers */ = {isa = PBXBuildFile; fileRef = 883A84D81513964B006DB4C7 /* RACBehaviorSubject.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D08FF274169A331A00743C6D /* RACDisposable.h in Headers */ = {isa = PBXBuildFile; fileRef = 883A84DD1513B5EC006DB4C7 /* RACDisposable.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D08FF275169A331A00743C6D /* RACScopedDisposable.h in Headers */ = {isa = PBXBuildFile; fileRef = 884476E2152367D100958F44 /* RACScopedDisposable.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D08FF276169A331A00743C6D /* RACCompoundDisposable.h in Headers */ = {isa = PBXBuildFile; fileRef = 881E86A01669304700667F7B /* RACCompoundDisposable.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D08FF277169A331B00743C6D /* RACCommand.h in Headers */ = {isa = PBXBuildFile; fileRef = 882093E91501E6EE00796685 /* RACCommand.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D08FF278169A331B00743C6D /* RACSequence.h in Headers */ = {isa = PBXBuildFile; fileRef = D0E967671641EF9C00FCFF06 /* RACSequence.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D08FF27F169A331B00743C6D /* RACScheduler.h in Headers */ = {isa = PBXBuildFile; fileRef = 88E2C6B2153C771C00C7493C /* RACScheduler.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D08FF280169A333400743C6D /* NSArray+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = D0E967571641EF9C00FCFF06 /* NSArray+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D08FF281169A333400743C6D /* NSDictionary+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = D0E967591641EF9C00FCFF06 /* NSDictionary+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D08FF282169A333400743C6D /* NSOrderedSet+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = D0E9675B1641EF9C00FCFF06 /* NSOrderedSet+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D08FF283169A333400743C6D /* NSSet+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = D0E9675D1641EF9C00FCFF06 /* NSSet+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D08FF284169A333400743C6D /* NSString+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = D0E9675F1641EF9C00FCFF06 /* NSString+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D08FF285169A333400743C6D /* UIControl+RACSignalSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 88F4425F153DC0450097B4C3 /* UIControl+RACSignalSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D08FF286169A333400743C6D /* UITextField+RACSignalSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = 88F44264153DCAC50097B4C3 /* UITextField+RACSignalSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D08FF287169A333400743C6D /* UITextView+RACSignalSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = A1FCC27215666AA3008C9686 /* UITextView+RACSignalSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D08FF289169A333400743C6D /* NSObject+RACPropertySubscribing.h in Headers */ = {isa = PBXBuildFile; fileRef = 88CDF82C15008C0500163A9F /* NSObject+RACPropertySubscribing.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D090767F17FBEADE00EB087A /* NSURLConnection+RACSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = D090767D17FBEADE00EB087A /* NSURLConnection+RACSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D090768017FBEADE00EB087A /* NSURLConnection+RACSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = D090767D17FBEADE00EB087A /* NSURLConnection+RACSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D090768117FBEADE00EB087A /* NSURLConnection+RACSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = D090767D17FBEADE00EB087A /* NSURLConnection+RACSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D090768217FBEADE00EB087A /* NSURLConnection+RACSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = D090767E17FBEADE00EB087A /* NSURLConnection+RACSupport.m */; }; + D090768317FBEADE00EB087A /* NSURLConnection+RACSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = D090767E17FBEADE00EB087A /* NSURLConnection+RACSupport.m */; }; + D090768417FBEADE00EB087A /* NSURLConnection+RACSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = D090767E17FBEADE00EB087A /* NSURLConnection+RACSupport.m */; }; + D090768A17FBECBF00EB087A /* NSURLConnectionRACSupportSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D090768917FBECBF00EB087A /* NSURLConnectionRACSupportSpec.m */; }; + D090768B17FBECBF00EB087A /* NSURLConnectionRACSupportSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D090768917FBECBF00EB087A /* NSURLConnectionRACSupportSpec.m */; }; + D090768D17FBED2E00EB087A /* test-data.json in Resources */ = {isa = PBXBuildFile; fileRef = D090768C17FBED2E00EB087A /* test-data.json */; }; + D090768E17FBED2E00EB087A /* test-data.json in Resources */ = {isa = PBXBuildFile; fileRef = D090768C17FBED2E00EB087A /* test-data.json */; }; + D094E44917775AF200906BF7 /* EXTKeyPathCoding.h in Headers */ = {isa = PBXBuildFile; fileRef = D094E44517775AF200906BF7 /* EXTKeyPathCoding.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D094E44A17775AF200906BF7 /* EXTKeyPathCoding.h in Headers */ = {isa = PBXBuildFile; fileRef = D094E44517775AF200906BF7 /* EXTKeyPathCoding.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D094E44B17775AF200906BF7 /* EXTScope.h in Headers */ = {isa = PBXBuildFile; fileRef = D094E44617775AF200906BF7 /* EXTScope.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D094E44C17775AF200906BF7 /* EXTScope.h in Headers */ = {isa = PBXBuildFile; fileRef = D094E44617775AF200906BF7 /* EXTScope.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D094E44F17775AF200906BF7 /* metamacros.h in Headers */ = {isa = PBXBuildFile; fileRef = D094E44817775AF200906BF7 /* metamacros.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D094E45017775AF200906BF7 /* metamacros.h in Headers */ = {isa = PBXBuildFile; fileRef = D094E44817775AF200906BF7 /* metamacros.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D0A0B01516EAA3D100C47593 /* NSText+RACSignalSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = D0A0B01316EAA3D100C47593 /* NSText+RACSignalSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D0A0B01616EAA3D100C47593 /* NSText+RACSignalSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = D0A0B01416EAA3D100C47593 /* NSText+RACSignalSupport.m */; }; + D0A0B01816EAA5CC00C47593 /* NSTextRACSupportSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D0A0B01716EAA5CC00C47593 /* NSTextRACSupportSpec.m */; }; + D0A0B03B16EAA9AC00C47593 /* NSControl+RACTextSignalSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = D0A0B03916EAA9AC00C47593 /* NSControl+RACTextSignalSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D0A0B03C16EAA9AC00C47593 /* NSControl+RACTextSignalSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = D0A0B03A16EAA9AC00C47593 /* NSControl+RACTextSignalSupport.m */; }; + D0A0E226176A84DB007273ED /* RACDisposableSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D0A0E225176A84DA007273ED /* RACDisposableSpec.m */; }; + D0A0E227176A84DB007273ED /* RACDisposableSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D0A0E225176A84DA007273ED /* RACDisposableSpec.m */; }; + D0A0E230176A8CD6007273ED /* RACPassthroughSubscriber.m in Sources */ = {isa = PBXBuildFile; fileRef = D0A0E22D176A8CD6007273ED /* RACPassthroughSubscriber.m */; }; + D0A0E231176A8CD6007273ED /* RACPassthroughSubscriber.m in Sources */ = {isa = PBXBuildFile; fileRef = D0A0E22D176A8CD6007273ED /* RACPassthroughSubscriber.m */; }; + D0C55CE217759559008CDDCA /* RACDelegateProxySpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D0C55CE117759559008CDDCA /* RACDelegateProxySpec.m */; }; + D0C70EC616659333005AAD03 /* RACSubscriberExamples.m in Sources */ = {isa = PBXBuildFile; fileRef = D0C70EC516659333005AAD03 /* RACSubscriberExamples.m */; }; + D0C70EC8166595AD005AAD03 /* RACSubscriberSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D0C70EC7166595AD005AAD03 /* RACSubscriberSpec.m */; }; + D0C70F90164337A2007027B4 /* RACSequenceAdditionsSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D0C70F8F164337A2007027B4 /* RACSequenceAdditionsSpec.m */; }; + D0C70F93164337E3007027B4 /* RACSequenceExamples.m in Sources */ = {isa = PBXBuildFile; fileRef = D0C70F92164337E3007027B4 /* RACSequenceExamples.m */; }; + D0D243BD1741FA13004359C6 /* NSObject+RACDescription.m in Sources */ = {isa = PBXBuildFile; fileRef = D0D243B61741FA0E004359C6 /* NSObject+RACDescription.m */; }; + D0D243BE1741FA13004359C6 /* NSObject+RACDescription.m in Sources */ = {isa = PBXBuildFile; fileRef = D0D243B61741FA0E004359C6 /* NSObject+RACDescription.m */; }; + D0D487011642550100DD7605 /* RACStream.h in Headers */ = {isa = PBXBuildFile; fileRef = D0D486FF1642550100DD7605 /* RACStream.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D0D487031642550100DD7605 /* RACStream.m in Sources */ = {isa = PBXBuildFile; fileRef = D0D487001642550100DD7605 /* RACStream.m */; }; + D0D487041642550100DD7605 /* RACStream.m in Sources */ = {isa = PBXBuildFile; fileRef = D0D487001642550100DD7605 /* RACStream.m */; }; + D0D487061642651400DD7605 /* RACSequenceSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D0D487051642651400DD7605 /* RACSequenceSpec.m */; }; + D0D910CE15F915BD00AD2DDA /* RACSignal+Operations.h in Headers */ = {isa = PBXBuildFile; fileRef = D0D910CC15F915BD00AD2DDA /* RACSignal+Operations.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D0D910D015F915BD00AD2DDA /* RACSignal+Operations.m in Sources */ = {isa = PBXBuildFile; fileRef = D0D910CD15F915BD00AD2DDA /* RACSignal+Operations.m */; }; + D0D910D115F915BD00AD2DDA /* RACSignal+Operations.m in Sources */ = {isa = PBXBuildFile; fileRef = D0D910CD15F915BD00AD2DDA /* RACSignal+Operations.m */; }; + D0DFBCCE15DD6D40009DADB3 /* RACBacktrace.m in Sources */ = {isa = PBXBuildFile; fileRef = D0DFBCCD15DD6D40009DADB3 /* RACBacktrace.m */; }; + D0DFBCCF15DD6D40009DADB3 /* RACBacktrace.m in Sources */ = {isa = PBXBuildFile; fileRef = D0DFBCCD15DD6D40009DADB3 /* RACBacktrace.m */; }; + D0DFBCD015DD70CC009DADB3 /* ReactiveCocoa.framework in Copy Frameworks */ = {isa = PBXBuildFile; fileRef = 88037F8315056328001A5B19 /* ReactiveCocoa.framework */; }; + D0E9676B1641EF9C00FCFF06 /* NSArray+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = D0E967571641EF9C00FCFF06 /* NSArray+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D0E9676D1641EF9C00FCFF06 /* NSArray+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E967581641EF9C00FCFF06 /* NSArray+RACSequenceAdditions.m */; }; + D0E9676E1641EF9C00FCFF06 /* NSArray+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E967581641EF9C00FCFF06 /* NSArray+RACSequenceAdditions.m */; }; + D0E9676F1641EF9C00FCFF06 /* NSDictionary+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = D0E967591641EF9C00FCFF06 /* NSDictionary+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D0E967711641EF9C00FCFF06 /* NSDictionary+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E9675A1641EF9C00FCFF06 /* NSDictionary+RACSequenceAdditions.m */; }; + D0E967721641EF9C00FCFF06 /* NSDictionary+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E9675A1641EF9C00FCFF06 /* NSDictionary+RACSequenceAdditions.m */; }; + D0E967731641EF9C00FCFF06 /* NSOrderedSet+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = D0E9675B1641EF9C00FCFF06 /* NSOrderedSet+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D0E967751641EF9C00FCFF06 /* NSOrderedSet+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E9675C1641EF9C00FCFF06 /* NSOrderedSet+RACSequenceAdditions.m */; }; + D0E967761641EF9C00FCFF06 /* NSOrderedSet+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E9675C1641EF9C00FCFF06 /* NSOrderedSet+RACSequenceAdditions.m */; }; + D0E967771641EF9C00FCFF06 /* NSSet+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = D0E9675D1641EF9C00FCFF06 /* NSSet+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D0E967791641EF9C00FCFF06 /* NSSet+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E9675E1641EF9C00FCFF06 /* NSSet+RACSequenceAdditions.m */; }; + D0E9677A1641EF9C00FCFF06 /* NSSet+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E9675E1641EF9C00FCFF06 /* NSSet+RACSequenceAdditions.m */; }; + D0E9677B1641EF9C00FCFF06 /* NSString+RACSequenceAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = D0E9675F1641EF9C00FCFF06 /* NSString+RACSequenceAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D0E9677D1641EF9C00FCFF06 /* NSString+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E967601641EF9C00FCFF06 /* NSString+RACSequenceAdditions.m */; }; + D0E9677E1641EF9C00FCFF06 /* NSString+RACSequenceAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E967601641EF9C00FCFF06 /* NSString+RACSequenceAdditions.m */; }; + D0E967811641EF9C00FCFF06 /* RACArraySequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E967621641EF9C00FCFF06 /* RACArraySequence.m */; }; + D0E967821641EF9C00FCFF06 /* RACArraySequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E967621641EF9C00FCFF06 /* RACArraySequence.m */; }; + D0E967851641EF9C00FCFF06 /* RACDynamicSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E967641641EF9C00FCFF06 /* RACDynamicSequence.m */; }; + D0E967861641EF9C00FCFF06 /* RACDynamicSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E967641641EF9C00FCFF06 /* RACDynamicSequence.m */; }; + D0E967891641EF9C00FCFF06 /* RACEmptySequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E967661641EF9C00FCFF06 /* RACEmptySequence.m */; }; + D0E9678A1641EF9C00FCFF06 /* RACEmptySequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E967661641EF9C00FCFF06 /* RACEmptySequence.m */; }; + D0E9678B1641EF9C00FCFF06 /* RACSequence.h in Headers */ = {isa = PBXBuildFile; fileRef = D0E967671641EF9C00FCFF06 /* RACSequence.h */; settings = {ATTRIBUTES = (Public, ); }; }; + D0E9678D1641EF9C00FCFF06 /* RACSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E967681641EF9C00FCFF06 /* RACSequence.m */; }; + D0E9678E1641EF9C00FCFF06 /* RACSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E967681641EF9C00FCFF06 /* RACSequence.m */; }; + D0E967911641EF9C00FCFF06 /* RACStringSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E9676A1641EF9C00FCFF06 /* RACStringSequence.m */; }; + D0E967921641EF9C00FCFF06 /* RACStringSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0E9676A1641EF9C00FCFF06 /* RACStringSequence.m */; }; + D0EDE76716968AB10072A780 /* RACPropertySignalExamples.m in Sources */ = {isa = PBXBuildFile; fileRef = D0EDE76616968AB10072A780 /* RACPropertySignalExamples.m */; }; + D0EE284D164D906B006954A4 /* RACSignalSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0EE284A164D906B006954A4 /* RACSignalSequence.m */; }; + D0EE284E164D906B006954A4 /* RACSignalSequence.m in Sources */ = {isa = PBXBuildFile; fileRef = D0EE284A164D906B006954A4 /* RACSignalSequence.m */; }; + D0F117C8179F0A95006CE68F /* libReactiveCocoa-iOS.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 88F440AB153DAC820097B4C3 /* libReactiveCocoa-iOS.a */; }; + D0F117CC179F0B97006CE68F /* UITableViewCellRACSupportSpec.m in Sources */ = {isa = PBXBuildFile; fileRef = D0F117CB179F0B97006CE68F /* UITableViewCellRACSupportSpec.m */; }; + D40D7AAB18E22B5E0065BB70 /* libExpecta.a in Frameworks */ = {isa = PBXBuildFile; fileRef = D40D7AAA18E22B5E0065BB70 /* libExpecta.a */; }; + D40D7AAD18E22B7E0065BB70 /* libSpecta.a in Frameworks */ = {isa = PBXBuildFile; fileRef = D40D7AAC18E22B7E0065BB70 /* libSpecta.a */; }; + D40D7AAF18E22BE30065BB70 /* libExpecta-iOS.a in Frameworks */ = {isa = PBXBuildFile; fileRef = D40D7AAE18E22BE30065BB70 /* libExpecta-iOS.a */; }; + D40D7AB118E22BF60065BB70 /* libSpecta-iOS.a in Frameworks */ = {isa = PBXBuildFile; fileRef = D40D7AB018E22BF60065BB70 /* libSpecta-iOS.a */; }; + D40D7AB218E22EC60065BB70 /* libSpecta-iOS.a in Frameworks */ = {isa = PBXBuildFile; fileRef = D40D7AB018E22BF60065BB70 /* libSpecta-iOS.a */; }; + D40D7AB318E22EC90065BB70 /* libExpecta-iOS.a in Frameworks */ = {isa = PBXBuildFile; fileRef = D40D7AAE18E22BE30065BB70 /* libExpecta-iOS.a */; }; +/* End PBXBuildFile section */ + +/* Begin PBXContainerItemProxy section */ + 1860F435177C91B500C7B3C9 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 88CDF7B215000FCE00163A9F /* Project object */; + proxyType = 1; + remoteGlobalIDString = 1860F411177C91B500C7B3C9; + remoteInfo = "ReactiveCocoa-iOS-UIKitTestHost"; + }; + 88037FDA150564E9001A5B19 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 88CDF7B215000FCE00163A9F /* Project object */; + proxyType = 1; + remoteGlobalIDString = 88037F8215056328001A5B19; + remoteInfo = ReactiveCocoa; + }; + D0ED9DB517501806003859A6 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 88CDF7B215000FCE00163A9F /* Project object */; + proxyType = 1; + remoteGlobalIDString = 88F440AA153DAC820097B4C3; + remoteInfo = "ReactiveCocoa-iOS"; + }; + D0F117C2179F0A91006CE68F /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 88CDF7B215000FCE00163A9F /* Project object */; + proxyType = 1; + remoteGlobalIDString = 88F440AA153DAC820097B4C3; + remoteInfo = "ReactiveCocoa-iOS"; + }; +/* End PBXContainerItemProxy section */ + +/* Begin PBXCopyFilesBuildPhase section */ + 8820937F1501C94E00796685 /* Copy Frameworks */ = { + isa = PBXCopyFilesBuildPhase; + buildActionMask = 2147483647; + dstPath = ""; + dstSubfolderSpec = 10; + files = ( + D0DFBCD015DD70CC009DADB3 /* ReactiveCocoa.framework in Copy Frameworks */, + ); + name = "Copy Frameworks"; + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXCopyFilesBuildPhase section */ + +/* Begin PBXFileReference section */ + 1668027817FE75E900C724B4 /* UICollectionReusableView+RACSignalSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "UICollectionReusableView+RACSignalSupport.h"; sourceTree = "<group>"; }; + 1668027917FE75E900C724B4 /* UICollectionReusableView+RACSignalSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "UICollectionReusableView+RACSignalSupport.m"; sourceTree = "<group>"; }; + 1668028117FE774800C724B4 /* UICollectionReusableViewRACSupportSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = UICollectionReusableViewRACSupportSpec.m; sourceTree = "<group>"; }; + 1860F412177C91B500C7B3C9 /* ReactiveCocoa-iOS-UIKitTestHost.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = "ReactiveCocoa-iOS-UIKitTestHost.app"; sourceTree = BUILT_PRODUCTS_DIR; }; + 1860F413177C91B500C7B3C9 /* UIKit.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = UIKit.framework; path = Library/Frameworks/UIKit.framework; sourceTree = DEVELOPER_DIR; }; + 1860F415177C91B500C7B3C9 /* Foundation.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Foundation.framework; path = Library/Frameworks/Foundation.framework; sourceTree = DEVELOPER_DIR; }; + 1860F417177C91B500C7B3C9 /* CoreGraphics.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreGraphics.framework; path = Library/Frameworks/CoreGraphics.framework; sourceTree = DEVELOPER_DIR; }; + 1860F41B177C91B500C7B3C9 /* ReactiveCocoa-iOS-UIKitTestHost-Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = "ReactiveCocoa-iOS-UIKitTestHost-Info.plist"; sourceTree = "<group>"; }; + 1860F41D177C91B500C7B3C9 /* en */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = en; path = en.lproj/InfoPlist.strings; sourceTree = "<group>"; }; + 1860F41F177C91B500C7B3C9 /* main.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = main.m; sourceTree = "<group>"; }; + 1860F421177C91B500C7B3C9 /* ReactiveCocoa-iOS-UIKitTestHost-Prefix.pch */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "ReactiveCocoa-iOS-UIKitTestHost-Prefix.pch"; sourceTree = "<group>"; }; + 1860F422177C91B500C7B3C9 /* RACAppDelegate.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RACAppDelegate.h; sourceTree = "<group>"; }; + 1860F423177C91B500C7B3C9 /* RACAppDelegate.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = RACAppDelegate.m; sourceTree = "<group>"; }; + 1860F425177C91B500C7B3C9 /* Default.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = Default.png; sourceTree = "<group>"; }; + 1860F427177C91B500C7B3C9 /* Default@2x.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = "Default@2x.png"; sourceTree = "<group>"; }; + 1860F429177C91B500C7B3C9 /* Default-568h@2x.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = "Default-568h@2x.png"; sourceTree = "<group>"; }; + 1860F430177C91B500C7B3C9 /* ReactiveCocoa-iOS-UIKitTestHostTests.octest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = "ReactiveCocoa-iOS-UIKitTestHostTests.octest"; sourceTree = BUILT_PRODUCTS_DIR; }; + 1860F431177C91B500C7B3C9 /* SenTestingKit.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = SenTestingKit.framework; path = Library/Frameworks/SenTestingKit.framework; sourceTree = DEVELOPER_DIR; }; + 1860F43B177C91B500C7B3C9 /* en */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = en; path = en.lproj/InfoPlist.strings; sourceTree = "<group>"; }; + 1860F455177C96B200C7B3C9 /* ReactiveCocoa-iOS-UIKitTestHostTests-Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; name = "ReactiveCocoa-iOS-UIKitTestHostTests-Info.plist"; path = "ReactiveCocoaTests/UIKit/UIKitTests/ReactiveCocoa-iOS-UIKitTestHostTests-Info.plist"; sourceTree = SOURCE_ROOT; }; + 1860F457177C972E00C7B3C9 /* ReactiveCocoa-iOS-UIKitTest-Prefix.pch */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = "ReactiveCocoa-iOS-UIKitTest-Prefix.pch"; path = "ReactiveCocoaTests/UIKit/UIKitTests/ReactiveCocoa-iOS-UIKitTest-Prefix.pch"; sourceTree = SOURCE_ROOT; }; + 1E89337F171647A5009071B0 /* NSObjectRACPropertySubscribingExamples.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NSObjectRACPropertySubscribingExamples.h; sourceTree = "<group>"; }; + 1E893380171647A5009071B0 /* NSObjectRACPropertySubscribingExamples.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = NSObjectRACPropertySubscribingExamples.m; sourceTree = "<group>"; }; + 1EC06B15173CB04000365258 /* UIGestureRecognizer+RACSignalSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "UIGestureRecognizer+RACSignalSupport.h"; sourceTree = "<group>"; }; + 1EC06B16173CB04000365258 /* UIGestureRecognizer+RACSignalSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "UIGestureRecognizer+RACSignalSupport.m"; sourceTree = "<group>"; }; + 27A887C71703DB4F00040001 /* UIBarButtonItem+RACCommandSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "UIBarButtonItem+RACCommandSupport.h"; sourceTree = "<group>"; }; + 27A887C81703DB4F00040001 /* UIBarButtonItem+RACCommandSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "UIBarButtonItem+RACCommandSupport.m"; sourceTree = "<group>"; }; + 4925E805181BCC71000B2FEE /* NSControllerRACSupportSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = NSControllerRACSupportSpec.m; sourceTree = "<group>"; }; + 554D9E5B181064E200F21262 /* UIRefreshControl+RACCommandSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "UIRefreshControl+RACCommandSupport.h"; sourceTree = "<group>"; }; + 554D9E5C181064E200F21262 /* UIRefreshControl+RACCommandSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "UIRefreshControl+RACCommandSupport.m"; sourceTree = "<group>"; }; + 5564542318107275002BD2E4 /* UIRefreshControlRACSupportSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = UIRefreshControlRACSupportSpec.m; sourceTree = "<group>"; }; + 557A4B58177648C7008EF796 /* UIActionSheet+RACSignalSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "UIActionSheet+RACSignalSupport.h"; sourceTree = "<group>"; }; + 557A4B59177648C7008EF796 /* UIActionSheet+RACSignalSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "UIActionSheet+RACSignalSupport.m"; sourceTree = "<group>"; }; + 5EE9A7911760D61300EAF5A2 /* UIButton+RACCommandSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "UIButton+RACCommandSupport.h"; sourceTree = "<group>"; }; + 5EE9A7921760D61300EAF5A2 /* UIButton+RACCommandSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "UIButton+RACCommandSupport.m"; sourceTree = "<group>"; }; + 5EE9A79A1760D88500EAF5A2 /* UIButtonRACSupportSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = UIButtonRACSupportSpec.m; sourceTree = "<group>"; }; + 5F016DF217B10AA8002EEC69 /* UIControl+RACSignalSupportPrivate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "UIControl+RACSignalSupportPrivate.h"; sourceTree = "<group>"; }; + 5F016DF317B10AA8002EEC69 /* UIControl+RACSignalSupportPrivate.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "UIControl+RACSignalSupportPrivate.m"; sourceTree = "<group>"; }; + 5F2447AC167E87C50062180C /* RACKVOChannelSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACKVOChannelSpec.m; sourceTree = "<group>"; }; + 5F45A883168CFA3E00B58A2B /* RACKVOChannel.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACKVOChannel.h; sourceTree = "<group>"; }; + 5F45A884168CFA3E00B58A2B /* RACKVOChannel.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACKVOChannel.m; sourceTree = "<group>"; }; + 5F6FE8511692568A00A8D7A6 /* RACChannel.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACChannel.h; sourceTree = "<group>"; }; + 5F6FE8521692568A00A8D7A6 /* RACChannel.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACChannel.m; sourceTree = "<group>"; }; + 5F70B2AD17AB1829009AEDF9 /* UIDatePicker+RACSignalSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "UIDatePicker+RACSignalSupport.h"; sourceTree = "<group>"; }; + 5F70B2AE17AB1829009AEDF9 /* UIDatePicker+RACSignalSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "UIDatePicker+RACSignalSupport.m"; sourceTree = "<group>"; }; + 5F70B2B617AB1856009AEDF9 /* UISegmentedControl+RACSignalSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "UISegmentedControl+RACSignalSupport.h"; sourceTree = "<group>"; }; + 5F70B2B717AB1856009AEDF9 /* UISegmentedControl+RACSignalSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "UISegmentedControl+RACSignalSupport.m"; sourceTree = "<group>"; }; + 5F70B2B817AB1856009AEDF9 /* UISlider+RACSignalSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "UISlider+RACSignalSupport.h"; sourceTree = "<group>"; }; + 5F70B2B917AB1856009AEDF9 /* UISlider+RACSignalSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "UISlider+RACSignalSupport.m"; sourceTree = "<group>"; }; + 5F70B2BA17AB1857009AEDF9 /* UIStepper+RACSignalSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "UIStepper+RACSignalSupport.h"; sourceTree = "<group>"; }; + 5F70B2BB17AB1857009AEDF9 /* UIStepper+RACSignalSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "UIStepper+RACSignalSupport.m"; sourceTree = "<group>"; }; + 5F70B2BC17AB1857009AEDF9 /* UISwitch+RACSignalSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "UISwitch+RACSignalSupport.h"; sourceTree = "<group>"; }; + 5F70B2BD17AB1857009AEDF9 /* UISwitch+RACSignalSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "UISwitch+RACSignalSupport.m"; sourceTree = "<group>"; }; + 5F773DE8169B46670023069D /* NSEnumerator+RACSequenceAdditions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSEnumerator+RACSequenceAdditions.h"; sourceTree = "<group>"; }; + 5F773DE9169B46670023069D /* NSEnumerator+RACSequenceAdditions.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSEnumerator+RACSequenceAdditions.m"; sourceTree = "<group>"; }; + 5F773DEF169B48830023069D /* NSEnumeratorRACSequenceAdditionsSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = NSEnumeratorRACSequenceAdditionsSpec.m; sourceTree = "<group>"; }; + 5F7EFECC168FBC4B0037E500 /* RACChannelExamples.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACChannelExamples.h; sourceTree = "<group>"; }; + 5F7EFECD168FBC4B0037E500 /* RACChannelExamples.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACChannelExamples.m; sourceTree = "<group>"; }; + 5F7EFECE168FBC4B0037E500 /* RACChannelSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACChannelSpec.m; sourceTree = "<group>"; }; + 5F9743F51694A2460024EB82 /* RACEagerSequence.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACEagerSequence.h; sourceTree = "<group>"; }; + 5F9743F61694A2460024EB82 /* RACEagerSequence.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACEagerSequence.m; sourceTree = "<group>"; }; + 5FAF5223174D4C2000CAC810 /* ReactiveCocoaTests-iOS.octest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = "ReactiveCocoaTests-iOS.octest"; sourceTree = BUILT_PRODUCTS_DIR; }; + 5FAF5261174D4D8E00CAC810 /* UIBarButtonItemRACSupportSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = UIBarButtonItemRACSupportSpec.m; sourceTree = "<group>"; }; + 5FAF5288174E9CD200CAC810 /* CoreGraphics.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreGraphics.framework; path = Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS6.1.sdk/System/Library/Frameworks/CoreGraphics.framework; sourceTree = DEVELOPER_DIR; }; + 5FD7DC7B174F9EEB008710B4 /* UIKit.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = UIKit.framework; path = System/Library/Frameworks/UIKit.framework; sourceTree = SDKROOT; }; + 5FDC35011736F54600792E52 /* NSString+RACKeyPathUtilities.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSString+RACKeyPathUtilities.h"; sourceTree = "<group>"; }; + 5FDC35021736F54700792E52 /* NSString+RACKeyPathUtilities.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSString+RACKeyPathUtilities.m"; sourceTree = "<group>"; }; + 5FDC350E1736F81800792E52 /* NSStringRACKeyPathUtilitiesSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = NSStringRACKeyPathUtilitiesSpec.m; sourceTree = "<group>"; }; + 6E58405316F22D7500F588A6 /* NSObject+RACDeallocating.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSObject+RACDeallocating.h"; sourceTree = "<group>"; }; + 6E58405416F22D7500F588A6 /* NSObject+RACDeallocating.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSObject+RACDeallocating.m"; sourceTree = "<group>"; }; + 6E58405E16F3414200F588A6 /* NSObjectRACDeallocatingSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = NSObjectRACDeallocatingSpec.m; sourceTree = "<group>"; }; + 7479F6E3186177D200575CDB /* RACIndexSetSequence.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACIndexSetSequence.h; sourceTree = "<group>"; }; + 7479F6E4186177D200575CDB /* RACIndexSetSequence.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACIndexSetSequence.m; sourceTree = "<group>"; }; + 74F17316186024A900BC937C /* NSIndexSet+RACSequenceAdditions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSIndexSet+RACSequenceAdditions.h"; sourceTree = "<group>"; }; + 74F17317186024A900BC937C /* NSIndexSet+RACSequenceAdditions.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSIndexSet+RACSequenceAdditions.m"; sourceTree = "<group>"; }; + 8801E7501644BDE200A155FE /* NSObjectRACLiftingSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = NSObjectRACLiftingSpec.m; sourceTree = "<group>"; }; + 88037F8315056328001A5B19 /* ReactiveCocoa.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = ReactiveCocoa.framework; sourceTree = BUILT_PRODUCTS_DIR; }; + 88037F8C15056328001A5B19 /* ReactiveCocoa.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ReactiveCocoa.h; sourceTree = "<group>"; }; + 8803C010166732BA00C36839 /* RACSchedulerSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACSchedulerSpec.m; sourceTree = "<group>"; }; + 880B9174150B09190008488E /* RACSubject.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACSubject.h; sourceTree = "<group>"; }; + 880B9175150B09190008488E /* RACSubject.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACSubject.m; sourceTree = "<group>"; }; + 880D7A5816F7B351004A3361 /* NSObject+RACSelectorSignal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSObject+RACSelectorSignal.h"; sourceTree = "<group>"; }; + 880D7A5916F7B351004A3361 /* NSObject+RACSelectorSignal.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSObject+RACSelectorSignal.m"; sourceTree = "<group>"; }; + 880D7A6516F7BB1A004A3361 /* NSObjectRACSelectorSignalSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = NSObjectRACSelectorSignalSpec.m; sourceTree = "<group>"; }; + 880D7A6716F7BCC7004A3361 /* RACSubclassObject.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACSubclassObject.h; sourceTree = "<group>"; }; + 880D7A6816F7BCC7004A3361 /* RACSubclassObject.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACSubclassObject.m; sourceTree = "<group>"; }; + 881B37CA152260BF0079220B /* RACUnit.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACUnit.h; sourceTree = "<group>"; }; + 881B37CB152260BF0079220B /* RACUnit.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACUnit.m; sourceTree = "<group>"; }; + 881E86A01669304700667F7B /* RACCompoundDisposable.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACCompoundDisposable.h; sourceTree = "<group>"; }; + 881E86A11669304700667F7B /* RACCompoundDisposable.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACCompoundDisposable.m; sourceTree = "<group>"; }; + 881E86B91669350B00667F7B /* RACCompoundDisposableSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACCompoundDisposableSpec.m; sourceTree = "<group>"; }; + 881E87AA16695C5600667F7B /* RACQueueScheduler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACQueueScheduler.h; sourceTree = "<group>"; }; + 881E87AB16695C5600667F7B /* RACQueueScheduler.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACQueueScheduler.m; sourceTree = "<group>"; }; + 881E87B016695EDF00667F7B /* RACImmediateScheduler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACImmediateScheduler.h; sourceTree = "<group>"; }; + 881E87B116695EDF00667F7B /* RACImmediateScheduler.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACImmediateScheduler.m; sourceTree = "<group>"; }; + 881E87C21669635F00667F7B /* RACSubscriptionScheduler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACSubscriptionScheduler.h; sourceTree = "<group>"; }; + 881E87C31669636000667F7B /* RACSubscriptionScheduler.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACSubscriptionScheduler.m; sourceTree = "<group>"; }; + 8820937B1501C8A600796685 /* RACSignalSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACSignalSpec.m; sourceTree = "<group>"; }; + 882093E61501E6CB00796685 /* NSControl+RACCommandSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSControl+RACCommandSupport.h"; sourceTree = "<group>"; }; + 882093E71501E6CB00796685 /* NSControl+RACCommandSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSControl+RACCommandSupport.m"; sourceTree = "<group>"; }; + 882093E91501E6EE00796685 /* RACCommand.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; lineEnding = 0; path = RACCommand.h; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.objcpp; }; + 882093EA1501E6EE00796685 /* RACCommand.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; lineEnding = 0; path = RACCommand.m; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.objc; }; + 882CCA1D15F1564D00937D6E /* RACCommandSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACCommandSpec.m; sourceTree = "<group>"; }; + 882D071717614FA7009EDA69 /* RACTargetQueueScheduler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACTargetQueueScheduler.h; sourceTree = "<group>"; }; + 882D071817614FA7009EDA69 /* RACTargetQueueScheduler.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACTargetQueueScheduler.m; sourceTree = "<group>"; }; + 882D07201761521B009EDA69 /* RACQueueScheduler+Subclass.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "RACQueueScheduler+Subclass.h"; sourceTree = "<group>"; }; + 88302BFB1762A9E6003633BD /* RACTestExampleScheduler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACTestExampleScheduler.h; sourceTree = "<group>"; }; + 88302BFC1762A9E6003633BD /* RACTestExampleScheduler.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACTestExampleScheduler.m; sourceTree = "<group>"; }; + 88302C2D1762C180003633BD /* RACTargetQueueSchedulerSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACTargetQueueSchedulerSpec.m; sourceTree = "<group>"; }; + 8837EA1416A5A33300FC3CDF /* RACKVOTrampoline.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACKVOTrampoline.h; sourceTree = "<group>"; }; + 8837EA1516A5A33300FC3CDF /* RACKVOTrampoline.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACKVOTrampoline.m; sourceTree = "<group>"; }; + 883A84D81513964B006DB4C7 /* RACBehaviorSubject.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACBehaviorSubject.h; sourceTree = "<group>"; }; + 883A84D91513964B006DB4C7 /* RACBehaviorSubject.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; lineEnding = 0; path = RACBehaviorSubject.m; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.objc; }; + 883A84DD1513B5EC006DB4C7 /* RACDisposable.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACDisposable.h; sourceTree = "<group>"; }; + 883A84DE1513B5EC006DB4C7 /* RACDisposable.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACDisposable.m; sourceTree = "<group>"; }; + 88442A321608A9AD00636B49 /* RACTestObject.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACTestObject.h; sourceTree = "<group>"; }; + 88442A331608A9AD00636B49 /* RACTestObject.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACTestObject.m; sourceTree = "<group>"; }; + 88442C8716090C1500636B49 /* NSData+RACSupport.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "NSData+RACSupport.h"; sourceTree = "<group>"; }; + 88442C8816090C1500636B49 /* NSData+RACSupport.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = "NSData+RACSupport.m"; sourceTree = "<group>"; }; + 88442C8916090C1500636B49 /* NSFileHandle+RACSupport.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "NSFileHandle+RACSupport.h"; sourceTree = "<group>"; }; + 88442C8A16090C1500636B49 /* NSFileHandle+RACSupport.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = "NSFileHandle+RACSupport.m"; sourceTree = "<group>"; }; + 88442C8B16090C1500636B49 /* NSNotificationCenter+RACSupport.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "NSNotificationCenter+RACSupport.h"; sourceTree = "<group>"; }; + 88442C8C16090C1500636B49 /* NSNotificationCenter+RACSupport.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = "NSNotificationCenter+RACSupport.m"; sourceTree = "<group>"; }; + 88442C8D16090C1500636B49 /* NSString+RACSupport.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "NSString+RACSupport.h"; sourceTree = "<group>"; }; + 88442C8E16090C1500636B49 /* NSString+RACSupport.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = "NSString+RACSupport.m"; sourceTree = "<group>"; }; + 884476E2152367D100958F44 /* RACScopedDisposable.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACScopedDisposable.h; sourceTree = "<group>"; }; + 884476E3152367D100958F44 /* RACScopedDisposable.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACScopedDisposable.m; sourceTree = "<group>"; }; + 884848B515F658B800B11BD0 /* NSControlRACSupportSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = NSControlRACSupportSpec.m; sourceTree = "<group>"; }; + 8851A38A16161D500050D47F /* NSObjectRACPropertySubscribingSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = NSObjectRACPropertySubscribingSpec.m; sourceTree = "<group>"; }; + 8857BB81152A27A9009804CC /* NSObject+RACKVOWrapper.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSObject+RACKVOWrapper.h"; sourceTree = "<group>"; }; + 886678701518DCD800DE77EC /* NSObject+RACPropertySubscribing.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSObject+RACPropertySubscribing.m"; sourceTree = "<group>"; }; + 886CEACC163DE669007632D1 /* RACBlockTrampolineSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACBlockTrampolineSpec.m; sourceTree = "<group>"; }; + 886CEAE0163DE942007632D1 /* NSObject+RACLifting.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSObject+RACLifting.h"; sourceTree = "<group>"; }; + 886CEAE1163DE942007632D1 /* NSObject+RACLifting.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSObject+RACLifting.m"; sourceTree = "<group>"; }; + 886D98581667C86D00F22541 /* RACScheduler+Private.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "RACScheduler+Private.h"; sourceTree = "<group>"; }; + 886F70281551CF920045D68B /* RACGroupedSignal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; lineEnding = 0; path = RACGroupedSignal.h; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.objcpp; }; + 886F70291551CF920045D68B /* RACGroupedSignal.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACGroupedSignal.m; sourceTree = "<group>"; }; + 887ACDA5165878A7009190AD /* NSInvocation+RACTypeParsing.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSInvocation+RACTypeParsing.h"; sourceTree = "<group>"; }; + 887ACDA6165878A7009190AD /* NSInvocation+RACTypeParsing.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSInvocation+RACTypeParsing.m"; sourceTree = "<group>"; }; + 888439A11634E10D00DED0DB /* RACBlockTrampoline.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACBlockTrampoline.h; sourceTree = "<group>"; }; + 888439A21634E10D00DED0DB /* RACBlockTrampoline.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACBlockTrampoline.m; sourceTree = "<group>"; }; + 8884DD641756ACF600F6C379 /* RACSignalStartExamples.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACSignalStartExamples.m; sourceTree = "<group>"; }; + 8884DD6A1756AD3600F6C379 /* RACSignalStartExamples.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RACSignalStartExamples.h; sourceTree = "<group>"; }; + 88977C3D1512914A00A09EC5 /* RACSignal.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACSignal.m; sourceTree = "<group>"; }; + 889D0A7F15974B2A00F833E3 /* RACSubjectSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACSubjectSpec.m; sourceTree = "<group>"; }; + 88B76F8C153726B00053EAE2 /* RACTuple.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACTuple.h; sourceTree = "<group>"; }; + 88B76F8D153726B00053EAE2 /* RACTuple.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACTuple.m; sourceTree = "<group>"; }; + 88C5A0231692460A0045EF05 /* RACMulticastConnection.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACMulticastConnection.h; sourceTree = "<group>"; }; + 88C5A025169246140045EF05 /* RACMulticastConnection.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACMulticastConnection.m; sourceTree = "<group>"; }; + 88C5A02816924BFC0045EF05 /* RACMulticastConnectionSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACMulticastConnectionSpec.m; sourceTree = "<group>"; }; + 88CDF7BF15000FCE00163A9F /* Cocoa.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Cocoa.framework; path = System/Library/Frameworks/Cocoa.framework; sourceTree = SDKROOT; }; + 88CDF7C315000FCE00163A9F /* CoreData.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreData.framework; path = System/Library/Frameworks/CoreData.framework; sourceTree = SDKROOT; }; + 88CDF7C415000FCE00163A9F /* Foundation.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Foundation.framework; path = System/Library/Frameworks/Foundation.framework; sourceTree = SDKROOT; }; + 88CDF7C715000FCE00163A9F /* ReactiveCocoa-Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist; path = "ReactiveCocoa-Info.plist"; sourceTree = "<group>"; }; + 88CDF7C915000FCE00163A9F /* en */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = en; path = en.lproj/InfoPlist.strings; sourceTree = "<group>"; }; + 88CDF7CD15000FCE00163A9F /* ReactiveCocoa-Prefix.pch */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "ReactiveCocoa-Prefix.pch"; sourceTree = "<group>"; }; + 88CDF7DC15000FCF00163A9F /* ReactiveCocoaTests.octest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = ReactiveCocoaTests.octest; sourceTree = BUILT_PRODUCTS_DIR; }; + 88CDF7DD15000FCF00163A9F /* SenTestingKit.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = SenTestingKit.framework; path = Library/Frameworks/SenTestingKit.framework; sourceTree = DEVELOPER_DIR; }; + 88CDF7E415000FCF00163A9F /* ReactiveCocoaTests-Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist; path = "ReactiveCocoaTests-Info.plist"; sourceTree = "<group>"; }; + 88CDF7E615000FCF00163A9F /* en */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = en; path = en.lproj/InfoPlist.strings; sourceTree = "<group>"; }; + 88CDF7FA150019CA00163A9F /* RACSubscriber.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACSubscriber.h; sourceTree = "<group>"; }; + 88CDF7FB150019CA00163A9F /* RACSubscriber.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACSubscriber.m; sourceTree = "<group>"; }; + 88CDF80415001CA800163A9F /* RACSignal.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RACSignal.h; sourceTree = "<group>"; }; + 88CDF82915008BB900163A9F /* NSObject+RACKVOWrapper.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSObject+RACKVOWrapper.m"; sourceTree = "<group>"; }; + 88CDF82C15008C0500163A9F /* NSObject+RACPropertySubscribing.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; lineEnding = 0; path = "NSObject+RACPropertySubscribing.h"; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.objcpp; }; + 88D4AB3C1510F6C30011494F /* RACReplaySubject.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACReplaySubject.h; sourceTree = "<group>"; }; + 88D4AB3D1510F6C30011494F /* RACReplaySubject.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; lineEnding = 0; path = RACReplaySubject.m; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.objc; }; + 88DA309515071CBA00C19D0F /* RACValueTransformer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACValueTransformer.h; sourceTree = "<group>"; }; + 88DA309615071CBA00C19D0F /* RACValueTransformer.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACValueTransformer.m; sourceTree = "<group>"; }; + 88E2C6B2153C771C00C7493C /* RACScheduler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACScheduler.h; sourceTree = "<group>"; }; + 88E2C6B3153C771C00C7493C /* RACScheduler.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACScheduler.m; sourceTree = "<group>"; }; + 88F440AB153DAC820097B4C3 /* libReactiveCocoa-iOS.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = "libReactiveCocoa-iOS.a"; sourceTree = BUILT_PRODUCTS_DIR; }; + 88F440D1153DADEA0097B4C3 /* NSObject+RACAppKitBindings.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSObject+RACAppKitBindings.h"; sourceTree = "<group>"; }; + 88F440D2153DADEA0097B4C3 /* NSObject+RACAppKitBindings.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSObject+RACAppKitBindings.m"; sourceTree = "<group>"; }; + 88F4425F153DC0450097B4C3 /* UIControl+RACSignalSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "UIControl+RACSignalSupport.h"; sourceTree = "<group>"; }; + 88F44260153DC0450097B4C3 /* UIControl+RACSignalSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "UIControl+RACSignalSupport.m"; sourceTree = "<group>"; }; + 88F44264153DCAC50097B4C3 /* UITextField+RACSignalSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "UITextField+RACSignalSupport.h"; sourceTree = "<group>"; }; + 88F44265153DCAC50097B4C3 /* UITextField+RACSignalSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "UITextField+RACSignalSupport.m"; sourceTree = "<group>"; }; + 88F5870515361C170084BD32 /* RACMulticastConnection+Private.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; lineEnding = 0; path = "RACMulticastConnection+Private.h"; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.objcpp; }; + 88FC735316114F9C00F8A774 /* RACSubscriptingAssignmentTrampoline.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACSubscriptingAssignmentTrampoline.h; sourceTree = "<group>"; }; + 88FC735416114F9C00F8A774 /* RACSubscriptingAssignmentTrampoline.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACSubscriptingAssignmentTrampoline.m; sourceTree = "<group>"; }; + 88FC735A16114FFB00F8A774 /* RACSubscriptingAssignmentTrampolineSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACSubscriptingAssignmentTrampolineSpec.m; sourceTree = "<group>"; }; + A1FCC27215666AA3008C9686 /* UITextView+RACSignalSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "UITextView+RACSignalSupport.h"; sourceTree = "<group>"; }; + A1FCC27315666AA3008C9686 /* UITextView+RACSignalSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "UITextView+RACSignalSupport.m"; sourceTree = "<group>"; }; + A1FCC370156754A7008C9686 /* RACObjCRuntime.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACObjCRuntime.h; sourceTree = "<group>"; }; + A1FCC371156754A7008C9686 /* RACObjCRuntime.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACObjCRuntime.m; sourceTree = "<group>"; }; + A1FCC3761567DED0008C9686 /* RACDelegateProxy.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACDelegateProxy.h; sourceTree = "<group>"; }; + A1FCC3771567DED0008C9686 /* RACDelegateProxy.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACDelegateProxy.m; sourceTree = "<group>"; }; + AC65FD51176DECB1005ED22B /* UIAlertViewRACSupportSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = UIAlertViewRACSupportSpec.m; sourceTree = "<group>"; }; + ACB0EAF11797DDD400942FFC /* UIAlertView+RACSignalSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "UIAlertView+RACSignalSupport.m"; sourceTree = "<group>"; }; + ACB0EAF21797DDD400942FFC /* UIAlertView+RACSignalSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "UIAlertView+RACSignalSupport.h"; sourceTree = "<group>"; }; + BE527E9118636F7F006349E8 /* NSUserDefaults+RACSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSUserDefaults+RACSupport.h"; sourceTree = "<group>"; }; + BE527E9218636F7F006349E8 /* NSUserDefaults+RACSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSUserDefaults+RACSupport.m"; sourceTree = "<group>"; }; + BE527E9E1863705B006349E8 /* NSUserDefaultsRACSupportSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = NSUserDefaultsRACSupportSpec.m; sourceTree = "<group>"; }; + CD11C6F118714CD0007C7CFD /* UITableViewHeaderFooterView+RACSignalSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "UITableViewHeaderFooterView+RACSignalSupport.h"; sourceTree = "<group>"; }; + CD11C6F218714CD0007C7CFD /* UITableViewHeaderFooterView+RACSignalSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "UITableViewHeaderFooterView+RACSignalSupport.m"; sourceTree = "<group>"; }; + CD11C6F918714DC1007C7CFD /* UITableViewHeaderFooterViewRACSupportSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = UITableViewHeaderFooterViewRACSupportSpec.m; sourceTree = "<group>"; }; + CD11C6FC18714DFB007C7CFD /* RACTestTableViewController.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACTestTableViewController.h; sourceTree = "<group>"; }; + CD11C6FD18714DFB007C7CFD /* RACTestTableViewController.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACTestTableViewController.m; sourceTree = "<group>"; }; + D004BC9B177E1A2B00A5B8C5 /* UIActionSheetRACSupportSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = UIActionSheetRACSupportSpec.m; path = ReactiveCocoaTests/UIActionSheetRACSupportSpec.m; sourceTree = SOURCE_ROOT; }; + D00930771788AB7B00EE7E8B /* RACTestScheduler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACTestScheduler.h; sourceTree = "<group>"; }; + D00930781788AB7B00EE7E8B /* RACTestScheduler.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACTestScheduler.m; sourceTree = "<group>"; }; + D011F9CF1782AFD400EE7E38 /* NSObjectRACAppKitBindingsSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = NSObjectRACAppKitBindingsSpec.m; sourceTree = "<group>"; }; + D013A3D41807B5ED0072B6CE /* RACErrorSignal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACErrorSignal.h; sourceTree = "<group>"; }; + D013A3D51807B5ED0072B6CE /* RACErrorSignal.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACErrorSignal.m; sourceTree = "<group>"; }; + D013A3DC1807B7450072B6CE /* RACEmptySignal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACEmptySignal.h; sourceTree = "<group>"; }; + D013A3DD1807B7450072B6CE /* RACEmptySignal.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACEmptySignal.m; sourceTree = "<group>"; }; + D013A3E41807B7C30072B6CE /* RACReturnSignal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACReturnSignal.h; sourceTree = "<group>"; }; + D013A3E51807B7C30072B6CE /* RACReturnSignal.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACReturnSignal.m; sourceTree = "<group>"; }; + D013A3ED1807B9690072B6CE /* RACDynamicSignal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACDynamicSignal.h; sourceTree = "<group>"; }; + D013A3EE1807B9690072B6CE /* RACDynamicSignal.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACDynamicSignal.m; sourceTree = "<group>"; }; + D01DB9AE166819B9003E8F7F /* ReactiveCocoaTests-Prefix.pch */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "ReactiveCocoaTests-Prefix.pch"; sourceTree = "<group>"; }; + D020F3DA17F6A3E40092BED2 /* RACCompoundDisposableProvider.d */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.dtrace; path = RACCompoundDisposableProvider.d; sourceTree = "<group>"; }; + D02221611678910900DBD031 /* RACTupleSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACTupleSpec.m; sourceTree = "<group>"; }; + D02538A115E2D7FB005BACB8 /* RACBacktrace.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RACBacktrace.h; sourceTree = "<group>"; }; + D028DB72179E53CB00D1042F /* RACSerialDisposable.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACSerialDisposable.h; sourceTree = "<group>"; }; + D028DB73179E53CB00D1042F /* RACSerialDisposable.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACSerialDisposable.m; sourceTree = "<group>"; }; + D028DB7C179E591E00D1042F /* RACSerialDisposableSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACSerialDisposableSpec.m; sourceTree = "<group>"; }; + D028DB85179E616700D1042F /* UITableViewCell+RACSignalSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "UITableViewCell+RACSignalSupport.h"; sourceTree = "<group>"; }; + D028DB86179E616700D1042F /* UITableViewCell+RACSignalSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "UITableViewCell+RACSignalSupport.m"; sourceTree = "<group>"; }; + D0307EDB1731AAE100D83211 /* RACTupleSequence.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACTupleSequence.h; sourceTree = "<group>"; }; + D0307EDC1731AAE100D83211 /* RACTupleSequence.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACTupleSequence.m; sourceTree = "<group>"; }; + D03525D317E2EBC90099CBAB /* RACSignalProvider.d */ = {isa = PBXFileReference; explicitFileType = sourcecode.dtrace; fileEncoding = 4; path = RACSignalProvider.d; sourceTree = "<group>"; }; + D041376815D2281C004BBF80 /* RACKVOWrapperSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACKVOWrapperSpec.m; sourceTree = "<group>"; }; + D0487AB1164314430085D890 /* RACStreamExamples.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACStreamExamples.h; sourceTree = "<group>"; }; + D0487AB2164314430085D890 /* RACStreamExamples.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACStreamExamples.m; sourceTree = "<group>"; }; + D05AD39417F2D56F0080895B /* libReactiveCocoa-Mac.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = "libReactiveCocoa-Mac.a"; sourceTree = BUILT_PRODUCTS_DIR; }; + D05AD39517F2D5700080895B /* Cocoa.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Cocoa.framework; path = System/Library/Frameworks/Cocoa.framework; sourceTree = SDKROOT; }; + D05AD39717F2D5700080895B /* AppKit.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = AppKit.framework; path = System/Library/Frameworks/AppKit.framework; sourceTree = SDKROOT; }; + D05AD3A317F2D5700080895B /* XCTest.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = XCTest.framework; path = Library/Frameworks/XCTest.framework; sourceTree = DEVELOPER_DIR; }; + D05F9D3317984EC000FD7982 /* EXTRuntimeExtensions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = EXTRuntimeExtensions.h; sourceTree = "<group>"; }; + D05F9D3417984EC000FD7982 /* EXTRuntimeExtensions.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = EXTRuntimeExtensions.m; sourceTree = "<group>"; }; + D066C795176D262500C242D2 /* UIControlRACSupportSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = UIControlRACSupportSpec.m; sourceTree = "<group>"; }; + D066C79B176D263D00C242D2 /* RACTestUIButton.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACTestUIButton.h; sourceTree = "<group>"; }; + D066C79C176D263D00C242D2 /* RACTestUIButton.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACTestUIButton.m; sourceTree = "<group>"; }; + D0700F4B1672994D00D7CD30 /* NSNotificationCenterRACSupportSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = NSNotificationCenterRACSupportSpec.m; sourceTree = "<group>"; }; + D07200241788C57200987F70 /* RACTestSchedulerSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACTestSchedulerSpec.m; sourceTree = "<group>"; }; + D075A72817BCB7E100C24FB7 /* RACControlCommandExamples.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACControlCommandExamples.h; sourceTree = "<group>"; }; + D075A72917BCB7E100C24FB7 /* RACControlCommandExamples.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACControlCommandExamples.m; sourceTree = "<group>"; }; + D077A16B169B740200057BB1 /* RACEvent.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACEvent.h; sourceTree = "<group>"; }; + D077A16C169B740200057BB1 /* RACEvent.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACEvent.m; sourceTree = "<group>"; }; + D077A171169B79A900057BB1 /* RACEventSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACEventSpec.m; sourceTree = "<group>"; }; + D07CD7141731BA3900DE2394 /* RACUnarySequence.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACUnarySequence.h; sourceTree = "<group>"; }; + D07CD7151731BA3900DE2394 /* RACUnarySequence.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACUnarySequence.m; sourceTree = "<group>"; }; + D07E9489179DD21E00A6F609 /* RACStream+Private.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "RACStream+Private.h"; sourceTree = "<group>"; }; + D0870C6E16884A0600D0E11D /* RACBacktraceSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACBacktraceSpec.m; sourceTree = "<group>"; }; + D090767D17FBEADE00EB087A /* NSURLConnection+RACSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSURLConnection+RACSupport.h"; sourceTree = "<group>"; }; + D090767E17FBEADE00EB087A /* NSURLConnection+RACSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSURLConnection+RACSupport.m"; sourceTree = "<group>"; }; + D090768917FBECBF00EB087A /* NSURLConnectionRACSupportSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = NSURLConnectionRACSupportSpec.m; sourceTree = "<group>"; }; + D090768C17FBED2E00EB087A /* test-data.json */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.json; path = "test-data.json"; sourceTree = "<group>"; }; + D094E44517775AF200906BF7 /* EXTKeyPathCoding.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = EXTKeyPathCoding.h; sourceTree = "<group>"; }; + D094E44617775AF200906BF7 /* EXTScope.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = EXTScope.h; sourceTree = "<group>"; }; + D094E44817775AF200906BF7 /* metamacros.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = metamacros.h; sourceTree = "<group>"; }; + D094E45317775B1000906BF7 /* Common.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = Common.xcconfig; sourceTree = "<group>"; }; + D094E45517775B1000906BF7 /* Debug.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = Debug.xcconfig; sourceTree = "<group>"; }; + D094E45617775B1000906BF7 /* Profile.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = Profile.xcconfig; sourceTree = "<group>"; }; + D094E45717775B1000906BF7 /* Release.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = Release.xcconfig; sourceTree = "<group>"; }; + D094E45817775B1000906BF7 /* Test.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = Test.xcconfig; sourceTree = "<group>"; }; + D094E45A17775B1000906BF7 /* Application.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = Application.xcconfig; sourceTree = "<group>"; }; + D094E45B17775B1000906BF7 /* StaticLibrary.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = StaticLibrary.xcconfig; sourceTree = "<group>"; }; + D094E45D17775B1000906BF7 /* iOS-Application.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = "iOS-Application.xcconfig"; sourceTree = "<group>"; }; + D094E45E17775B1000906BF7 /* iOS-Base.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = "iOS-Base.xcconfig"; sourceTree = "<group>"; }; + D094E45F17775B1000906BF7 /* iOS-StaticLibrary.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = "iOS-StaticLibrary.xcconfig"; sourceTree = "<group>"; }; + D094E46117775B1000906BF7 /* Mac-Application.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = "Mac-Application.xcconfig"; sourceTree = "<group>"; }; + D094E46217775B1000906BF7 /* Mac-Base.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = "Mac-Base.xcconfig"; sourceTree = "<group>"; }; + D094E46317775B1000906BF7 /* Mac-DynamicLibrary.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = "Mac-DynamicLibrary.xcconfig"; sourceTree = "<group>"; }; + D094E46417775B1000906BF7 /* Mac-Framework.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = "Mac-Framework.xcconfig"; sourceTree = "<group>"; }; + D094E46517775B1000906BF7 /* Mac-StaticLibrary.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = "Mac-StaticLibrary.xcconfig"; sourceTree = "<group>"; }; + D094E46617775B1000906BF7 /* README.md */ = {isa = PBXFileReference; lastKnownFileType = text; path = README.md; sourceTree = "<group>"; }; + D0A0B01316EAA3D100C47593 /* NSText+RACSignalSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSText+RACSignalSupport.h"; sourceTree = "<group>"; }; + D0A0B01416EAA3D100C47593 /* NSText+RACSignalSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSText+RACSignalSupport.m"; sourceTree = "<group>"; }; + D0A0B01716EAA5CC00C47593 /* NSTextRACSupportSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = NSTextRACSupportSpec.m; sourceTree = "<group>"; }; + D0A0B03916EAA9AC00C47593 /* NSControl+RACTextSignalSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSControl+RACTextSignalSupport.h"; sourceTree = "<group>"; }; + D0A0B03A16EAA9AC00C47593 /* NSControl+RACTextSignalSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSControl+RACTextSignalSupport.m"; sourceTree = "<group>"; }; + D0A0E225176A84DA007273ED /* RACDisposableSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACDisposableSpec.m; sourceTree = "<group>"; }; + D0A0E22C176A8CD6007273ED /* RACPassthroughSubscriber.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACPassthroughSubscriber.h; sourceTree = "<group>"; }; + D0A0E22D176A8CD6007273ED /* RACPassthroughSubscriber.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACPassthroughSubscriber.m; sourceTree = "<group>"; }; + D0C55CD817758A73008CDDCA /* UITextFieldRACSupportSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = UITextFieldRACSupportSpec.m; sourceTree = "<group>"; }; + D0C55CDE17758C2A008CDDCA /* UITextViewRACSupportSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = UITextViewRACSupportSpec.m; sourceTree = "<group>"; }; + D0C55CE117759559008CDDCA /* RACDelegateProxySpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACDelegateProxySpec.m; sourceTree = "<group>"; }; + D0C70EC416659333005AAD03 /* RACSubscriberExamples.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACSubscriberExamples.h; sourceTree = "<group>"; }; + D0C70EC516659333005AAD03 /* RACSubscriberExamples.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACSubscriberExamples.m; sourceTree = "<group>"; }; + D0C70EC7166595AD005AAD03 /* RACSubscriberSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACSubscriberSpec.m; sourceTree = "<group>"; }; + D0C70F8F164337A2007027B4 /* RACSequenceAdditionsSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACSequenceAdditionsSpec.m; sourceTree = "<group>"; }; + D0C70F91164337E3007027B4 /* RACSequenceExamples.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACSequenceExamples.h; sourceTree = "<group>"; }; + D0C70F92164337E3007027B4 /* RACSequenceExamples.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACSequenceExamples.m; sourceTree = "<group>"; }; + D0D243B51741FA0E004359C6 /* NSObject+RACDescription.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "NSObject+RACDescription.h"; sourceTree = "<group>"; }; + D0D243B61741FA0E004359C6 /* NSObject+RACDescription.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = "NSObject+RACDescription.m"; sourceTree = "<group>"; }; + D0D486FF1642550100DD7605 /* RACStream.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACStream.h; sourceTree = "<group>"; }; + D0D487001642550100DD7605 /* RACStream.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACStream.m; sourceTree = "<group>"; }; + D0D487051642651400DD7605 /* RACSequenceSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACSequenceSpec.m; sourceTree = "<group>"; }; + D0D910CC15F915BD00AD2DDA /* RACSignal+Operations.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "RACSignal+Operations.h"; sourceTree = "<group>"; }; + D0D910CD15F915BD00AD2DDA /* RACSignal+Operations.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "RACSignal+Operations.m"; sourceTree = "<group>"; }; + D0DFBCCD15DD6D40009DADB3 /* RACBacktrace.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACBacktrace.m; sourceTree = "<group>"; }; + D0E967571641EF9C00FCFF06 /* NSArray+RACSequenceAdditions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSArray+RACSequenceAdditions.h"; sourceTree = "<group>"; }; + D0E967581641EF9C00FCFF06 /* NSArray+RACSequenceAdditions.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSArray+RACSequenceAdditions.m"; sourceTree = "<group>"; }; + D0E967591641EF9C00FCFF06 /* NSDictionary+RACSequenceAdditions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSDictionary+RACSequenceAdditions.h"; sourceTree = "<group>"; }; + D0E9675A1641EF9C00FCFF06 /* NSDictionary+RACSequenceAdditions.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSDictionary+RACSequenceAdditions.m"; sourceTree = "<group>"; }; + D0E9675B1641EF9C00FCFF06 /* NSOrderedSet+RACSequenceAdditions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSOrderedSet+RACSequenceAdditions.h"; sourceTree = "<group>"; }; + D0E9675C1641EF9C00FCFF06 /* NSOrderedSet+RACSequenceAdditions.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSOrderedSet+RACSequenceAdditions.m"; sourceTree = "<group>"; }; + D0E9675D1641EF9C00FCFF06 /* NSSet+RACSequenceAdditions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSSet+RACSequenceAdditions.h"; sourceTree = "<group>"; }; + D0E9675E1641EF9C00FCFF06 /* NSSet+RACSequenceAdditions.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSSet+RACSequenceAdditions.m"; sourceTree = "<group>"; }; + D0E9675F1641EF9C00FCFF06 /* NSString+RACSequenceAdditions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSString+RACSequenceAdditions.h"; sourceTree = "<group>"; }; + D0E967601641EF9C00FCFF06 /* NSString+RACSequenceAdditions.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSString+RACSequenceAdditions.m"; sourceTree = "<group>"; }; + D0E967611641EF9C00FCFF06 /* RACArraySequence.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACArraySequence.h; sourceTree = "<group>"; }; + D0E967621641EF9C00FCFF06 /* RACArraySequence.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACArraySequence.m; sourceTree = "<group>"; }; + D0E967631641EF9C00FCFF06 /* RACDynamicSequence.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACDynamicSequence.h; sourceTree = "<group>"; }; + D0E967641641EF9C00FCFF06 /* RACDynamicSequence.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACDynamicSequence.m; sourceTree = "<group>"; }; + D0E967651641EF9C00FCFF06 /* RACEmptySequence.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACEmptySequence.h; sourceTree = "<group>"; }; + D0E967661641EF9C00FCFF06 /* RACEmptySequence.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACEmptySequence.m; sourceTree = "<group>"; }; + D0E967671641EF9C00FCFF06 /* RACSequence.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; lineEnding = 0; path = RACSequence.h; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.objcpp; }; + D0E967681641EF9C00FCFF06 /* RACSequence.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACSequence.m; sourceTree = "<group>"; }; + D0E967691641EF9C00FCFF06 /* RACStringSequence.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACStringSequence.h; sourceTree = "<group>"; }; + D0E9676A1641EF9C00FCFF06 /* RACStringSequence.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACStringSequence.m; sourceTree = "<group>"; }; + D0EDE76516968AB10072A780 /* RACPropertySignalExamples.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACPropertySignalExamples.h; sourceTree = "<group>"; }; + D0EDE76616968AB10072A780 /* RACPropertySignalExamples.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACPropertySignalExamples.m; sourceTree = "<group>"; }; + D0EE2849164D906B006954A4 /* RACSignalSequence.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RACSignalSequence.h; sourceTree = "<group>"; }; + D0EE284A164D906B006954A4 /* RACSignalSequence.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACSignalSequence.m; sourceTree = "<group>"; }; + D0F117CB179F0B97006CE68F /* UITableViewCellRACSupportSpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = UITableViewCellRACSupportSpec.m; sourceTree = "<group>"; }; + D0FAEC02176AEEE600D3C1A7 /* RACSubscriber+Private.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "RACSubscriber+Private.h"; sourceTree = "<group>"; }; + D40D7AAA18E22B5E0065BB70 /* libExpecta.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libExpecta.a; sourceTree = BUILT_PRODUCTS_DIR; }; + D40D7AAC18E22B7E0065BB70 /* libSpecta.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libSpecta.a; sourceTree = BUILT_PRODUCTS_DIR; }; + D40D7AAE18E22BE30065BB70 /* libExpecta-iOS.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; name = "libExpecta-iOS.a"; path = "../external/expecta/build/Debug-iphoneos/libExpecta-iOS.a"; sourceTree = "<group>"; }; + D40D7AB018E22BF60065BB70 /* libSpecta-iOS.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; name = "libSpecta-iOS.a"; path = "../external/specta/build/Debug-iphoneos/libSpecta-iOS.a"; sourceTree = "<group>"; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + 1860F40F177C91B500C7B3C9 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + D0F117C8179F0A95006CE68F /* libReactiveCocoa-iOS.a in Frameworks */, + 1860F414177C91B500C7B3C9 /* UIKit.framework in Frameworks */, + 1860F416177C91B500C7B3C9 /* Foundation.framework in Frameworks */, + 1860F418177C91B500C7B3C9 /* CoreGraphics.framework in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 1860F42C177C91B500C7B3C9 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + 1860F432177C91B500C7B3C9 /* SenTestingKit.framework in Frameworks */, + 1860F433177C91B500C7B3C9 /* UIKit.framework in Frameworks */, + 1860F434177C91B500C7B3C9 /* Foundation.framework in Frameworks */, + D40D7AB218E22EC60065BB70 /* libSpecta-iOS.a in Frameworks */, + D40D7AB318E22EC90065BB70 /* libExpecta-iOS.a in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 5FAF521F174D4C2000CAC810 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + 5FD7DC7C174F9EEB008710B4 /* UIKit.framework in Frameworks */, + 5FAF5289174E9CD300CAC810 /* CoreGraphics.framework in Frameworks */, + 5FAF5265174D500D00CAC810 /* libReactiveCocoa-iOS.a in Frameworks */, + 5FAF5224174D4C2000CAC810 /* SenTestingKit.framework in Frameworks */, + D40D7AAF18E22BE30065BB70 /* libExpecta-iOS.a in Frameworks */, + D40D7AB118E22BF60065BB70 /* libSpecta-iOS.a in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 88037F7F15056328001A5B19 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + 88037F8415056328001A5B19 /* Cocoa.framework in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 88CDF7D815000FCF00163A9F /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + 88037FD9150564D9001A5B19 /* ReactiveCocoa.framework in Frameworks */, + 88CDF7DE15000FCF00163A9F /* SenTestingKit.framework in Frameworks */, + 88CDF7DF15000FCF00163A9F /* Cocoa.framework in Frameworks */, + D40D7AAB18E22B5E0065BB70 /* libExpecta.a in Frameworks */, + D40D7AAD18E22B7E0065BB70 /* libSpecta.a in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 88F440A8153DAC820097B4C3 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + 5FD7DC7A174F9EAF008710B4 /* Foundation.framework in Frameworks */, + 5FD7DC7F174F9FC8008710B4 /* UIKit.framework in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + D05AD39117F2D56F0080895B /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + D05AD39617F2D5700080895B /* Cocoa.framework in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 1860F419177C91B500C7B3C9 /* UIKitTestHost */ = { + isa = PBXGroup; + children = ( + 1860F422177C91B500C7B3C9 /* RACAppDelegate.h */, + 1860F423177C91B500C7B3C9 /* RACAppDelegate.m */, + CD11C6FC18714DFB007C7CFD /* RACTestTableViewController.h */, + CD11C6FD18714DFB007C7CFD /* RACTestTableViewController.m */, + 1860F41A177C91B500C7B3C9 /* Supporting Files */, + ); + path = UIKitTestHost; + sourceTree = "<group>"; + }; + 1860F41A177C91B500C7B3C9 /* Supporting Files */ = { + isa = PBXGroup; + children = ( + 1860F41B177C91B500C7B3C9 /* ReactiveCocoa-iOS-UIKitTestHost-Info.plist */, + 1860F41C177C91B500C7B3C9 /* InfoPlist.strings */, + 1860F41F177C91B500C7B3C9 /* main.m */, + 1860F421177C91B500C7B3C9 /* ReactiveCocoa-iOS-UIKitTestHost-Prefix.pch */, + 1860F425177C91B500C7B3C9 /* Default.png */, + 1860F427177C91B500C7B3C9 /* Default@2x.png */, + 1860F429177C91B500C7B3C9 /* Default-568h@2x.png */, + ); + name = "Supporting Files"; + sourceTree = "<group>"; + }; + 1860F437177C91B500C7B3C9 /* UIKitTests */ = { + isa = PBXGroup; + children = ( + D004BC9B177E1A2B00A5B8C5 /* UIActionSheetRACSupportSpec.m */, + 1668028117FE774800C724B4 /* UICollectionReusableViewRACSupportSpec.m */, + D0F117CB179F0B97006CE68F /* UITableViewCellRACSupportSpec.m */, + CD11C6F918714DC1007C7CFD /* UITableViewHeaderFooterViewRACSupportSpec.m */, + D0C55CD817758A73008CDDCA /* UITextFieldRACSupportSpec.m */, + D0C55CDE17758C2A008CDDCA /* UITextViewRACSupportSpec.m */, + ); + path = UIKitTests; + sourceTree = "<group>"; + }; + 1860F438177C91B500C7B3C9 /* Supporting Files */ = { + isa = PBXGroup; + children = ( + 1860F455177C96B200C7B3C9 /* ReactiveCocoa-iOS-UIKitTestHostTests-Info.plist */, + 1860F457177C972E00C7B3C9 /* ReactiveCocoa-iOS-UIKitTest-Prefix.pch */, + 1860F43A177C91B500C7B3C9 /* InfoPlist.strings */, + ); + name = "Supporting Files"; + path = UIKitTestHost; + sourceTree = "<group>"; + }; + 1860F44E177C949A00C7B3C9 /* UIKit */ = { + isa = PBXGroup; + children = ( + 1860F437177C91B500C7B3C9 /* UIKitTests */, + 1860F419177C91B500C7B3C9 /* UIKitTestHost */, + 1860F438177C91B500C7B3C9 /* Supporting Files */, + ); + path = UIKit; + sourceTree = "<group>"; + }; + 5FAF525F174D4D6100CAC810 /* OS X */ = { + isa = PBXGroup; + children = ( + 884848B515F658B800B11BD0 /* NSControlRACSupportSpec.m */, + D011F9CF1782AFD400EE7E38 /* NSObjectRACAppKitBindingsSpec.m */, + D0A0B01716EAA5CC00C47593 /* NSTextRACSupportSpec.m */, + 4925E805181BCC71000B2FEE /* NSControllerRACSupportSpec.m */, + ); + name = "OS X"; + sourceTree = "<group>"; + }; + 5FAF5260174D4D7100CAC810 /* iOS */ = { + isa = PBXGroup; + children = ( + 1860F44E177C949A00C7B3C9 /* UIKit */, + D0C55CE117759559008CDDCA /* RACDelegateProxySpec.m */, + D066C79B176D263D00C242D2 /* RACTestUIButton.h */, + D066C79C176D263D00C242D2 /* RACTestUIButton.m */, + AC65FD51176DECB1005ED22B /* UIAlertViewRACSupportSpec.m */, + 5FAF5261174D4D8E00CAC810 /* UIBarButtonItemRACSupportSpec.m */, + 5EE9A79A1760D88500EAF5A2 /* UIButtonRACSupportSpec.m */, + D066C795176D262500C242D2 /* UIControlRACSupportSpec.m */, + 5564542318107275002BD2E4 /* UIRefreshControlRACSupportSpec.m */, + ); + name = iOS; + sourceTree = "<group>"; + }; + 88977C5915129AB200A09EC5 /* KVO + Bindings */ = { + isa = PBXGroup; + children = ( + 5F6FE8511692568A00A8D7A6 /* RACChannel.h */, + 5F6FE8521692568A00A8D7A6 /* RACChannel.m */, + 5F45A883168CFA3E00B58A2B /* RACKVOChannel.h */, + 5F45A884168CFA3E00B58A2B /* RACKVOChannel.m */, + 8857BB81152A27A9009804CC /* NSObject+RACKVOWrapper.h */, + 88CDF82915008BB900163A9F /* NSObject+RACKVOWrapper.m */, + 5FDC35011736F54600792E52 /* NSString+RACKeyPathUtilities.h */, + 5FDC35021736F54700792E52 /* NSString+RACKeyPathUtilities.m */, + 8837EA1416A5A33300FC3CDF /* RACKVOTrampoline.h */, + 8837EA1516A5A33300FC3CDF /* RACKVOTrampoline.m */, + 88CDF82C15008C0500163A9F /* NSObject+RACPropertySubscribing.h */, + 886678701518DCD800DE77EC /* NSObject+RACPropertySubscribing.m */, + 88DA309515071CBA00C19D0F /* RACValueTransformer.h */, + 88DA309615071CBA00C19D0F /* RACValueTransformer.m */, + ); + name = "KVO + Bindings"; + sourceTree = "<group>"; + }; + 889C04BB155DA37600F19F0C /* Foundation Support */ = { + isa = PBXGroup; + children = ( + D0E967571641EF9C00FCFF06 /* NSArray+RACSequenceAdditions.h */, + D0E967581641EF9C00FCFF06 /* NSArray+RACSequenceAdditions.m */, + 88442C8716090C1500636B49 /* NSData+RACSupport.h */, + 88442C8816090C1500636B49 /* NSData+RACSupport.m */, + D0E967591641EF9C00FCFF06 /* NSDictionary+RACSequenceAdditions.h */, + D0E9675A1641EF9C00FCFF06 /* NSDictionary+RACSequenceAdditions.m */, + 5F773DE8169B46670023069D /* NSEnumerator+RACSequenceAdditions.h */, + 5F773DE9169B46670023069D /* NSEnumerator+RACSequenceAdditions.m */, + 88442C8916090C1500636B49 /* NSFileHandle+RACSupport.h */, + 88442C8A16090C1500636B49 /* NSFileHandle+RACSupport.m */, + 74F17316186024A900BC937C /* NSIndexSet+RACSequenceAdditions.h */, + 74F17317186024A900BC937C /* NSIndexSet+RACSequenceAdditions.m */, + 88442C8B16090C1500636B49 /* NSNotificationCenter+RACSupport.h */, + 88442C8C16090C1500636B49 /* NSNotificationCenter+RACSupport.m */, + D0D243B51741FA0E004359C6 /* NSObject+RACDescription.h */, + D0D243B61741FA0E004359C6 /* NSObject+RACDescription.m */, + 880D7A5816F7B351004A3361 /* NSObject+RACSelectorSignal.h */, + 880D7A5916F7B351004A3361 /* NSObject+RACSelectorSignal.m */, + D0E9675B1641EF9C00FCFF06 /* NSOrderedSet+RACSequenceAdditions.h */, + D0E9675C1641EF9C00FCFF06 /* NSOrderedSet+RACSequenceAdditions.m */, + D0E9675D1641EF9C00FCFF06 /* NSSet+RACSequenceAdditions.h */, + D0E9675E1641EF9C00FCFF06 /* NSSet+RACSequenceAdditions.m */, + D0E9675F1641EF9C00FCFF06 /* NSString+RACSequenceAdditions.h */, + D0E967601641EF9C00FCFF06 /* NSString+RACSequenceAdditions.m */, + 88442C8D16090C1500636B49 /* NSString+RACSupport.h */, + 88442C8E16090C1500636B49 /* NSString+RACSupport.m */, + D090767D17FBEADE00EB087A /* NSURLConnection+RACSupport.h */, + D090767E17FBEADE00EB087A /* NSURLConnection+RACSupport.m */, + BE527E9118636F7F006349E8 /* NSUserDefaults+RACSupport.h */, + BE527E9218636F7F006349E8 /* NSUserDefaults+RACSupport.m */, + ); + name = "Foundation Support"; + sourceTree = "<group>"; + }; + 88CDF7B015000FCE00163A9F = { + isa = PBXGroup; + children = ( + 88CDF7C515000FCE00163A9F /* ReactiveCocoa */, + 88CDF7E215000FCF00163A9F /* ReactiveCocoaTests */, + 88CDF7BE15000FCE00163A9F /* Frameworks */, + D094E45117775B1000906BF7 /* Configuration */, + 88CDF7BC15000FCE00163A9F /* Products */, + ); + sourceTree = "<group>"; + usesTabs = 1; + }; + 88CDF7BC15000FCE00163A9F /* Products */ = { + isa = PBXGroup; + children = ( + 88CDF7DC15000FCF00163A9F /* ReactiveCocoaTests.octest */, + 88037F8315056328001A5B19 /* ReactiveCocoa.framework */, + 88F440AB153DAC820097B4C3 /* libReactiveCocoa-iOS.a */, + 5FAF5223174D4C2000CAC810 /* ReactiveCocoaTests-iOS.octest */, + 1860F412177C91B500C7B3C9 /* ReactiveCocoa-iOS-UIKitTestHost.app */, + 1860F430177C91B500C7B3C9 /* ReactiveCocoa-iOS-UIKitTestHostTests.octest */, + D05AD39417F2D56F0080895B /* libReactiveCocoa-Mac.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + 88CDF7BE15000FCE00163A9F /* Frameworks */ = { + isa = PBXGroup; + children = ( + D40D7AAC18E22B7E0065BB70 /* libSpecta.a */, + D40D7AB018E22BF60065BB70 /* libSpecta-iOS.a */, + D40D7AAA18E22B5E0065BB70 /* libExpecta.a */, + D40D7AAE18E22BE30065BB70 /* libExpecta-iOS.a */, + D094E44417775ACD00906BF7 /* libextobjc */, + 1860F413177C91B500C7B3C9 /* UIKit.framework */, + 1860F415177C91B500C7B3C9 /* Foundation.framework */, + 1860F417177C91B500C7B3C9 /* CoreGraphics.framework */, + 1860F431177C91B500C7B3C9 /* SenTestingKit.framework */, + D05AD39517F2D5700080895B /* Cocoa.framework */, + D05AD3A317F2D5700080895B /* XCTest.framework */, + 88CDF7C115000FCE00163A9F /* Other Frameworks */, + ); + name = Frameworks; + sourceTree = "<group>"; + }; + 88CDF7C115000FCE00163A9F /* Other Frameworks */ = { + isa = PBXGroup; + children = ( + 88CDF7BF15000FCE00163A9F /* Cocoa.framework */, + 88CDF7C315000FCE00163A9F /* CoreData.framework */, + 5FAF5288174E9CD200CAC810 /* CoreGraphics.framework */, + 88CDF7C415000FCE00163A9F /* Foundation.framework */, + 88CDF7DD15000FCF00163A9F /* SenTestingKit.framework */, + 5FD7DC7B174F9EEB008710B4 /* UIKit.framework */, + D05AD39717F2D5700080895B /* AppKit.framework */, + ); + name = "Other Frameworks"; + sourceTree = "<group>"; + }; + 88CDF7C515000FCE00163A9F /* ReactiveCocoa */ = { + isa = PBXGroup; + children = ( + 88037F8C15056328001A5B19 /* ReactiveCocoa.h */, + 88DA308C15071C4C00C19D0F /* Core */, + 889C04BB155DA37600F19F0C /* Foundation Support */, + 88DA309415071C5F00C19D0F /* AppKit Support */, + 88F44257153DC0100097B4C3 /* UIKit Support */, + 88977C5915129AB200A09EC5 /* KVO + Bindings */, + A1FCC36F15675466008C9686 /* Objective-C Runtime */, + 88CDF7C615000FCE00163A9F /* Supporting Files */, + ); + path = ReactiveCocoa; + sourceTree = "<group>"; + }; + 88CDF7C615000FCE00163A9F /* Supporting Files */ = { + isa = PBXGroup; + children = ( + 88CDF7C715000FCE00163A9F /* ReactiveCocoa-Info.plist */, + 88CDF7C815000FCE00163A9F /* InfoPlist.strings */, + 88CDF7CD15000FCE00163A9F /* ReactiveCocoa-Prefix.pch */, + ); + name = "Supporting Files"; + sourceTree = "<group>"; + }; + 88CDF7E215000FCF00163A9F /* ReactiveCocoaTests */ = { + isa = PBXGroup; + children = ( + 5FAF5260174D4D7100CAC810 /* iOS */, + 5FAF525F174D4D6100CAC810 /* OS X */, + 88CDF7E315000FCF00163A9F /* Supporting Files */, + 5F773DEF169B48830023069D /* NSEnumeratorRACSequenceAdditionsSpec.m */, + D0700F4B1672994D00D7CD30 /* NSNotificationCenterRACSupportSpec.m */, + 6E58405E16F3414200F588A6 /* NSObjectRACDeallocatingSpec.m */, + 8801E7501644BDE200A155FE /* NSObjectRACLiftingSpec.m */, + 1E89337F171647A5009071B0 /* NSObjectRACPropertySubscribingExamples.h */, + 1E893380171647A5009071B0 /* NSObjectRACPropertySubscribingExamples.m */, + 8851A38A16161D500050D47F /* NSObjectRACPropertySubscribingSpec.m */, + 880D7A6516F7BB1A004A3361 /* NSObjectRACSelectorSignalSpec.m */, + 5FDC350E1736F81800792E52 /* NSStringRACKeyPathUtilitiesSpec.m */, + D090768917FBECBF00EB087A /* NSURLConnectionRACSupportSpec.m */, + BE527E9E1863705B006349E8 /* NSUserDefaultsRACSupportSpec.m */, + D0870C6E16884A0600D0E11D /* RACBacktraceSpec.m */, + 5F7EFECC168FBC4B0037E500 /* RACChannelExamples.h */, + 5F7EFECD168FBC4B0037E500 /* RACChannelExamples.m */, + 5F7EFECE168FBC4B0037E500 /* RACChannelSpec.m */, + D075A72817BCB7E100C24FB7 /* RACControlCommandExamples.h */, + D075A72917BCB7E100C24FB7 /* RACControlCommandExamples.m */, + 886CEACC163DE669007632D1 /* RACBlockTrampolineSpec.m */, + 882CCA1D15F1564D00937D6E /* RACCommandSpec.m */, + 881E86B91669350B00667F7B /* RACCompoundDisposableSpec.m */, + D0A0E225176A84DA007273ED /* RACDisposableSpec.m */, + D077A171169B79A900057BB1 /* RACEventSpec.m */, + 5F2447AC167E87C50062180C /* RACKVOChannelSpec.m */, + D041376815D2281C004BBF80 /* RACKVOWrapperSpec.m */, + 88C5A02816924BFC0045EF05 /* RACMulticastConnectionSpec.m */, + D0EDE76516968AB10072A780 /* RACPropertySignalExamples.h */, + D0EDE76616968AB10072A780 /* RACPropertySignalExamples.m */, + 8803C010166732BA00C36839 /* RACSchedulerSpec.m */, + D0C70F8F164337A2007027B4 /* RACSequenceAdditionsSpec.m */, + D0C70F91164337E3007027B4 /* RACSequenceExamples.h */, + D0C70F92164337E3007027B4 /* RACSequenceExamples.m */, + D0D487051642651400DD7605 /* RACSequenceSpec.m */, + 8820937B1501C8A600796685 /* RACSignalSpec.m */, + 8884DD6A1756AD3600F6C379 /* RACSignalStartExamples.h */, + 8884DD641756ACF600F6C379 /* RACSignalStartExamples.m */, + D0487AB1164314430085D890 /* RACStreamExamples.h */, + D0487AB2164314430085D890 /* RACStreamExamples.m */, + 880D7A6716F7BCC7004A3361 /* RACSubclassObject.h */, + 880D7A6816F7BCC7004A3361 /* RACSubclassObject.m */, + 889D0A7F15974B2A00F833E3 /* RACSubjectSpec.m */, + D0C70EC416659333005AAD03 /* RACSubscriberExamples.h */, + D0C70EC516659333005AAD03 /* RACSubscriberExamples.m */, + D0C70EC7166595AD005AAD03 /* RACSubscriberSpec.m */, + 88FC735A16114FFB00F8A774 /* RACSubscriptingAssignmentTrampolineSpec.m */, + 88302C2D1762C180003633BD /* RACTargetQueueSchedulerSpec.m */, + 88302BFB1762A9E6003633BD /* RACTestExampleScheduler.h */, + 88302BFC1762A9E6003633BD /* RACTestExampleScheduler.m */, + 88442A321608A9AD00636B49 /* RACTestObject.h */, + 88442A331608A9AD00636B49 /* RACTestObject.m */, + D02221611678910900DBD031 /* RACTupleSpec.m */, + 8803C010166732BA00C36839 /* RACSchedulerSpec.m */, + D028DB7C179E591E00D1042F /* RACSerialDisposableSpec.m */, + D07200241788C57200987F70 /* RACTestSchedulerSpec.m */, + ); + path = ReactiveCocoaTests; + sourceTree = "<group>"; + }; + 88CDF7E315000FCF00163A9F /* Supporting Files */ = { + isa = PBXGroup; + children = ( + 88CDF7E415000FCF00163A9F /* ReactiveCocoaTests-Info.plist */, + 88CDF7E515000FCF00163A9F /* InfoPlist.strings */, + D01DB9AE166819B9003E8F7F /* ReactiveCocoaTests-Prefix.pch */, + D090768C17FBED2E00EB087A /* test-data.json */, + ); + name = "Supporting Files"; + sourceTree = "<group>"; + }; + 88DA308C15071C4C00C19D0F /* Core */ = { + isa = PBXGroup; + children = ( + 88CDF7FA150019CA00163A9F /* RACSubscriber.h */, + D0FAEC02176AEEE600D3C1A7 /* RACSubscriber+Private.h */, + 88CDF7FB150019CA00163A9F /* RACSubscriber.m */, + D0A0E22C176A8CD6007273ED /* RACPassthroughSubscriber.h */, + D0A0E22D176A8CD6007273ED /* RACPassthroughSubscriber.m */, + 888439A11634E10D00DED0DB /* RACBlockTrampoline.h */, + 888439A21634E10D00DED0DB /* RACBlockTrampoline.m */, + 881B37CA152260BF0079220B /* RACUnit.h */, + 881B37CB152260BF0079220B /* RACUnit.m */, + 88B76F8C153726B00053EAE2 /* RACTuple.h */, + 88B76F8D153726B00053EAE2 /* RACTuple.m */, + D02538A115E2D7FB005BACB8 /* RACBacktrace.h */, + D0DFBCCD15DD6D40009DADB3 /* RACBacktrace.m */, + 88FC735316114F9C00F8A774 /* RACSubscriptingAssignmentTrampoline.h */, + 88FC735416114F9C00F8A774 /* RACSubscriptingAssignmentTrampoline.m */, + 6E58405316F22D7500F588A6 /* NSObject+RACDeallocating.h */, + 6E58405416F22D7500F588A6 /* NSObject+RACDeallocating.m */, + 886CEAE0163DE942007632D1 /* NSObject+RACLifting.h */, + 886CEAE1163DE942007632D1 /* NSObject+RACLifting.m */, + 887ACDA5165878A7009190AD /* NSInvocation+RACTypeParsing.h */, + 887ACDA6165878A7009190AD /* NSInvocation+RACTypeParsing.m */, + D0D486FF1642550100DD7605 /* RACStream.h */, + D07E9489179DD21E00A6F609 /* RACStream+Private.h */, + D0D487001642550100DD7605 /* RACStream.m */, + D0D486FB164253B600DD7605 /* Signals */, + D0D486FD164253D500DD7605 /* Disposables */, + D0D486FE164253E100DD7605 /* Commands */, + D0E967561641EF8200FCFF06 /* Sequences */, + D0087C1B16705C5600679459 /* Schedulers */, + ); + name = Core; + sourceTree = "<group>"; + }; + 88DA309415071C5F00C19D0F /* AppKit Support */ = { + isa = PBXGroup; + children = ( + 882093E61501E6CB00796685 /* NSControl+RACCommandSupport.h */, + 882093E71501E6CB00796685 /* NSControl+RACCommandSupport.m */, + D0A0B03916EAA9AC00C47593 /* NSControl+RACTextSignalSupport.h */, + D0A0B03A16EAA9AC00C47593 /* NSControl+RACTextSignalSupport.m */, + 88F440D1153DADEA0097B4C3 /* NSObject+RACAppKitBindings.h */, + 88F440D2153DADEA0097B4C3 /* NSObject+RACAppKitBindings.m */, + D0A0B01316EAA3D100C47593 /* NSText+RACSignalSupport.h */, + D0A0B01416EAA3D100C47593 /* NSText+RACSignalSupport.m */, + ); + name = "AppKit Support"; + sourceTree = "<group>"; + }; + 88F44257153DC0100097B4C3 /* UIKit Support */ = { + isa = PBXGroup; + children = ( + A1FCC3761567DED0008C9686 /* RACDelegateProxy.h */, + A1FCC3771567DED0008C9686 /* RACDelegateProxy.m */, + 557A4B58177648C7008EF796 /* UIActionSheet+RACSignalSupport.h */, + 557A4B59177648C7008EF796 /* UIActionSheet+RACSignalSupport.m */, + ACB0EAF21797DDD400942FFC /* UIAlertView+RACSignalSupport.h */, + ACB0EAF11797DDD400942FFC /* UIAlertView+RACSignalSupport.m */, + 27A887C71703DB4F00040001 /* UIBarButtonItem+RACCommandSupport.h */, + 27A887C81703DB4F00040001 /* UIBarButtonItem+RACCommandSupport.m */, + 5EE9A7911760D61300EAF5A2 /* UIButton+RACCommandSupport.h */, + 5EE9A7921760D61300EAF5A2 /* UIButton+RACCommandSupport.m */, + 1668027817FE75E900C724B4 /* UICollectionReusableView+RACSignalSupport.h */, + 1668027917FE75E900C724B4 /* UICollectionReusableView+RACSignalSupport.m */, + 88F4425F153DC0450097B4C3 /* UIControl+RACSignalSupport.h */, + 88F44260153DC0450097B4C3 /* UIControl+RACSignalSupport.m */, + 5F016DF217B10AA8002EEC69 /* UIControl+RACSignalSupportPrivate.h */, + 5F016DF317B10AA8002EEC69 /* UIControl+RACSignalSupportPrivate.m */, + 5F70B2AD17AB1829009AEDF9 /* UIDatePicker+RACSignalSupport.h */, + 5F70B2AE17AB1829009AEDF9 /* UIDatePicker+RACSignalSupport.m */, + 1EC06B15173CB04000365258 /* UIGestureRecognizer+RACSignalSupport.h */, + 1EC06B16173CB04000365258 /* UIGestureRecognizer+RACSignalSupport.m */, + 554D9E5B181064E200F21262 /* UIRefreshControl+RACCommandSupport.h */, + 554D9E5C181064E200F21262 /* UIRefreshControl+RACCommandSupport.m */, + 5F70B2B617AB1856009AEDF9 /* UISegmentedControl+RACSignalSupport.h */, + 5F70B2B717AB1856009AEDF9 /* UISegmentedControl+RACSignalSupport.m */, + 5F70B2B817AB1856009AEDF9 /* UISlider+RACSignalSupport.h */, + 5F70B2B917AB1856009AEDF9 /* UISlider+RACSignalSupport.m */, + 5F70B2BA17AB1857009AEDF9 /* UIStepper+RACSignalSupport.h */, + 5F70B2BB17AB1857009AEDF9 /* UIStepper+RACSignalSupport.m */, + 5F70B2BC17AB1857009AEDF9 /* UISwitch+RACSignalSupport.h */, + 5F70B2BD17AB1857009AEDF9 /* UISwitch+RACSignalSupport.m */, + D028DB85179E616700D1042F /* UITableViewCell+RACSignalSupport.h */, + D028DB86179E616700D1042F /* UITableViewCell+RACSignalSupport.m */, + CD11C6F118714CD0007C7CFD /* UITableViewHeaderFooterView+RACSignalSupport.h */, + CD11C6F218714CD0007C7CFD /* UITableViewHeaderFooterView+RACSignalSupport.m */, + 88F44264153DCAC50097B4C3 /* UITextField+RACSignalSupport.h */, + 88F44265153DCAC50097B4C3 /* UITextField+RACSignalSupport.m */, + A1FCC27215666AA3008C9686 /* UITextView+RACSignalSupport.h */, + A1FCC27315666AA3008C9686 /* UITextView+RACSignalSupport.m */, + ); + name = "UIKit Support"; + sourceTree = "<group>"; + }; + A1FCC36F15675466008C9686 /* Objective-C Runtime */ = { + isa = PBXGroup; + children = ( + A1FCC370156754A7008C9686 /* RACObjCRuntime.h */, + A1FCC371156754A7008C9686 /* RACObjCRuntime.m */, + ); + name = "Objective-C Runtime"; + sourceTree = "<group>"; + }; + D0087C1B16705C5600679459 /* Schedulers */ = { + isa = PBXGroup; + children = ( + 88E2C6B2153C771C00C7493C /* RACScheduler.h */, + 886D98581667C86D00F22541 /* RACScheduler+Private.h */, + 88E2C6B3153C771C00C7493C /* RACScheduler.m */, + 881E87AA16695C5600667F7B /* RACQueueScheduler.h */, + 882D07201761521B009EDA69 /* RACQueueScheduler+Subclass.h */, + 881E87AB16695C5600667F7B /* RACQueueScheduler.m */, + 882D071717614FA7009EDA69 /* RACTargetQueueScheduler.h */, + 882D071817614FA7009EDA69 /* RACTargetQueueScheduler.m */, + 881E87B016695EDF00667F7B /* RACImmediateScheduler.h */, + 881E87B116695EDF00667F7B /* RACImmediateScheduler.m */, + 881E87C21669635F00667F7B /* RACSubscriptionScheduler.h */, + 881E87C31669636000667F7B /* RACSubscriptionScheduler.m */, + D00930771788AB7B00EE7E8B /* RACTestScheduler.h */, + D00930781788AB7B00EE7E8B /* RACTestScheduler.m */, + ); + name = Schedulers; + sourceTree = "<group>"; + }; + D013A3EC1807B9260072B6CE /* Private */ = { + isa = PBXGroup; + children = ( + D013A3ED1807B9690072B6CE /* RACDynamicSignal.h */, + D013A3EE1807B9690072B6CE /* RACDynamicSignal.m */, + D013A3DC1807B7450072B6CE /* RACEmptySignal.h */, + D013A3DD1807B7450072B6CE /* RACEmptySignal.m */, + D013A3D41807B5ED0072B6CE /* RACErrorSignal.h */, + D013A3D51807B5ED0072B6CE /* RACErrorSignal.m */, + D013A3E41807B7C30072B6CE /* RACReturnSignal.h */, + D013A3E51807B7C30072B6CE /* RACReturnSignal.m */, + ); + name = Private; + sourceTree = "<group>"; + }; + D094E44417775ACD00906BF7 /* libextobjc */ = { + isa = PBXGroup; + children = ( + D094E44517775AF200906BF7 /* EXTKeyPathCoding.h */, + D05F9D3317984EC000FD7982 /* EXTRuntimeExtensions.h */, + D05F9D3417984EC000FD7982 /* EXTRuntimeExtensions.m */, + D094E44617775AF200906BF7 /* EXTScope.h */, + D094E44817775AF200906BF7 /* metamacros.h */, + ); + name = libextobjc; + path = ReactiveCocoa/extobjc; + sourceTree = "<group>"; + }; + D094E45117775B1000906BF7 /* Configuration */ = { + isa = PBXGroup; + children = ( + D094E45217775B1000906BF7 /* Base */, + D094E45C17775B1000906BF7 /* iOS */, + D094E46017775B1000906BF7 /* Mac OS X */, + D094E46617775B1000906BF7 /* README.md */, + ); + name = Configuration; + path = ../external/xcconfigs; + sourceTree = "<group>"; + }; + D094E45217775B1000906BF7 /* Base */ = { + isa = PBXGroup; + children = ( + D094E45317775B1000906BF7 /* Common.xcconfig */, + D094E45417775B1000906BF7 /* Configurations */, + D094E45917775B1000906BF7 /* Targets */, + ); + path = Base; + sourceTree = "<group>"; + }; + D094E45417775B1000906BF7 /* Configurations */ = { + isa = PBXGroup; + children = ( + D094E45517775B1000906BF7 /* Debug.xcconfig */, + D094E45617775B1000906BF7 /* Profile.xcconfig */, + D094E45717775B1000906BF7 /* Release.xcconfig */, + D094E45817775B1000906BF7 /* Test.xcconfig */, + ); + path = Configurations; + sourceTree = "<group>"; + }; + D094E45917775B1000906BF7 /* Targets */ = { + isa = PBXGroup; + children = ( + D094E45A17775B1000906BF7 /* Application.xcconfig */, + D094E45B17775B1000906BF7 /* StaticLibrary.xcconfig */, + ); + path = Targets; + sourceTree = "<group>"; + }; + D094E45C17775B1000906BF7 /* iOS */ = { + isa = PBXGroup; + children = ( + D094E45D17775B1000906BF7 /* iOS-Application.xcconfig */, + D094E45E17775B1000906BF7 /* iOS-Base.xcconfig */, + D094E45F17775B1000906BF7 /* iOS-StaticLibrary.xcconfig */, + ); + path = iOS; + sourceTree = "<group>"; + }; + D094E46017775B1000906BF7 /* Mac OS X */ = { + isa = PBXGroup; + children = ( + D094E46117775B1000906BF7 /* Mac-Application.xcconfig */, + D094E46217775B1000906BF7 /* Mac-Base.xcconfig */, + D094E46317775B1000906BF7 /* Mac-DynamicLibrary.xcconfig */, + D094E46417775B1000906BF7 /* Mac-Framework.xcconfig */, + D094E46517775B1000906BF7 /* Mac-StaticLibrary.xcconfig */, + ); + path = "Mac OS X"; + sourceTree = "<group>"; + }; + D0D486FB164253B600DD7605 /* Signals */ = { + isa = PBXGroup; + children = ( + 88CDF80415001CA800163A9F /* RACSignal.h */, + 88977C3D1512914A00A09EC5 /* RACSignal.m */, + D03525D317E2EBC90099CBAB /* RACSignalProvider.d */, + D0D910CC15F915BD00AD2DDA /* RACSignal+Operations.h */, + D0D910CD15F915BD00AD2DDA /* RACSignal+Operations.m */, + D077A16B169B740200057BB1 /* RACEvent.h */, + D077A16C169B740200057BB1 /* RACEvent.m */, + 88C5A0231692460A0045EF05 /* RACMulticastConnection.h */, + 88F5870515361C170084BD32 /* RACMulticastConnection+Private.h */, + 88C5A025169246140045EF05 /* RACMulticastConnection.m */, + 886F70281551CF920045D68B /* RACGroupedSignal.h */, + 886F70291551CF920045D68B /* RACGroupedSignal.m */, + D013A3EC1807B9260072B6CE /* Private */, + D0D486FC164253C400DD7605 /* Subjects */, + ); + name = Signals; + sourceTree = "<group>"; + }; + D0D486FC164253C400DD7605 /* Subjects */ = { + isa = PBXGroup; + children = ( + 880B9174150B09190008488E /* RACSubject.h */, + 880B9175150B09190008488E /* RACSubject.m */, + 88D4AB3C1510F6C30011494F /* RACReplaySubject.h */, + 88D4AB3D1510F6C30011494F /* RACReplaySubject.m */, + 883A84D81513964B006DB4C7 /* RACBehaviorSubject.h */, + 883A84D91513964B006DB4C7 /* RACBehaviorSubject.m */, + ); + name = Subjects; + sourceTree = "<group>"; + }; + D0D486FD164253D500DD7605 /* Disposables */ = { + isa = PBXGroup; + children = ( + 883A84DD1513B5EC006DB4C7 /* RACDisposable.h */, + 883A84DE1513B5EC006DB4C7 /* RACDisposable.m */, + 884476E2152367D100958F44 /* RACScopedDisposable.h */, + 884476E3152367D100958F44 /* RACScopedDisposable.m */, + 881E86A01669304700667F7B /* RACCompoundDisposable.h */, + 881E86A11669304700667F7B /* RACCompoundDisposable.m */, + D020F3DA17F6A3E40092BED2 /* RACCompoundDisposableProvider.d */, + D028DB72179E53CB00D1042F /* RACSerialDisposable.h */, + D028DB73179E53CB00D1042F /* RACSerialDisposable.m */, + ); + name = Disposables; + sourceTree = "<group>"; + }; + D0D486FE164253E100DD7605 /* Commands */ = { + isa = PBXGroup; + children = ( + 882093E91501E6EE00796685 /* RACCommand.h */, + 882093EA1501E6EE00796685 /* RACCommand.m */, + ); + name = Commands; + sourceTree = "<group>"; + }; + D0E967561641EF8200FCFF06 /* Sequences */ = { + isa = PBXGroup; + children = ( + D0E967671641EF9C00FCFF06 /* RACSequence.h */, + D0E967681641EF9C00FCFF06 /* RACSequence.m */, + D0E967611641EF9C00FCFF06 /* RACArraySequence.h */, + D0E967621641EF9C00FCFF06 /* RACArraySequence.m */, + D0E967631641EF9C00FCFF06 /* RACDynamicSequence.h */, + D0E967641641EF9C00FCFF06 /* RACDynamicSequence.m */, + 5F9743F51694A2460024EB82 /* RACEagerSequence.h */, + 5F9743F61694A2460024EB82 /* RACEagerSequence.m */, + D0E967651641EF9C00FCFF06 /* RACEmptySequence.h */, + D0E967661641EF9C00FCFF06 /* RACEmptySequence.m */, + 7479F6E3186177D200575CDB /* RACIndexSetSequence.h */, + 7479F6E4186177D200575CDB /* RACIndexSetSequence.m */, + D0E967691641EF9C00FCFF06 /* RACStringSequence.h */, + D0E9676A1641EF9C00FCFF06 /* RACStringSequence.m */, + D0EE2849164D906B006954A4 /* RACSignalSequence.h */, + D0EE284A164D906B006954A4 /* RACSignalSequence.m */, + D0307EDB1731AAE100D83211 /* RACTupleSequence.h */, + D0307EDC1731AAE100D83211 /* RACTupleSequence.m */, + D07CD7141731BA3900DE2394 /* RACUnarySequence.h */, + D07CD7151731BA3900DE2394 /* RACUnarySequence.m */, + ); + name = Sequences; + sourceTree = "<group>"; + }; +/* End PBXGroup section */ + +/* Begin PBXHeadersBuildPhase section */ + 88037F8015056328001A5B19 /* Headers */ = { + isa = PBXHeadersBuildPhase; + buildActionMask = 2147483647; + files = ( + 882D071917614FA7009EDA69 /* RACTargetQueueScheduler.h in Headers */, + 881E87AC16695C5600667F7B /* RACQueueScheduler.h in Headers */, + 88037FB81505645C001A5B19 /* ReactiveCocoa.h in Headers */, + 88037FBB1505646C001A5B19 /* NSObject+RACPropertySubscribing.h in Headers */, + 88037FBC1505646C001A5B19 /* RACSignal.h in Headers */, + 88037FBE1505646C001A5B19 /* RACSubscriber.h in Headers */, + 88037FC11505646C001A5B19 /* RACCommand.h in Headers */, + 88037FC21505646C001A5B19 /* NSControl+RACCommandSupport.h in Headers */, + D028DB74179E53CB00D1042F /* RACSerialDisposable.h in Headers */, + 880B9176150B09190008488E /* RACSubject.h in Headers */, + D090767F17FBEADE00EB087A /* NSURLConnection+RACSupport.h in Headers */, + 88F440D3153DADEA0097B4C3 /* NSObject+RACAppKitBindings.h in Headers */, + 88D4AB3E1510F6C30011494F /* RACReplaySubject.h in Headers */, + 883A84DA1513964B006DB4C7 /* RACBehaviorSubject.h in Headers */, + 883A84DF1513B5EC006DB4C7 /* RACDisposable.h in Headers */, + 886F702A1551CF920045D68B /* RACGroupedSignal.h in Headers */, + 881B37CC152260BF0079220B /* RACUnit.h in Headers */, + 884476E4152367D100958F44 /* RACScopedDisposable.h in Headers */, + 88E2C6B4153C771C00C7493C /* RACScheduler.h in Headers */, + 88B76F8E153726B00053EAE2 /* RACTuple.h in Headers */, + 886CEAE2163DE942007632D1 /* NSObject+RACLifting.h in Headers */, + D0D910CE15F915BD00AD2DDA /* RACSignal+Operations.h in Headers */, + D0E9676B1641EF9C00FCFF06 /* NSArray+RACSequenceAdditions.h in Headers */, + D0E9676F1641EF9C00FCFF06 /* NSDictionary+RACSequenceAdditions.h in Headers */, + D0E967731641EF9C00FCFF06 /* NSOrderedSet+RACSequenceAdditions.h in Headers */, + D0E967771641EF9C00FCFF06 /* NSSet+RACSequenceAdditions.h in Headers */, + D0E9677B1641EF9C00FCFF06 /* NSString+RACSequenceAdditions.h in Headers */, + D0E9678B1641EF9C00FCFF06 /* RACSequence.h in Headers */, + 88A0B6D3165B2B77005DE8F3 /* RACSubscriptingAssignmentTrampoline.h in Headers */, + D0D487011642550100DD7605 /* RACStream.h in Headers */, + 88C5A0241692460A0045EF05 /* RACMulticastConnection.h in Headers */, + 881E86A21669304800667F7B /* RACCompoundDisposable.h in Headers */, + 881E87C41669636000667F7B /* RACSubscriptionScheduler.h in Headers */, + 5F45A885168CFA3E00B58A2B /* RACKVOChannel.h in Headers */, + 880D7A5A16F7B351004A3361 /* NSObject+RACSelectorSignal.h in Headers */, + 6E58405516F22D7500F588A6 /* NSObject+RACDeallocating.h in Headers */, + 5F6FE8531692568A00A8D7A6 /* RACChannel.h in Headers */, + 882D072117615381009EDA69 /* RACQueueScheduler+Subclass.h in Headers */, + D005A259169A3B7D00A9D2DB /* RACBacktrace.h in Headers */, + BE527E9318636F7F006349E8 /* NSUserDefaults+RACSupport.h in Headers */, + 5F773DEA169B46670023069D /* NSEnumerator+RACSequenceAdditions.h in Headers */, + D077A16D169B740200057BB1 /* RACEvent.h in Headers */, + D0A0B01516EAA3D100C47593 /* NSText+RACSignalSupport.h in Headers */, + D0A0B03B16EAA9AC00C47593 /* NSControl+RACTextSignalSupport.h in Headers */, + D094E44917775AF200906BF7 /* EXTKeyPathCoding.h in Headers */, + D094E44B17775AF200906BF7 /* EXTScope.h in Headers */, + D094E44F17775AF200906BF7 /* metamacros.h in Headers */, + D00930791788AB7B00EE7E8B /* RACTestScheduler.h in Headers */, + 74F17318186024A900BC937C /* NSIndexSet+RACSequenceAdditions.h in Headers */, + 55C39DEC17F1EC84006DC60C /* NSData+RACSupport.h in Headers */, + 55C39DED17F1EC84006DC60C /* NSFileHandle+RACSupport.h in Headers */, + 55C39DEE17F1EC84006DC60C /* NSNotificationCenter+RACSupport.h in Headers */, + 55C39DEF17F1EC84006DC60C /* NSString+RACSupport.h in Headers */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 88F440A9153DAC820097B4C3 /* Headers */ = { + isa = PBXHeadersBuildPhase; + buildActionMask = 2147483647; + files = ( + 880D7A5B16F7B351004A3361 /* NSObject+RACSelectorSignal.h in Headers */, + CD11C6F318714CD0007C7CFD /* UITableViewHeaderFooterView+RACSignalSupport.h in Headers */, + 5F45A886168CFA3E00B58A2B /* RACKVOChannel.h in Headers */, + 554D9E5D181064E200F21262 /* UIRefreshControl+RACCommandSupport.h in Headers */, + 5F6FE8541692568A00A8D7A6 /* RACChannel.h in Headers */, + D08FF264169A32D100743C6D /* ReactiveCocoa.h in Headers */, + D08FF265169A32DC00743C6D /* RACSubscriber.h in Headers */, + D08FF267169A330000743C6D /* RACUnit.h in Headers */, + D08FF268169A330000743C6D /* RACTuple.h in Headers */, + D08FF269169A330000743C6D /* RACBacktrace.h in Headers */, + D08FF26A169A330000743C6D /* RACSubscriptingAssignmentTrampoline.h in Headers */, + 74F17319186024A900BC937C /* NSIndexSet+RACSequenceAdditions.h in Headers */, + D08FF26C169A331A00743C6D /* RACStream.h in Headers */, + D08FF26D169A331A00743C6D /* RACSignal.h in Headers */, + D08FF26E169A331A00743C6D /* RACSignal+Operations.h in Headers */, + D08FF26F169A331A00743C6D /* RACMulticastConnection.h in Headers */, + D08FF270169A331A00743C6D /* RACGroupedSignal.h in Headers */, + D08FF271169A331A00743C6D /* RACSubject.h in Headers */, + D08FF272169A331A00743C6D /* RACReplaySubject.h in Headers */, + D08FF273169A331A00743C6D /* RACBehaviorSubject.h in Headers */, + D08FF274169A331A00743C6D /* RACDisposable.h in Headers */, + D08FF275169A331A00743C6D /* RACScopedDisposable.h in Headers */, + D08FF276169A331A00743C6D /* RACCompoundDisposable.h in Headers */, + D08FF277169A331B00743C6D /* RACCommand.h in Headers */, + D08FF278169A331B00743C6D /* RACSequence.h in Headers */, + D08FF27F169A331B00743C6D /* RACScheduler.h in Headers */, + D08FF26B169A330000743C6D /* NSObject+RACLifting.h in Headers */, + D08FF280169A333400743C6D /* NSArray+RACSequenceAdditions.h in Headers */, + D028DB75179E53CB00D1042F /* RACSerialDisposable.h in Headers */, + D08FF281169A333400743C6D /* NSDictionary+RACSequenceAdditions.h in Headers */, + D08FF282169A333400743C6D /* NSOrderedSet+RACSequenceAdditions.h in Headers */, + D028DB87179E616700D1042F /* UITableViewCell+RACSignalSupport.h in Headers */, + 1646747B17FFA0610036E30B /* UICollectionReusableView+RACSignalSupport.h in Headers */, + D08FF283169A333400743C6D /* NSSet+RACSequenceAdditions.h in Headers */, + D08FF284169A333400743C6D /* NSString+RACSequenceAdditions.h in Headers */, + D08FF285169A333400743C6D /* UIControl+RACSignalSupport.h in Headers */, + D08FF286169A333400743C6D /* UITextField+RACSignalSupport.h in Headers */, + D08FF287169A333400743C6D /* UITextView+RACSignalSupport.h in Headers */, + D08FF289169A333400743C6D /* NSObject+RACPropertySubscribing.h in Headers */, + 5F773DEB169B46670023069D /* NSEnumerator+RACSequenceAdditions.h in Headers */, + D077A16E169B740200057BB1 /* RACEvent.h in Headers */, + 6EA0C08216F4AEC1006EBEB2 /* NSObject+RACDeallocating.h in Headers */, + 27A887D21703DDEB00040001 /* UIBarButtonItem+RACCommandSupport.h in Headers */, + 1EC06B17173CB04000365258 /* UIGestureRecognizer+RACSignalSupport.h in Headers */, + D090768017FBEADE00EB087A /* NSURLConnection+RACSupport.h in Headers */, + 5EE9A7931760D61300EAF5A2 /* UIButton+RACCommandSupport.h in Headers */, + 88302C961762EC79003633BD /* RACQueueScheduler.h in Headers */, + BE527E9418636F7F006349E8 /* NSUserDefaults+RACSupport.h in Headers */, + 88302C9B1762EC7E003633BD /* RACQueueScheduler+Subclass.h in Headers */, + 88302CA21762F62D003633BD /* RACTargetQueueScheduler.h in Headers */, + 557A4B5A177648C7008EF796 /* UIActionSheet+RACSignalSupport.h in Headers */, + ACB0EAF41797DDD400942FFC /* UIAlertView+RACSignalSupport.h in Headers */, + D094E44A17775AF200906BF7 /* EXTKeyPathCoding.h in Headers */, + D094E44C17775AF200906BF7 /* EXTScope.h in Headers */, + D094E45017775AF200906BF7 /* metamacros.h in Headers */, + D009307A1788AB7B00EE7E8B /* RACTestScheduler.h in Headers */, + 5F70B2AF17AB1829009AEDF9 /* UIDatePicker+RACSignalSupport.h in Headers */, + 5F70B2BE17AB1857009AEDF9 /* UISegmentedControl+RACSignalSupport.h in Headers */, + 5F70B2C017AB1857009AEDF9 /* UISlider+RACSignalSupport.h in Headers */, + 5F70B2C217AB1857009AEDF9 /* UIStepper+RACSignalSupport.h in Headers */, + 5F70B2C417AB1857009AEDF9 /* UISwitch+RACSignalSupport.h in Headers */, + 55C39DF017F1EC84006DC60C /* NSData+RACSupport.h in Headers */, + 55C39DF117F1EC84006DC60C /* NSFileHandle+RACSupport.h in Headers */, + 55C39DF217F1EC84006DC60C /* NSNotificationCenter+RACSupport.h in Headers */, + 55C39DF317F1EC84006DC60C /* NSString+RACSupport.h in Headers */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + D05AD39217F2D56F0080895B /* Headers */ = { + isa = PBXHeadersBuildPhase; + buildActionMask = 2147483647; + files = ( + D05AD3E017F2DB1D0080895B /* RACBehaviorSubject.h in Headers */, + D05AD3C917F2DB100080895B /* RACSubscriptingAssignmentTrampoline.h in Headers */, + D05AD3C517F2DB100080895B /* RACTuple.h in Headers */, + 74F1731A186024A900BC937C /* NSIndexSet+RACSequenceAdditions.h in Headers */, + D05AD41A17F2DB6A0080895B /* NSString+RACSequenceAdditions.h in Headers */, + D05AD41E17F2DB6E0080895B /* NSControl+RACCommandSupport.h in Headers */, + D05AD3E417F2DB230080895B /* RACScopedDisposable.h in Headers */, + D05AD40F17F2DB6A0080895B /* NSFileHandle+RACSupport.h in Headers */, + D05AD40517F2DB5D0080895B /* RACTestScheduler.h in Headers */, + D05AD42817F2DB840080895B /* RACKVOChannel.h in Headers */, + D05AD3FF17F2DB5D0080895B /* RACTargetQueueScheduler.h in Headers */, + D05AD3E217F2DB230080895B /* RACDisposable.h in Headers */, + D05AD42617F2DB840080895B /* RACChannel.h in Headers */, + D05AD3EA17F2DB270080895B /* RACCommand.h in Headers */, + D05AD3DE17F2DB1D0080895B /* RACReplaySubject.h in Headers */, + D05AD3D817F2DB1D0080895B /* RACMulticastConnection.h in Headers */, + D05AD3E817F2DB230080895B /* RACSerialDisposable.h in Headers */, + D05AD42E17F2DB840080895B /* NSObject+RACPropertySubscribing.h in Headers */, + D05AD3CB17F2DB100080895B /* NSObject+RACDeallocating.h in Headers */, + D05AD3D417F2DB1D0080895B /* RACSignal+Operations.h in Headers */, + D05AD41417F2DB6A0080895B /* NSObject+RACSelectorSignal.h in Headers */, + D05AD3FC17F2DB5D0080895B /* RACQueueScheduler.h in Headers */, + D05AD42017F2DB6E0080895B /* NSControl+RACTextSignalSupport.h in Headers */, + D05AD3FD17F2DB5D0080895B /* RACQueueScheduler+Subclass.h in Headers */, + D05AD42217F2DB6E0080895B /* NSObject+RACAppKitBindings.h in Headers */, + BE527E9518636F7F006349E8 /* NSUserDefaults+RACSupport.h in Headers */, + D05AD3DA17F2DB1D0080895B /* RACGroupedSignal.h in Headers */, + D05AD41617F2DB6A0080895B /* NSOrderedSet+RACSequenceAdditions.h in Headers */, + D05AD3E617F2DB230080895B /* RACCompoundDisposable.h in Headers */, + D05AD40B17F2DB6A0080895B /* NSDictionary+RACSequenceAdditions.h in Headers */, + D05AD3D617F2DB1D0080895B /* RACEvent.h in Headers */, + D05AD3D017F2DB100080895B /* RACStream.h in Headers */, + D05AD3DC17F2DB1D0080895B /* RACSubject.h in Headers */, + D05AD41C17F2DB6A0080895B /* NSString+RACSupport.h in Headers */, + D05AD42417F2DB6E0080895B /* NSText+RACSignalSupport.h in Headers */, + D05AD3C017F2DA300080895B /* RACSubscriber.h in Headers */, + D05AD40717F2DB6A0080895B /* NSArray+RACSequenceAdditions.h in Headers */, + D090768117FBEADE00EB087A /* NSURLConnection+RACSupport.h in Headers */, + D05AD3C717F2DB100080895B /* RACBacktrace.h in Headers */, + D05AD3EE17F2DB4F0080895B /* RACSequence.h in Headers */, + D05AD3D217F2DB1D0080895B /* RACSignal.h in Headers */, + D05AD3CD17F2DB100080895B /* NSObject+RACLifting.h in Headers */, + D05AD40D17F2DB6A0080895B /* NSEnumerator+RACSequenceAdditions.h in Headers */, + D05AD3FA17F2DB5D0080895B /* RACScheduler.h in Headers */, + D05AD40317F2DB5D0080895B /* RACSubscriptionScheduler.h in Headers */, + D05AD41817F2DB6A0080895B /* NSSet+RACSequenceAdditions.h in Headers */, + D05AD41117F2DB6A0080895B /* NSNotificationCenter+RACSupport.h in Headers */, + D05AD40917F2DB6A0080895B /* NSData+RACSupport.h in Headers */, + D05AD3C317F2DB100080895B /* RACUnit.h in Headers */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXHeadersBuildPhase section */ + +/* Begin PBXNativeTarget section */ + 1860F411177C91B500C7B3C9 /* ReactiveCocoa-iOS-UIKitTestHost */ = { + isa = PBXNativeTarget; + buildConfigurationList = 1860F44C177C91B500C7B3C9 /* Build configuration list for PBXNativeTarget "ReactiveCocoa-iOS-UIKitTestHost" */; + buildPhases = ( + 1860F40E177C91B500C7B3C9 /* Sources */, + 1860F40F177C91B500C7B3C9 /* Frameworks */, + 1860F410177C91B500C7B3C9 /* Resources */, + ); + buildRules = ( + ); + dependencies = ( + D0F117C3179F0A91006CE68F /* PBXTargetDependency */, + ); + name = "ReactiveCocoa-iOS-UIKitTestHost"; + productName = "ReactiveCocoa-iOS-UIKitTestHost"; + productReference = 1860F412177C91B500C7B3C9 /* ReactiveCocoa-iOS-UIKitTestHost.app */; + productType = "com.apple.product-type.application"; + }; + 1860F42F177C91B500C7B3C9 /* ReactiveCocoa-iOS-UIKitTestHostTests */ = { + isa = PBXNativeTarget; + buildConfigurationList = 1860F44D177C91B500C7B3C9 /* Build configuration list for PBXNativeTarget "ReactiveCocoa-iOS-UIKitTestHostTests" */; + buildPhases = ( + 1860F42B177C91B500C7B3C9 /* Sources */, + 1860F42C177C91B500C7B3C9 /* Frameworks */, + 1860F42D177C91B500C7B3C9 /* Resources */, + ); + buildRules = ( + ); + dependencies = ( + 1860F436177C91B500C7B3C9 /* PBXTargetDependency */, + ); + name = "ReactiveCocoa-iOS-UIKitTestHostTests"; + productName = "ReactiveCocoa-iOS-UIKitTestHostTests"; + productReference = 1860F430177C91B500C7B3C9 /* ReactiveCocoa-iOS-UIKitTestHostTests.octest */; + productType = "com.apple.product-type.bundle"; + }; + 5FAF5222174D4C2000CAC810 /* ReactiveCocoaTests-iOS */ = { + isa = PBXNativeTarget; + buildConfigurationList = 5FAF523D174D4C2000CAC810 /* Build configuration list for PBXNativeTarget "ReactiveCocoaTests-iOS" */; + buildPhases = ( + 5FAF521E174D4C2000CAC810 /* Sources */, + 5FAF521F174D4C2000CAC810 /* Frameworks */, + 5FAF5220174D4C2000CAC810 /* Resources */, + ); + buildRules = ( + ); + dependencies = ( + D0ED9DB617501806003859A6 /* PBXTargetDependency */, + ); + name = "ReactiveCocoaTests-iOS"; + productName = "ReactiveCocoaTests-iOS"; + productReference = 5FAF5223174D4C2000CAC810 /* ReactiveCocoaTests-iOS.octest */; + productType = "com.apple.product-type.bundle"; + }; + 88037F8215056328001A5B19 /* ReactiveCocoa */ = { + isa = PBXNativeTarget; + buildConfigurationList = 88037F8F15056328001A5B19 /* Build configuration list for PBXNativeTarget "ReactiveCocoa" */; + buildPhases = ( + 88037F7E15056328001A5B19 /* Sources */, + 88037F7F15056328001A5B19 /* Frameworks */, + 88037F8015056328001A5B19 /* Headers */, + 88037F8115056328001A5B19 /* Resources */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = ReactiveCocoa; + productName = ReactiveCocoa; + productReference = 88037F8315056328001A5B19 /* ReactiveCocoa.framework */; + productType = "com.apple.product-type.framework"; + }; + 88CDF7DB15000FCF00163A9F /* ReactiveCocoaTests */ = { + isa = PBXNativeTarget; + buildConfigurationList = 88CDF7F015000FCF00163A9F /* Build configuration list for PBXNativeTarget "ReactiveCocoaTests" */; + buildPhases = ( + 88CDF7D715000FCF00163A9F /* Sources */, + 88CDF7D815000FCF00163A9F /* Frameworks */, + 88CDF7D915000FCF00163A9F /* Resources */, + 8820937F1501C94E00796685 /* Copy Frameworks */, + ); + buildRules = ( + ); + dependencies = ( + 88037FDB150564E9001A5B19 /* PBXTargetDependency */, + ); + name = ReactiveCocoaTests; + productName = GHObservableTests; + productReference = 88CDF7DC15000FCF00163A9F /* ReactiveCocoaTests.octest */; + productType = "com.apple.product-type.bundle"; + }; + 88F440AA153DAC820097B4C3 /* ReactiveCocoa-iOS */ = { + isa = PBXNativeTarget; + buildConfigurationList = 88F440B3153DAC820097B4C3 /* Build configuration list for PBXNativeTarget "ReactiveCocoa-iOS" */; + buildPhases = ( + 88F440A7153DAC820097B4C3 /* Sources */, + 88F440A8153DAC820097B4C3 /* Frameworks */, + 88F440A9153DAC820097B4C3 /* Headers */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = "ReactiveCocoa-iOS"; + productName = ReactiveCocoaLib; + productReference = 88F440AB153DAC820097B4C3 /* libReactiveCocoa-iOS.a */; + productType = "com.apple.product-type.library.static"; + }; + D05AD39317F2D56F0080895B /* ReactiveCocoa-Mac */ = { + isa = PBXNativeTarget; + buildConfigurationList = D05AD3BD17F2D5710080895B /* Build configuration list for PBXNativeTarget "ReactiveCocoa-Mac" */; + buildPhases = ( + D05AD39017F2D56F0080895B /* Sources */, + D05AD39117F2D56F0080895B /* Frameworks */, + D05AD39217F2D56F0080895B /* Headers */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = "ReactiveCocoa-Mac"; + productName = "ReactiveCocoa-Mac"; + productReference = D05AD39417F2D56F0080895B /* libReactiveCocoa-Mac.a */; + productType = "com.apple.product-type.library.static"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 88CDF7B215000FCE00163A9F /* Project object */ = { + isa = PBXProject; + attributes = { + CLASSPREFIX = RAC; + LastUpgradeCheck = 0500; + ORGANIZATIONNAME = "GitHub, Inc."; + }; + buildConfigurationList = 88CDF7B515000FCE00163A9F /* Build configuration list for PBXProject "ReactiveCocoa" */; + compatibilityVersion = "Xcode 3.2"; + developmentRegion = English; + hasScannedForEncodings = 0; + knownRegions = ( + en, + ); + mainGroup = 88CDF7B015000FCE00163A9F; + productRefGroup = 88CDF7BC15000FCE00163A9F /* Products */; + projectDirPath = ""; + projectRoot = ""; + targets = ( + 88037F8215056328001A5B19 /* ReactiveCocoa */, + 88F440AA153DAC820097B4C3 /* ReactiveCocoa-iOS */, + 88CDF7DB15000FCF00163A9F /* ReactiveCocoaTests */, + 5FAF5222174D4C2000CAC810 /* ReactiveCocoaTests-iOS */, + 1860F411177C91B500C7B3C9 /* ReactiveCocoa-iOS-UIKitTestHost */, + 1860F42F177C91B500C7B3C9 /* ReactiveCocoa-iOS-UIKitTestHostTests */, + D05AD39317F2D56F0080895B /* ReactiveCocoa-Mac */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXResourcesBuildPhase section */ + 1860F410177C91B500C7B3C9 /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 1860F41E177C91B500C7B3C9 /* InfoPlist.strings in Resources */, + 1860F426177C91B500C7B3C9 /* Default.png in Resources */, + 1860F428177C91B500C7B3C9 /* Default@2x.png in Resources */, + 1860F42A177C91B500C7B3C9 /* Default-568h@2x.png in Resources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 1860F42D177C91B500C7B3C9 /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 1860F43C177C91B500C7B3C9 /* InfoPlist.strings in Resources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 5FAF5220174D4C2000CAC810 /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + D090768E17FBED2E00EB087A /* test-data.json in Resources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 88037F8115056328001A5B19 /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 88CDF7D915000FCF00163A9F /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + D090768D17FBED2E00EB087A /* test-data.json in Resources */, + 88CDF7E715000FCF00163A9F /* InfoPlist.strings in Resources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXResourcesBuildPhase section */ + +/* Begin PBXSourcesBuildPhase section */ + 1860F40E177C91B500C7B3C9 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + CD11C6FF18714F00007C7CFD /* RACTestTableViewController.m in Sources */, + 1860F420177C91B500C7B3C9 /* main.m in Sources */, + 1860F424177C91B500C7B3C9 /* RACAppDelegate.m in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 1860F42B177C91B500C7B3C9 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + CD11C700187151AE007C7CFD /* UITableViewHeaderFooterViewRACSupportSpec.m in Sources */, + 1668028317FE775200C724B4 /* UICollectionReusableViewRACSupportSpec.m in Sources */, + 5564537F18107203002BD2E4 /* RACControlCommandExamples.m in Sources */, + D0F117CC179F0B97006CE68F /* UITableViewCellRACSupportSpec.m in Sources */, + 1860F44F177C958300C7B3C9 /* UITextFieldRACSupportSpec.m in Sources */, + 1860F450177C958900C7B3C9 /* UITextViewRACSupportSpec.m in Sources */, + D004BC9C177E1A2B00A5B8C5 /* UIActionSheetRACSupportSpec.m in Sources */, + 5564542418107275002BD2E4 /* UIRefreshControlRACSupportSpec.m in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 5FAF521E174D4C2000CAC810 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 5FAF523E174D4D3200CAC810 /* NSEnumeratorRACSequenceAdditionsSpec.m in Sources */, + 5FAF523F174D4D3600CAC810 /* NSNotificationCenterRACSupportSpec.m in Sources */, + D090768B17FBECBF00EB087A /* NSURLConnectionRACSupportSpec.m in Sources */, + 5FAF5240174D4D5600CAC810 /* NSObjectRACDeallocatingSpec.m in Sources */, + 5FAF5241174D4D5600CAC810 /* NSObjectRACLiftingSpec.m in Sources */, + 5FAF5242174D4D5600CAC810 /* NSObjectRACPropertySubscribingExamples.m in Sources */, + 5FAF5243174D4D5600CAC810 /* NSObjectRACPropertySubscribingSpec.m in Sources */, + 5FAF5244174D4D5600CAC810 /* NSStringRACKeyPathUtilitiesSpec.m in Sources */, + 5FAF5246174D4D5600CAC810 /* RACBacktraceSpec.m in Sources */, + 5FAF5247174D4D5600CAC810 /* RACBlockTrampolineSpec.m in Sources */, + 5FAF5248174D4D5600CAC810 /* RACCommandSpec.m in Sources */, + 5FAF5249174D4D5600CAC810 /* RACCompoundDisposableSpec.m in Sources */, + BE527EA01863706B006349E8 /* NSUserDefaultsRACSupportSpec.m in Sources */, + 5FAF524A174D4D5600CAC810 /* RACEventSpec.m in Sources */, + 5FAF524B174D4D5600CAC810 /* RACKVOWrapperSpec.m in Sources */, + 5FAF524C174D4D5600CAC810 /* RACMulticastConnectionSpec.m in Sources */, + 5FAF524D174D4D5600CAC810 /* RACKVOChannelSpec.m in Sources */, + 5FAF524E174D4D5600CAC810 /* RACPropertySignalExamples.m in Sources */, + 5FAF524F174D4D5600CAC810 /* RACChannelExamples.m in Sources */, + 5FAF5250174D4D5600CAC810 /* RACChannelSpec.m in Sources */, + 5FAF5251174D4D5600CAC810 /* RACSchedulerSpec.m in Sources */, + 5FAF5252174D4D5600CAC810 /* RACSequenceAdditionsSpec.m in Sources */, + 5FAF5253174D4D5600CAC810 /* RACSequenceExamples.m in Sources */, + 5FAF5254174D4D5600CAC810 /* RACSequenceSpec.m in Sources */, + 5FAF5255174D4D5600CAC810 /* RACSignalSpec.m in Sources */, + 5FAF5256174D4D5600CAC810 /* RACStreamExamples.m in Sources */, + 5FAF5257174D4D5600CAC810 /* RACSubjectSpec.m in Sources */, + 5FAF5258174D4D5600CAC810 /* RACSubscriberExamples.m in Sources */, + 5FAF5259174D4D5600CAC810 /* RACSubscriberSpec.m in Sources */, + AC65FD52176DECB1005ED22B /* UIAlertViewRACSupportSpec.m in Sources */, + 5FAF525A174D4D5600CAC810 /* RACSubscriptingAssignmentTrampolineSpec.m in Sources */, + 5FAF525B174D4D5600CAC810 /* RACTestObject.m in Sources */, + 5FAF525C174D4D5600CAC810 /* RACTupleSpec.m in Sources */, + 5FAF525D174D4D5600CAC810 /* NSObjectRACSelectorSignalSpec.m in Sources */, + 5FAF525E174D4D5600CAC810 /* RACSubclassObject.m in Sources */, + 5FAF5262174D4D8F00CAC810 /* UIBarButtonItemRACSupportSpec.m in Sources */, + 88302BFE1762A9E6003633BD /* RACTestExampleScheduler.m in Sources */, + 8884DD6B1756B65300F6C379 /* RACSignalStartExamples.m in Sources */, + D028DB7E179E591E00D1042F /* RACSerialDisposableSpec.m in Sources */, + 5EE9A79B1760D88500EAF5A2 /* UIButtonRACSupportSpec.m in Sources */, + 88302C2F1762C180003633BD /* RACTargetQueueSchedulerSpec.m in Sources */, + D0A0E227176A84DB007273ED /* RACDisposableSpec.m in Sources */, + D066C796176D262500C242D2 /* UIControlRACSupportSpec.m in Sources */, + D066C79D176D263D00C242D2 /* RACTestUIButton.m in Sources */, + D0C55CE217759559008CDDCA /* RACDelegateProxySpec.m in Sources */, + D07200261788C57200987F70 /* RACTestSchedulerSpec.m in Sources */, + D075A72B17BCB7E100C24FB7 /* RACControlCommandExamples.m in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 88037F7E15056328001A5B19 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 88A0B6D2165B2B09005DE8F3 /* RACBlockTrampoline.m in Sources */, + 88037FC71505647E001A5B19 /* NSObject+RACKVOWrapper.m in Sources */, + 88037FC91505648C001A5B19 /* RACSubscriber.m in Sources */, + 88037FCC1505648C001A5B19 /* RACCommand.m in Sources */, + 88037FCD1505648C001A5B19 /* NSControl+RACCommandSupport.m in Sources */, + D090768217FBEADE00EB087A /* NSURLConnection+RACSupport.m in Sources */, + 88DA309815071CBA00C19D0F /* RACValueTransformer.m in Sources */, + 880B9177150B09190008488E /* RACSubject.m in Sources */, + 88D4AB3F1510F6C30011494F /* RACReplaySubject.m in Sources */, + 88977C3E1512914A00A09EC5 /* RACSignal.m in Sources */, + 883A84DB1513964B006DB4C7 /* RACBehaviorSubject.m in Sources */, + 883A84E01513B5EC006DB4C7 /* RACDisposable.m in Sources */, + 886678711518DCD800DE77EC /* NSObject+RACPropertySubscribing.m in Sources */, + 881B37CD152260BF0079220B /* RACUnit.m in Sources */, + 884476E5152367D100958F44 /* RACScopedDisposable.m in Sources */, + 88B76F8F153726B00053EAE2 /* RACTuple.m in Sources */, + 88E2C6B5153C771C00C7493C /* RACScheduler.m in Sources */, + 88F440D4153DADEA0097B4C3 /* NSObject+RACAppKitBindings.m in Sources */, + 886F702B1551CF920045D68B /* RACGroupedSignal.m in Sources */, + A1FCC374156754A7008C9686 /* RACObjCRuntime.m in Sources */, + BE527E9618636F7F006349E8 /* NSUserDefaults+RACSupport.m in Sources */, + D0DFBCCE15DD6D40009DADB3 /* RACBacktrace.m in Sources */, + D0D910D015F915BD00AD2DDA /* RACSignal+Operations.m in Sources */, + 88FC735716114F9C00F8A774 /* RACSubscriptingAssignmentTrampoline.m in Sources */, + 886CEAE4163DE942007632D1 /* NSObject+RACLifting.m in Sources */, + D013A3E11807B7450072B6CE /* RACEmptySignal.m in Sources */, + 887ACDA9165878A8009190AD /* NSInvocation+RACTypeParsing.m in Sources */, + D0E9676D1641EF9C00FCFF06 /* NSArray+RACSequenceAdditions.m in Sources */, + D0E967711641EF9C00FCFF06 /* NSDictionary+RACSequenceAdditions.m in Sources */, + D0E967751641EF9C00FCFF06 /* NSOrderedSet+RACSequenceAdditions.m in Sources */, + D0E967791641EF9C00FCFF06 /* NSSet+RACSequenceAdditions.m in Sources */, + D0E9677D1641EF9C00FCFF06 /* NSString+RACSequenceAdditions.m in Sources */, + D0E967811641EF9C00FCFF06 /* RACArraySequence.m in Sources */, + D0E967851641EF9C00FCFF06 /* RACDynamicSequence.m in Sources */, + D0E967891641EF9C00FCFF06 /* RACEmptySequence.m in Sources */, + D03525D417E2EBC90099CBAB /* RACSignalProvider.d in Sources */, + D028DB76179E53CB00D1042F /* RACSerialDisposable.m in Sources */, + D0E9678D1641EF9C00FCFF06 /* RACSequence.m in Sources */, + D0E967911641EF9C00FCFF06 /* RACStringSequence.m in Sources */, + D0D487031642550100DD7605 /* RACStream.m in Sources */, + D0EE284D164D906B006954A4 /* RACSignalSequence.m in Sources */, + 881E86A41669304800667F7B /* RACCompoundDisposable.m in Sources */, + 881E87AE16695C5600667F7B /* RACQueueScheduler.m in Sources */, + 881E87B416695EDF00667F7B /* RACImmediateScheduler.m in Sources */, + 881E87C61669636000667F7B /* RACSubscriptionScheduler.m in Sources */, + 5F45A887168CFA3E00B58A2B /* RACKVOChannel.m in Sources */, + 5F6FE8551692568A00A8D7A6 /* RACChannel.m in Sources */, + 88C5A026169246140045EF05 /* RACMulticastConnection.m in Sources */, + 5F9743F91694A2460024EB82 /* RACEagerSequence.m in Sources */, + 5F773DEC169B46670023069D /* NSEnumerator+RACSequenceAdditions.m in Sources */, + D077A16F169B740200057BB1 /* RACEvent.m in Sources */, + 8837EA1816A5A33300FC3CDF /* RACKVOTrampoline.m in Sources */, + D0A0B01616EAA3D100C47593 /* NSText+RACSignalSupport.m in Sources */, + D020F3DB17F6A3E40092BED2 /* RACCompoundDisposableProvider.d in Sources */, + D0A0B03C16EAA9AC00C47593 /* NSControl+RACTextSignalSupport.m in Sources */, + D013A3E91807B7C30072B6CE /* RACReturnSignal.m in Sources */, + 6E58405616F22D7500F588A6 /* NSObject+RACDeallocating.m in Sources */, + 880D7A5C16F7B351004A3361 /* NSObject+RACSelectorSignal.m in Sources */, + D0307EDF1731AAE100D83211 /* RACTupleSequence.m in Sources */, + D07CD7181731BA3900DE2394 /* RACUnarySequence.m in Sources */, + 5FDC35051736F54700792E52 /* NSString+RACKeyPathUtilities.m in Sources */, + D0D243BD1741FA13004359C6 /* NSObject+RACDescription.m in Sources */, + 882D071A17614FA7009EDA69 /* RACTargetQueueScheduler.m in Sources */, + 74F1731B186024A900BC937C /* NSIndexSet+RACSequenceAdditions.m in Sources */, + D0A0E230176A8CD6007273ED /* RACPassthroughSubscriber.m in Sources */, + D013A3D91807B5ED0072B6CE /* RACErrorSignal.m in Sources */, + 7479F6E8186177D200575CDB /* RACIndexSetSequence.m in Sources */, + D05F9D3717984EC000FD7982 /* EXTRuntimeExtensions.m in Sources */, + D009307B1788AB7B00EE7E8B /* RACTestScheduler.m in Sources */, + 55C39DE417F1EC6E006DC60C /* NSData+RACSupport.m in Sources */, + 55C39DE517F1EC6E006DC60C /* NSFileHandle+RACSupport.m in Sources */, + 55C39DE617F1EC6E006DC60C /* NSNotificationCenter+RACSupport.m in Sources */, + D013A3F21807B9690072B6CE /* RACDynamicSignal.m in Sources */, + 55C39DE717F1EC6E006DC60C /* NSString+RACSupport.m in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 88CDF7D715000FCF00163A9F /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 8820937C1501C8A600796685 /* RACSignalSpec.m in Sources */, + 889D0A8015974B2A00F833E3 /* RACSubjectSpec.m in Sources */, + D041376915D2281C004BBF80 /* RACKVOWrapperSpec.m in Sources */, + D028DB7D179E591E00D1042F /* RACSerialDisposableSpec.m in Sources */, + 882CCA1E15F1564D00937D6E /* RACCommandSpec.m in Sources */, + 884848B615F658B800B11BD0 /* NSControlRACSupportSpec.m in Sources */, + 88442A341608A9AD00636B49 /* RACTestObject.m in Sources */, + 88FC735B16114FFB00F8A774 /* RACSubscriptingAssignmentTrampolineSpec.m in Sources */, + 8851A38B16161D500050D47F /* NSObjectRACPropertySubscribingSpec.m in Sources */, + D0D487061642651400DD7605 /* RACSequenceSpec.m in Sources */, + D0487AB3164314430085D890 /* RACStreamExamples.m in Sources */, + D0C70F90164337A2007027B4 /* RACSequenceAdditionsSpec.m in Sources */, + D0C70F93164337E3007027B4 /* RACSequenceExamples.m in Sources */, + 886CEACD163DE669007632D1 /* RACBlockTrampolineSpec.m in Sources */, + 8801E7511644BDE200A155FE /* NSObjectRACLiftingSpec.m in Sources */, + D0C70EC616659333005AAD03 /* RACSubscriberExamples.m in Sources */, + D090768A17FBECBF00EB087A /* NSURLConnectionRACSupportSpec.m in Sources */, + D0C70EC8166595AD005AAD03 /* RACSubscriberSpec.m in Sources */, + 8803C011166732BA00C36839 /* RACSchedulerSpec.m in Sources */, + 881E86BA1669350B00667F7B /* RACCompoundDisposableSpec.m in Sources */, + D0700F4C1672994D00D7CD30 /* NSNotificationCenterRACSupportSpec.m in Sources */, + 5F2447AD167E87C50062180C /* RACKVOChannelSpec.m in Sources */, + D02221621678910900DBD031 /* RACTupleSpec.m in Sources */, + 5F7EFECF168FBC4B0037E500 /* RACChannelExamples.m in Sources */, + 5F7EFED0168FBC4B0037E500 /* RACChannelSpec.m in Sources */, + D0870C6F16884A0600D0E11D /* RACBacktraceSpec.m in Sources */, + 88C5A02916924BFC0045EF05 /* RACMulticastConnectionSpec.m in Sources */, + D0EDE76716968AB10072A780 /* RACPropertySignalExamples.m in Sources */, + BE527E9F1863705B006349E8 /* NSUserDefaultsRACSupportSpec.m in Sources */, + 5F773DF0169B48830023069D /* NSEnumeratorRACSequenceAdditionsSpec.m in Sources */, + D077A172169B79A900057BB1 /* RACEventSpec.m in Sources */, + D0A0B01816EAA5CC00C47593 /* NSTextRACSupportSpec.m in Sources */, + 6E58405F16F3414200F588A6 /* NSObjectRACDeallocatingSpec.m in Sources */, + 1E893381171647A5009071B0 /* NSObjectRACPropertySubscribingExamples.m in Sources */, + 880D7A6616F7BB1A004A3361 /* NSObjectRACSelectorSignalSpec.m in Sources */, + 880D7A6916F7BCC7004A3361 /* RACSubclassObject.m in Sources */, + 5FDC350F1736F81900792E52 /* NSStringRACKeyPathUtilitiesSpec.m in Sources */, + D075A72A17BCB7E100C24FB7 /* RACControlCommandExamples.m in Sources */, + 88302BFD1762A9E6003633BD /* RACTestExampleScheduler.m in Sources */, + 4925E806181BCC71000B2FEE /* NSControllerRACSupportSpec.m in Sources */, + 8884DD651756ACF600F6C379 /* RACSignalStartExamples.m in Sources */, + 88302C2E1762C180003633BD /* RACTargetQueueSchedulerSpec.m in Sources */, + D0A0E226176A84DB007273ED /* RACDisposableSpec.m in Sources */, + D011F9D01782AFD400EE7E38 /* NSObjectRACAppKitBindingsSpec.m in Sources */, + D07200251788C57200987F70 /* RACTestSchedulerSpec.m in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 88F440A7153DAC820097B4C3 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 27A887D11703DC6800040001 /* UIBarButtonItem+RACCommandSupport.m in Sources */, + 8882D4601673B0450080E7CD /* RACBlockTrampoline.m in Sources */, + 88F440BA153DAD570097B4C3 /* RACCommand.m in Sources */, + 88F440BC153DAD5A0097B4C3 /* RACSubscriber.m in Sources */, + 88F440BD153DAD5C0097B4C3 /* RACSignal.m in Sources */, + 88F440CF153DAD850097B4C3 /* NSObject+RACPropertySubscribing.m in Sources */, + ACB0EAF31797DDD400942FFC /* UIAlertView+RACSignalSupport.m in Sources */, + 88F440CE153DAD830097B4C3 /* NSObject+RACKVOWrapper.m in Sources */, + 88F440C1153DAD640097B4C3 /* RACReplaySubject.m in Sources */, + 88F440C0153DAD630097B4C3 /* RACSubject.m in Sources */, + 88F440C6153DAD6E0097B4C3 /* RACScopedDisposable.m in Sources */, + 88F440C3153DAD690097B4C3 /* RACBehaviorSubject.m in Sources */, + 88F440C9153DAD740097B4C3 /* RACUnit.m in Sources */, + 88F440CB153DAD780097B4C3 /* RACScheduler.m in Sources */, + 88F440CA153DAD760097B4C3 /* RACTuple.m in Sources */, + 88F440C5153DAD6C0097B4C3 /* RACDisposable.m in Sources */, + D090768317FBEADE00EB087A /* NSURLConnection+RACSupport.m in Sources */, + 88F44263153DC2C70097B4C3 /* UIControl+RACSignalSupport.m in Sources */, + 886F702C1551CF9D0045D68B /* RACGroupedSignal.m in Sources */, + 88F44267153DCAC50097B4C3 /* UITextField+RACSignalSupport.m in Sources */, + A1FCC27715666AA3008C9686 /* UITextView+RACSignalSupport.m in Sources */, + D03525D917E2FAAD0099CBAB /* RACSignalProvider.d in Sources */, + A1FCC375156754A7008C9686 /* RACObjCRuntime.m in Sources */, + A1FCC37B1567DED0008C9686 /* RACDelegateProxy.m in Sources */, + D0DFBCCF15DD6D40009DADB3 /* RACBacktrace.m in Sources */, + D0D910D115F915BD00AD2DDA /* RACSignal+Operations.m in Sources */, + 88FC735816114F9C00F8A774 /* RACSubscriptingAssignmentTrampoline.m in Sources */, + CD11C6F418714CD0007C7CFD /* UITableViewHeaderFooterView+RACSignalSupport.m in Sources */, + 886CEAE5163DE942007632D1 /* NSObject+RACLifting.m in Sources */, + 887ACDAA165878A8009190AD /* NSInvocation+RACTypeParsing.m in Sources */, + D0E9676E1641EF9C00FCFF06 /* NSArray+RACSequenceAdditions.m in Sources */, + D013A3E21807B7450072B6CE /* RACEmptySignal.m in Sources */, + D0E967721641EF9C00FCFF06 /* NSDictionary+RACSequenceAdditions.m in Sources */, + D0E967761641EF9C00FCFF06 /* NSOrderedSet+RACSequenceAdditions.m in Sources */, + D0E9677A1641EF9C00FCFF06 /* NSSet+RACSequenceAdditions.m in Sources */, + D0E9677E1641EF9C00FCFF06 /* NSString+RACSequenceAdditions.m in Sources */, + D0E967821641EF9C00FCFF06 /* RACArraySequence.m in Sources */, + D0E967861641EF9C00FCFF06 /* RACDynamicSequence.m in Sources */, + D028DB88179E616700D1042F /* UITableViewCell+RACSignalSupport.m in Sources */, + BE527E9718636F7F006349E8 /* NSUserDefaults+RACSupport.m in Sources */, + D0E9678A1641EF9C00FCFF06 /* RACEmptySequence.m in Sources */, + D0E9678E1641EF9C00FCFF06 /* RACSequence.m in Sources */, + D0E967921641EF9C00FCFF06 /* RACStringSequence.m in Sources */, + D013A3F31807B9690072B6CE /* RACDynamicSignal.m in Sources */, + D0D487041642550100DD7605 /* RACStream.m in Sources */, + D013A3DA1807B5ED0072B6CE /* RACErrorSignal.m in Sources */, + D0EE284E164D906B006954A4 /* RACSignalSequence.m in Sources */, + 74F1731C186024A900BC937C /* NSIndexSet+RACSequenceAdditions.m in Sources */, + 881E86A51669304800667F7B /* RACCompoundDisposable.m in Sources */, + 881E87AF16695C5600667F7B /* RACQueueScheduler.m in Sources */, + 881E87B516695EDF00667F7B /* RACImmediateScheduler.m in Sources */, + 1668028017FE75F900C724B4 /* UICollectionReusableView+RACSignalSupport.m in Sources */, + 881E87C71669636000667F7B /* RACSubscriptionScheduler.m in Sources */, + 5F45A888168CFA3E00B58A2B /* RACKVOChannel.m in Sources */, + D028DB77179E53CB00D1042F /* RACSerialDisposable.m in Sources */, + 5F6FE8561692568A00A8D7A6 /* RACChannel.m in Sources */, + 88C5A027169246140045EF05 /* RACMulticastConnection.m in Sources */, + 5F9743FA1694A2460024EB82 /* RACEagerSequence.m in Sources */, + 5F773DED169B46670023069D /* NSEnumerator+RACSequenceAdditions.m in Sources */, + D077A170169B740200057BB1 /* RACEvent.m in Sources */, + 8837EA1916A5A33300FC3CDF /* RACKVOTrampoline.m in Sources */, + 6E58405D16F22F7800F588A6 /* NSObject+RACDeallocating.m in Sources */, + 880D7A5D16F7B351004A3361 /* NSObject+RACSelectorSignal.m in Sources */, + D0307EE01731AAE100D83211 /* RACTupleSequence.m in Sources */, + D07CD7191731BA3900DE2394 /* RACUnarySequence.m in Sources */, + 554D9E5E181064E200F21262 /* UIRefreshControl+RACCommandSupport.m in Sources */, + 1EC06B18173CB04000365258 /* UIGestureRecognizer+RACSignalSupport.m in Sources */, + 5FDC35061736F54700792E52 /* NSString+RACKeyPathUtilities.m in Sources */, + D0D243BE1741FA13004359C6 /* NSObject+RACDescription.m in Sources */, + 5EE9A7941760D61300EAF5A2 /* UIButton+RACCommandSupport.m in Sources */, + 882D071F17615139009EDA69 /* RACTargetQueueScheduler.m in Sources */, + D0A0E231176A8CD6007273ED /* RACPassthroughSubscriber.m in Sources */, + 557A4B5B177648C7008EF796 /* UIActionSheet+RACSignalSupport.m in Sources */, + D05F9D3817984EC000FD7982 /* EXTRuntimeExtensions.m in Sources */, + D009307C1788AB7B00EE7E8B /* RACTestScheduler.m in Sources */, + 5F70B2B017AB1829009AEDF9 /* UIDatePicker+RACSignalSupport.m in Sources */, + 5F70B2BF17AB1857009AEDF9 /* UISegmentedControl+RACSignalSupport.m in Sources */, + 5F70B2C117AB1857009AEDF9 /* UISlider+RACSignalSupport.m in Sources */, + 5F70B2C317AB1857009AEDF9 /* UIStepper+RACSignalSupport.m in Sources */, + 5F70B2C517AB1857009AEDF9 /* UISwitch+RACSignalSupport.m in Sources */, + 5F016DF717B10AA8002EEC69 /* UIControl+RACSignalSupportPrivate.m in Sources */, + D013A3EA1807B7C30072B6CE /* RACReturnSignal.m in Sources */, + D020F3DC17F6A3E40092BED2 /* RACCompoundDisposableProvider.d in Sources */, + 7479F6E9186177D200575CDB /* RACIndexSetSequence.m in Sources */, + 55C39DE817F1EC6E006DC60C /* NSData+RACSupport.m in Sources */, + 55C39DE917F1EC6E006DC60C /* NSFileHandle+RACSupport.m in Sources */, + 55C39DEA17F1EC6E006DC60C /* NSNotificationCenter+RACSupport.m in Sources */, + 55C39DEB17F1EC6E006DC60C /* NSString+RACSupport.m in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + D05AD39017F2D56F0080895B /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + D05AD3CF17F2DB100080895B /* NSInvocation+RACTypeParsing.m in Sources */, + D05AD3F117F2DB4F0080895B /* RACDynamicSequence.m in Sources */, + D05AD3F517F2DB4F0080895B /* RACSignalSequence.m in Sources */, + D05AD3C217F2DB100080895B /* RACBlockTrampoline.m in Sources */, + D05AD41917F2DB6A0080895B /* NSSet+RACSequenceAdditions.m in Sources */, + D090768417FBEADE00EB087A /* NSURLConnection+RACSupport.m in Sources */, + D05AD3CE17F2DB100080895B /* NSObject+RACLifting.m in Sources */, + D05AD3FE17F2DB5D0080895B /* RACQueueScheduler.m in Sources */, + D05AD42517F2DB6E0080895B /* NSText+RACSignalSupport.m in Sources */, + D05AD43017F2DB840080895B /* RACValueTransformer.m in Sources */, + D070CBC517FB5E370017F121 /* RACCompoundDisposableProvider.d in Sources */, + D05AD3F217F2DB4F0080895B /* RACEagerSequence.m in Sources */, + D05AD3F617F2DB4F0080895B /* RACTupleSequence.m in Sources */, + D05AD3E917F2DB230080895B /* RACSerialDisposable.m in Sources */, + D05AD42117F2DB6E0080895B /* NSControl+RACTextSignalSupport.m in Sources */, + D05AD40E17F2DB6A0080895B /* NSEnumerator+RACSequenceAdditions.m in Sources */, + D05AD41B17F2DB6A0080895B /* NSString+RACSequenceAdditions.m in Sources */, + D05AD43217F2DBCA0080895B /* RACSignalProvider.d in Sources */, + D05AD42D17F2DB840080895B /* RACKVOTrampoline.m in Sources */, + D05AD3D517F2DB1D0080895B /* RACSignal+Operations.m in Sources */, + BE527E9818636F7F006349E8 /* NSUserDefaults+RACSupport.m in Sources */, + D05AD41317F2DB6A0080895B /* NSObject+RACDescription.m in Sources */, + D05AD3CA17F2DB100080895B /* RACSubscriptingAssignmentTrampoline.m in Sources */, + D05AD3E717F2DB230080895B /* RACCompoundDisposable.m in Sources */, + D05AD3DD17F2DB1D0080895B /* RACSubject.m in Sources */, + D013A3E31807B7450072B6CE /* RACEmptySignal.m in Sources */, + D05AD3F417F2DB4F0080895B /* RACStringSequence.m in Sources */, + D05AD40C17F2DB6A0080895B /* NSDictionary+RACSequenceAdditions.m in Sources */, + D05AD41F17F2DB6E0080895B /* NSControl+RACCommandSupport.m in Sources */, + D05AD41517F2DB6A0080895B /* NSObject+RACSelectorSignal.m in Sources */, + D05AD3C817F2DB100080895B /* RACBacktrace.m in Sources */, + D05AD41217F2DB6A0080895B /* NSNotificationCenter+RACSupport.m in Sources */, + D05AD3D917F2DB1D0080895B /* RACMulticastConnection.m in Sources */, + D05AD43117F2DB950080895B /* RACObjCRuntime.m in Sources */, + D05AD3DB17F2DB1D0080895B /* RACGroupedSignal.m in Sources */, + D05AD3F017F2DB4F0080895B /* RACArraySequence.m in Sources */, + D05AD3E517F2DB230080895B /* RACScopedDisposable.m in Sources */, + D05AD40417F2DB5D0080895B /* RACSubscriptionScheduler.m in Sources */, + D05AD42917F2DB840080895B /* RACKVOChannel.m in Sources */, + D05AD42C17F2DB840080895B /* NSString+RACKeyPathUtilities.m in Sources */, + D05AD42717F2DB840080895B /* RACChannel.m in Sources */, + D05AD3FB17F2DB5D0080895B /* RACScheduler.m in Sources */, + D05AD3EB17F2DB270080895B /* RACCommand.m in Sources */, + D05AD3D117F2DB100080895B /* RACStream.m in Sources */, + D05AD3F717F2DB4F0080895B /* RACUnarySequence.m in Sources */, + D05AD3D317F2DB1D0080895B /* RACSignal.m in Sources */, + D05AD42F17F2DB840080895B /* NSObject+RACPropertySubscribing.m in Sources */, + D05AD3F317F2DB4F0080895B /* RACEmptySequence.m in Sources */, + D05AD42317F2DB6E0080895B /* NSObject+RACAppKitBindings.m in Sources */, + D05AD40817F2DB6A0080895B /* NSArray+RACSequenceAdditions.m in Sources */, + D05AD40017F2DB5D0080895B /* RACTargetQueueScheduler.m in Sources */, + D05AD41717F2DB6A0080895B /* NSOrderedSet+RACSequenceAdditions.m in Sources */, + D05AD40617F2DB5D0080895B /* RACTestScheduler.m in Sources */, + D05AD3EF17F2DB4F0080895B /* RACSequence.m in Sources */, + D05AD3BF17F2DA2A0080895B /* RACSubscriber.m in Sources */, + D013A3EB1807B7C30072B6CE /* RACReturnSignal.m in Sources */, + D05AD3DF17F2DB1D0080895B /* RACReplaySubject.m in Sources */, + D05AD3C417F2DB100080895B /* RACUnit.m in Sources */, + D05AD41017F2DB6A0080895B /* NSFileHandle+RACSupport.m in Sources */, + D05AD41D17F2DB6A0080895B /* NSString+RACSupport.m in Sources */, + D05AD3E317F2DB230080895B /* RACDisposable.m in Sources */, + D05AD40217F2DB5D0080895B /* RACImmediateScheduler.m in Sources */, + D05AD3CC17F2DB100080895B /* NSObject+RACDeallocating.m in Sources */, + 74F1731D186024A900BC937C /* NSIndexSet+RACSequenceAdditions.m in Sources */, + D05AD40A17F2DB6A0080895B /* NSData+RACSupport.m in Sources */, + D013A3DB1807B5ED0072B6CE /* RACErrorSignal.m in Sources */, + 7479F6EA186177D200575CDB /* RACIndexSetSequence.m in Sources */, + D05AD42B17F2DB840080895B /* NSObject+RACKVOWrapper.m in Sources */, + D05AD3E117F2DB1D0080895B /* RACBehaviorSubject.m in Sources */, + D05AD3D717F2DB1D0080895B /* RACEvent.m in Sources */, + D05AD3C117F2DB100080895B /* RACPassthroughSubscriber.m in Sources */, + D05AD3C617F2DB100080895B /* RACTuple.m in Sources */, + D013A3F41807B9690072B6CE /* RACDynamicSignal.m in Sources */, + D049804217F91F42001EE042 /* EXTRuntimeExtensions.m in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin PBXTargetDependency section */ + 1860F436177C91B500C7B3C9 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + target = 1860F411177C91B500C7B3C9 /* ReactiveCocoa-iOS-UIKitTestHost */; + targetProxy = 1860F435177C91B500C7B3C9 /* PBXContainerItemProxy */; + }; + 88037FDB150564E9001A5B19 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + target = 88037F8215056328001A5B19 /* ReactiveCocoa */; + targetProxy = 88037FDA150564E9001A5B19 /* PBXContainerItemProxy */; + }; + D0ED9DB617501806003859A6 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + target = 88F440AA153DAC820097B4C3 /* ReactiveCocoa-iOS */; + targetProxy = D0ED9DB517501806003859A6 /* PBXContainerItemProxy */; + }; + D0F117C3179F0A91006CE68F /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + target = 88F440AA153DAC820097B4C3 /* ReactiveCocoa-iOS */; + targetProxy = D0F117C2179F0A91006CE68F /* PBXContainerItemProxy */; + }; +/* End PBXTargetDependency section */ + +/* Begin PBXVariantGroup section */ + 1860F41C177C91B500C7B3C9 /* InfoPlist.strings */ = { + isa = PBXVariantGroup; + children = ( + 1860F41D177C91B500C7B3C9 /* en */, + ); + name = InfoPlist.strings; + sourceTree = "<group>"; + }; + 1860F43A177C91B500C7B3C9 /* InfoPlist.strings */ = { + isa = PBXVariantGroup; + children = ( + 1860F43B177C91B500C7B3C9 /* en */, + ); + name = InfoPlist.strings; + sourceTree = "<group>"; + }; + 88CDF7C815000FCE00163A9F /* InfoPlist.strings */ = { + isa = PBXVariantGroup; + children = ( + 88CDF7C915000FCE00163A9F /* en */, + ); + name = InfoPlist.strings; + sourceTree = "<group>"; + }; + 88CDF7E515000FCF00163A9F /* InfoPlist.strings */ = { + isa = PBXVariantGroup; + children = ( + 88CDF7E615000FCF00163A9F /* en */, + ); + name = InfoPlist.strings; + sourceTree = "<group>"; + }; +/* End PBXVariantGroup section */ + +/* Begin XCBuildConfiguration section */ + 1860F440177C91B500C7B3C9 /* Debug */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = D094E45D17775B1000906BF7 /* iOS-Application.xcconfig */; + buildSettings = { + FRAMEWORK_SEARCH_PATHS = ( + "\"$(SDKROOT)/Developer/Library/Frameworks\"", + "\"$(DEVELOPER_LIBRARY_DIR)/Frameworks\"", + ); + GCC_PREFIX_HEADER = "ReactiveCocoaTests/ReactiveCocoaTests-Prefix.pch"; + HEADER_SEARCH_PATHS = ( + "\"$(PROJECT_DIR)/../external/specta/src\"", + "\"$(PROJECT_DIR)/../external/expecta/src\"/**", + "$(inherited)", + ); + INFOPLIST_FILE = "ReactiveCocoaTests/UIKit/UIKitTestHost/ReactiveCocoa-iOS-UIKitTestHost-Info.plist"; + OTHER_LDFLAGS = "-all_load"; + PRODUCT_NAME = "$(TARGET_NAME)"; + WRAPPER_EXTENSION = app; + }; + name = Debug; + }; + 1860F441177C91B500C7B3C9 /* Test */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = D094E45D17775B1000906BF7 /* iOS-Application.xcconfig */; + buildSettings = { + FRAMEWORK_SEARCH_PATHS = ( + "\"$(SDKROOT)/Developer/Library/Frameworks\"", + "\"$(DEVELOPER_LIBRARY_DIR)/Frameworks\"", + ); + GCC_PREFIX_HEADER = "ReactiveCocoaTests/ReactiveCocoaTests-Prefix.pch"; + HEADER_SEARCH_PATHS = ( + "\"$(PROJECT_DIR)/../external/specta/src\"", + "\"$(PROJECT_DIR)/../external/expecta/src\"/**", + "$(inherited)", + ); + INFOPLIST_FILE = "ReactiveCocoaTests/UIKit/UIKitTestHost/ReactiveCocoa-iOS-UIKitTestHost-Info.plist"; + OTHER_LDFLAGS = "-all_load"; + PRODUCT_NAME = "$(TARGET_NAME)"; + WRAPPER_EXTENSION = app; + }; + name = Test; + }; + 1860F442177C91B500C7B3C9 /* Release */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = D094E45D17775B1000906BF7 /* iOS-Application.xcconfig */; + buildSettings = { + FRAMEWORK_SEARCH_PATHS = ( + "\"$(SDKROOT)/Developer/Library/Frameworks\"", + "\"$(DEVELOPER_LIBRARY_DIR)/Frameworks\"", + ); + GCC_PREFIX_HEADER = "ReactiveCocoaTests/ReactiveCocoaTests-Prefix.pch"; + HEADER_SEARCH_PATHS = ( + "\"$(PROJECT_DIR)/../external/specta/src\"", + "\"$(PROJECT_DIR)/../external/expecta/src\"/**", + "$(inherited)", + ); + INFOPLIST_FILE = "ReactiveCocoaTests/UIKit/UIKitTestHost/ReactiveCocoa-iOS-UIKitTestHost-Info.plist"; + OTHER_LDFLAGS = "-all_load"; + PRODUCT_NAME = "$(TARGET_NAME)"; + WRAPPER_EXTENSION = app; + }; + name = Release; + }; + 1860F443177C91B500C7B3C9 /* Profile */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = D094E45D17775B1000906BF7 /* iOS-Application.xcconfig */; + buildSettings = { + FRAMEWORK_SEARCH_PATHS = ( + "\"$(SDKROOT)/Developer/Library/Frameworks\"", + "\"$(DEVELOPER_LIBRARY_DIR)/Frameworks\"", + ); + GCC_PREFIX_HEADER = "ReactiveCocoaTests/ReactiveCocoaTests-Prefix.pch"; + HEADER_SEARCH_PATHS = ( + "\"$(PROJECT_DIR)/../external/specta/src\"", + "\"$(PROJECT_DIR)/../external/expecta/src\"/**", + "$(inherited)", + ); + INFOPLIST_FILE = "ReactiveCocoaTests/UIKit/UIKitTestHost/ReactiveCocoa-iOS-UIKitTestHost-Info.plist"; + OTHER_LDFLAGS = "-all_load"; + PRODUCT_NAME = "$(TARGET_NAME)"; + WRAPPER_EXTENSION = app; + }; + name = Profile; + }; + 1860F444177C91B500C7B3C9 /* Debug */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = D094E45D17775B1000906BF7 /* iOS-Application.xcconfig */; + buildSettings = { + BUNDLE_LOADER = "$(BUILT_PRODUCTS_DIR)/ReactiveCocoa-iOS-UIKitTestHost.app/ReactiveCocoa-iOS-UIKitTestHost"; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; + CLANG_CXX_LIBRARY = "libc++"; + FRAMEWORK_SEARCH_PATHS = ( + "\"$(SDKROOT)/Developer/Library/Frameworks\"", + "\"$(DEVELOPER_LIBRARY_DIR)/Frameworks\"", + ); + GCC_C_LANGUAGE_STANDARD = gnu99; + GCC_PREFIX_HEADER = "ReactiveCocoaTests/ReactiveCocoaTests-Prefix.pch"; + HEADER_SEARCH_PATHS = ( + "\"$(PROJECT_DIR)/../external/specta/src\"", + "\"$(PROJECT_DIR)/../external/expecta/src\"/**", + "$(inherited)", + "\"$(SDKROOT)/Developer/Library/Frameworks\"", + "\"$(DEVELOPER_LIBRARY_DIR)/Frameworks\"\n\n//:configuration", + ); + INFOPLIST_FILE = "ReactiveCocoaTests/UIKit/UIKitTests/ReactiveCocoa-iOS-UIKitTestHostTests-Info.plist"; + ONLY_ACTIVE_ARCH = YES; + OTHER_LDFLAGS = "-all_load"; + PRODUCT_NAME = "$(TARGET_NAME)"; + TEST_HOST = "$(BUNDLE_LOADER)"; + WRAPPER_EXTENSION = octest; + }; + name = Debug; + }; + 1860F445177C91B500C7B3C9 /* Test */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = D094E45D17775B1000906BF7 /* iOS-Application.xcconfig */; + buildSettings = { + BUNDLE_LOADER = "$(BUILT_PRODUCTS_DIR)/ReactiveCocoa-iOS-UIKitTestHost.app/ReactiveCocoa-iOS-UIKitTestHost"; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; + CLANG_CXX_LIBRARY = "libc++"; + FRAMEWORK_SEARCH_PATHS = ( + "\"$(SDKROOT)/Developer/Library/Frameworks\"", + "\"$(DEVELOPER_LIBRARY_DIR)/Frameworks\"", + ); + GCC_C_LANGUAGE_STANDARD = gnu99; + GCC_PREFIX_HEADER = "ReactiveCocoaTests/ReactiveCocoaTests-Prefix.pch"; + HEADER_SEARCH_PATHS = ( + "\"$(PROJECT_DIR)/../external/specta/src\"", + "\"$(PROJECT_DIR)/../external/expecta/src\"/**", + "$(inherited)", + "\"$(SDKROOT)/Developer/Library/Frameworks\"", + "\"$(DEVELOPER_LIBRARY_DIR)/Frameworks\"\n\n//:configuration", + ); + INFOPLIST_FILE = "ReactiveCocoaTests/UIKit/UIKitTests/ReactiveCocoa-iOS-UIKitTestHostTests-Info.plist"; + ONLY_ACTIVE_ARCH = YES; + OTHER_LDFLAGS = "-all_load"; + PRODUCT_NAME = "$(TARGET_NAME)"; + TEST_HOST = "$(BUNDLE_LOADER)"; + WRAPPER_EXTENSION = octest; + }; + name = Test; + }; + 1860F446177C91B500C7B3C9 /* Release */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = D094E45D17775B1000906BF7 /* iOS-Application.xcconfig */; + buildSettings = { + BUNDLE_LOADER = "$(BUILT_PRODUCTS_DIR)/ReactiveCocoa-iOS-UIKitTestHost.app/ReactiveCocoa-iOS-UIKitTestHost"; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; + CLANG_CXX_LIBRARY = "libc++"; + FRAMEWORK_SEARCH_PATHS = ( + "\"$(SDKROOT)/Developer/Library/Frameworks\"", + "\"$(DEVELOPER_LIBRARY_DIR)/Frameworks\"", + ); + GCC_C_LANGUAGE_STANDARD = gnu99; + GCC_PREFIX_HEADER = "ReactiveCocoaTests/ReactiveCocoaTests-Prefix.pch"; + HEADER_SEARCH_PATHS = ( + "\"$(PROJECT_DIR)/../external/specta/src\"", + "\"$(PROJECT_DIR)/../external/expecta/src\"/**", + "$(inherited)", + "\"$(SDKROOT)/Developer/Library/Frameworks\"", + "\"$(DEVELOPER_LIBRARY_DIR)/Frameworks\"\n\n//:configuration", + ); + INFOPLIST_FILE = "ReactiveCocoaTests/UIKit/UIKitTests/ReactiveCocoa-iOS-UIKitTestHostTests-Info.plist"; + OTHER_LDFLAGS = "-all_load"; + PRODUCT_NAME = "$(TARGET_NAME)"; + TEST_HOST = "$(BUNDLE_LOADER)"; + WRAPPER_EXTENSION = octest; + }; + name = Release; + }; + 1860F447177C91B500C7B3C9 /* Profile */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = D094E45D17775B1000906BF7 /* iOS-Application.xcconfig */; + buildSettings = { + BUNDLE_LOADER = "$(BUILT_PRODUCTS_DIR)/ReactiveCocoa-iOS-UIKitTestHost.app/ReactiveCocoa-iOS-UIKitTestHost"; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; + CLANG_CXX_LIBRARY = "libc++"; + FRAMEWORK_SEARCH_PATHS = ( + "\"$(SDKROOT)/Developer/Library/Frameworks\"", + "\"$(DEVELOPER_LIBRARY_DIR)/Frameworks\"", + ); + GCC_C_LANGUAGE_STANDARD = gnu99; + GCC_PREFIX_HEADER = "ReactiveCocoaTests/ReactiveCocoaTests-Prefix.pch"; + HEADER_SEARCH_PATHS = ( + "\"$(PROJECT_DIR)/../external/specta/src\"", + "\"$(PROJECT_DIR)/../external/expecta/src\"/**", + "$(inherited)", + "\"$(SDKROOT)/Developer/Library/Frameworks\"", + "\"$(DEVELOPER_LIBRARY_DIR)/Frameworks\"\n\n//:configuration", + ); + INFOPLIST_FILE = "ReactiveCocoaTests/UIKit/UIKitTests/ReactiveCocoa-iOS-UIKitTestHostTests-Info.plist"; + OTHER_LDFLAGS = "-all_load"; + PRODUCT_NAME = "$(TARGET_NAME)"; + TEST_HOST = "$(BUNDLE_LOADER)"; + WRAPPER_EXTENSION = octest; + }; + name = Profile; + }; + 5FAF5233174D4C2000CAC810 /* Debug */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = D094E45D17775B1000906BF7 /* iOS-Application.xcconfig */; + buildSettings = { + FRAMEWORK_SEARCH_PATHS = ( + "\"$(SDKROOT)/Developer/Library/Frameworks\"", + "\"$(DEVELOPER_LIBRARY_DIR)/Frameworks\"", + ); + GCC_PREFIX_HEADER = "ReactiveCocoaTests/ReactiveCocoaTests-Prefix.pch"; + HEADER_SEARCH_PATHS = ( + "\"$(PROJECT_DIR)/../external/specta/src\"", + "\"$(PROJECT_DIR)/../external/expecta/src\"/**", + "$(inherited)", + ); + INFOPLIST_FILE = "ReactiveCocoaTests/ReactiveCocoaTests-Info.plist"; + OTHER_LDFLAGS = "-ObjC"; + PRODUCT_NAME = "$(TARGET_NAME)"; + WRAPPER_EXTENSION = octest; + }; + name = Debug; + }; + 5FAF5234174D4C2000CAC810 /* Test */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = D094E45D17775B1000906BF7 /* iOS-Application.xcconfig */; + buildSettings = { + FRAMEWORK_SEARCH_PATHS = ( + "\"$(SDKROOT)/Developer/Library/Frameworks\"", + "\"$(DEVELOPER_LIBRARY_DIR)/Frameworks\"", + ); + GCC_PREFIX_HEADER = "ReactiveCocoaTests/ReactiveCocoaTests-Prefix.pch"; + HEADER_SEARCH_PATHS = ( + "\"$(PROJECT_DIR)/../external/specta/src\"", + "\"$(PROJECT_DIR)/../external/expecta/src\"/**", + "$(inherited)", + ); + INFOPLIST_FILE = "ReactiveCocoaTests/ReactiveCocoaTests-Info.plist"; + OTHER_LDFLAGS = "-ObjC"; + PRODUCT_NAME = "$(TARGET_NAME)"; + WRAPPER_EXTENSION = octest; + }; + name = Test; + }; + 5FAF5235174D4C2000CAC810 /* Release */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = D094E45D17775B1000906BF7 /* iOS-Application.xcconfig */; + buildSettings = { + FRAMEWORK_SEARCH_PATHS = ( + "\"$(SDKROOT)/Developer/Library/Frameworks\"", + "\"$(DEVELOPER_LIBRARY_DIR)/Frameworks\"", + ); + GCC_PREFIX_HEADER = "ReactiveCocoaTests/ReactiveCocoaTests-Prefix.pch"; + HEADER_SEARCH_PATHS = ( + "\"$(PROJECT_DIR)/../external/specta/src\"", + "\"$(PROJECT_DIR)/../external/expecta/src\"/**", + "$(inherited)", + ); + INFOPLIST_FILE = "ReactiveCocoaTests/ReactiveCocoaTests-Info.plist"; + OTHER_LDFLAGS = "-ObjC"; + PRODUCT_NAME = "$(TARGET_NAME)"; + WRAPPER_EXTENSION = octest; + }; + name = Release; + }; + 5FAF5236174D4C2000CAC810 /* Profile */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = D094E45D17775B1000906BF7 /* iOS-Application.xcconfig */; + buildSettings = { + FRAMEWORK_SEARCH_PATHS = ( + "\"$(SDKROOT)/Developer/Library/Frameworks\"", + "\"$(DEVELOPER_LIBRARY_DIR)/Frameworks\"", + ); + GCC_PREFIX_HEADER = "ReactiveCocoaTests/ReactiveCocoaTests-Prefix.pch"; + HEADER_SEARCH_PATHS = ( + "\"$(PROJECT_DIR)/../external/specta/src\"", + "\"$(PROJECT_DIR)/../external/expecta/src\"/**", + "$(inherited)", + ); + INFOPLIST_FILE = "ReactiveCocoaTests/ReactiveCocoaTests-Info.plist"; + OTHER_LDFLAGS = "-ObjC"; + PRODUCT_NAME = "$(TARGET_NAME)"; + WRAPPER_EXTENSION = octest; + }; + name = Profile; + }; + 88037F9015056328001A5B19 /* Debug */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = D094E46417775B1000906BF7 /* Mac-Framework.xcconfig */; + buildSettings = { + DYLIB_COMPATIBILITY_VERSION = 1; + DYLIB_CURRENT_VERSION = 1; + FRAMEWORK_VERSION = A; + GCC_PREFIX_HEADER = "ReactiveCocoa/ReactiveCocoa-Prefix.pch"; + INFOPLIST_FILE = "ReactiveCocoa/ReactiveCocoa-Info.plist"; + PRODUCT_NAME = "$(TARGET_NAME)"; + WRAPPER_EXTENSION = framework; + }; + name = Debug; + }; + 88037F9115056328001A5B19 /* Release */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = D094E46417775B1000906BF7 /* Mac-Framework.xcconfig */; + buildSettings = { + DYLIB_COMPATIBILITY_VERSION = 1; + DYLIB_CURRENT_VERSION = 1; + FRAMEWORK_VERSION = A; + GCC_PREFIX_HEADER = "ReactiveCocoa/ReactiveCocoa-Prefix.pch"; + INFOPLIST_FILE = "ReactiveCocoa/ReactiveCocoa-Info.plist"; + PRODUCT_NAME = "$(TARGET_NAME)"; + WRAPPER_EXTENSION = framework; + }; + name = Release; + }; + 88997CAA1728912B00C569A6 /* Test */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = D094E45817775B1000906BF7 /* Test.xcconfig */; + buildSettings = { + ARCHS = "$(ARCHS_STANDARD_64_BIT)"; + CLANG_WARN_IMPLICIT_SIGN_CONVERSION = YES; + GCC_OPTIMIZATION_LEVEL = fast; + GCC_WARN_ABOUT_MISSING_NEWLINE = YES; + GCC_WARN_STRICT_SELECTOR_MATCH = YES; + GCC_WARN_UNDECLARED_SELECTOR = YES; + IPHONEOS_DEPLOYMENT_TARGET = 5.0; + MACOSX_DEPLOYMENT_TARGET = 10.7; + SDKROOT = macosx; + TARGETED_DEVICE_FAMILY = "1,2"; + VALID_ARCHS = x86_64; + WARNING_CFLAGS = ( + "-Werror", + "-Wall", + ); + }; + name = Test; + }; + 88997CAB1728912B00C569A6 /* Test */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = D094E46417775B1000906BF7 /* Mac-Framework.xcconfig */; + buildSettings = { + DYLIB_COMPATIBILITY_VERSION = 1; + DYLIB_CURRENT_VERSION = 1; + FRAMEWORK_VERSION = A; + GCC_PREFIX_HEADER = "ReactiveCocoa/ReactiveCocoa-Prefix.pch"; + INFOPLIST_FILE = "ReactiveCocoa/ReactiveCocoa-Info.plist"; + PRODUCT_NAME = "$(TARGET_NAME)"; + WRAPPER_EXTENSION = framework; + }; + name = Test; + }; + 88997CAC1728912B00C569A6 /* Test */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = D094E45F17775B1000906BF7 /* iOS-StaticLibrary.xcconfig */; + buildSettings = { + GCC_PREFIX_HEADER = "ReactiveCocoa/ReactiveCocoa-Prefix.pch"; + PRODUCT_NAME = "$(TARGET_NAME)"; + PUBLIC_HEADERS_FOLDER_PATH = include/ReactiveCocoa; + }; + name = Test; + }; + 88997CAD1728912B00C569A6 /* Test */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = D094E46117775B1000906BF7 /* Mac-Application.xcconfig */; + buildSettings = { + FRAMEWORK_SEARCH_PATHS = "$(DEVELOPER_LIBRARY_DIR)/Frameworks"; + GCC_PREFIX_HEADER = "ReactiveCocoaTests/ReactiveCocoaTests-Prefix.pch"; + HEADER_SEARCH_PATHS = ( + "\"$(PROJECT_DIR)/../external/specta/src\"", + "\"$(PROJECT_DIR)/../external/expecta/src\"/**", + ); + INFOPLIST_FILE = "ReactiveCocoaTests/ReactiveCocoaTests-Info.plist"; + OTHER_LDFLAGS = "-ObjC"; + PRODUCT_NAME = ReactiveCocoaTests; + VALID_ARCHS = x86_64; + WRAPPER_EXTENSION = octest; + }; + name = Test; + }; + 88CDF7EB15000FCF00163A9F /* Debug */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = D094E45517775B1000906BF7 /* Debug.xcconfig */; + buildSettings = { + ARCHS = "$(ARCHS_STANDARD_64_BIT)"; + CLANG_WARN_IMPLICIT_SIGN_CONVERSION = YES; + GCC_WARN_ABOUT_MISSING_NEWLINE = YES; + GCC_WARN_STRICT_SELECTOR_MATCH = YES; + GCC_WARN_UNDECLARED_SELECTOR = YES; + IPHONEOS_DEPLOYMENT_TARGET = 5.0; + MACOSX_DEPLOYMENT_TARGET = 10.7; + SDKROOT = macosx; + TARGETED_DEVICE_FAMILY = "1,2"; + VALID_ARCHS = x86_64; + WARNING_CFLAGS = ( + "-Werror", + "-Wall", + ); + }; + name = Debug; + }; + 88CDF7EC15000FCF00163A9F /* Release */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = D094E45717775B1000906BF7 /* Release.xcconfig */; + buildSettings = { + ARCHS = "$(ARCHS_STANDARD_64_BIT)"; + CLANG_WARN_IMPLICIT_SIGN_CONVERSION = YES; + GCC_WARN_ABOUT_MISSING_NEWLINE = YES; + GCC_WARN_STRICT_SELECTOR_MATCH = YES; + GCC_WARN_UNDECLARED_SELECTOR = YES; + IPHONEOS_DEPLOYMENT_TARGET = 5.0; + MACOSX_DEPLOYMENT_TARGET = 10.7; + SDKROOT = macosx; + TARGETED_DEVICE_FAMILY = "1,2"; + VALID_ARCHS = x86_64; + WARNING_CFLAGS = ( + "-Werror", + "-Wall", + ); + }; + name = Release; + }; + 88CDF7F115000FCF00163A9F /* Debug */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = D094E46117775B1000906BF7 /* Mac-Application.xcconfig */; + buildSettings = { + FRAMEWORK_SEARCH_PATHS = "$(DEVELOPER_LIBRARY_DIR)/Frameworks"; + GCC_PREFIX_HEADER = "ReactiveCocoaTests/ReactiveCocoaTests-Prefix.pch"; + HEADER_SEARCH_PATHS = ( + "\"$(PROJECT_DIR)/../external/specta/src\"", + "\"$(PROJECT_DIR)/../external/expecta/src\"/**", + ); + INFOPLIST_FILE = "ReactiveCocoaTests/ReactiveCocoaTests-Info.plist"; + OTHER_LDFLAGS = "-ObjC"; + PRODUCT_NAME = ReactiveCocoaTests; + VALID_ARCHS = x86_64; + WRAPPER_EXTENSION = octest; + }; + name = Debug; + }; + 88CDF7F215000FCF00163A9F /* Release */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = D094E46117775B1000906BF7 /* Mac-Application.xcconfig */; + buildSettings = { + FRAMEWORK_SEARCH_PATHS = "$(DEVELOPER_LIBRARY_DIR)/Frameworks"; + GCC_PREFIX_HEADER = "ReactiveCocoaTests/ReactiveCocoaTests-Prefix.pch"; + HEADER_SEARCH_PATHS = ( + "\"$(PROJECT_DIR)/../external/specta/src\"", + "\"$(PROJECT_DIR)/../external/expecta/src\"/**", + ); + INFOPLIST_FILE = "ReactiveCocoaTests/ReactiveCocoaTests-Info.plist"; + OTHER_LDFLAGS = "-ObjC"; + PRODUCT_NAME = ReactiveCocoaTests; + VALID_ARCHS = x86_64; + WRAPPER_EXTENSION = octest; + }; + name = Release; + }; + 88F440B4153DAC820097B4C3 /* Debug */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = D094E45F17775B1000906BF7 /* iOS-StaticLibrary.xcconfig */; + buildSettings = { + GCC_PREFIX_HEADER = "ReactiveCocoa/ReactiveCocoa-Prefix.pch"; + PRODUCT_NAME = "$(TARGET_NAME)"; + PUBLIC_HEADERS_FOLDER_PATH = include/ReactiveCocoa; + }; + name = Debug; + }; + 88F440B5153DAC820097B4C3 /* Release */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = D094E45F17775B1000906BF7 /* iOS-StaticLibrary.xcconfig */; + buildSettings = { + GCC_PREFIX_HEADER = "ReactiveCocoa/ReactiveCocoa-Prefix.pch"; + PRODUCT_NAME = "$(TARGET_NAME)"; + PUBLIC_HEADERS_FOLDER_PATH = include/ReactiveCocoa; + }; + name = Release; + }; + D05AD3B117F2D5710080895B /* Debug */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = D094E46517775B1000906BF7 /* Mac-StaticLibrary.xcconfig */; + buildSettings = { + CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; + CLANG_CXX_LIBRARY = "libc++"; + GCC_PREFIX_HEADER = "ReactiveCocoa/ReactiveCocoa-Prefix.pch"; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Debug; + }; + D05AD3B217F2D5710080895B /* Test */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = D094E46517775B1000906BF7 /* Mac-StaticLibrary.xcconfig */; + buildSettings = { + CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; + CLANG_CXX_LIBRARY = "libc++"; + GCC_PREFIX_HEADER = "ReactiveCocoa/ReactiveCocoa-Prefix.pch"; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Test; + }; + D05AD3B317F2D5710080895B /* Release */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = D094E46517775B1000906BF7 /* Mac-StaticLibrary.xcconfig */; + buildSettings = { + CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; + CLANG_CXX_LIBRARY = "libc++"; + GCC_PREFIX_HEADER = "ReactiveCocoa/ReactiveCocoa-Prefix.pch"; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Release; + }; + D05AD3B417F2D5710080895B /* Profile */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = D094E46517775B1000906BF7 /* Mac-StaticLibrary.xcconfig */; + buildSettings = { + CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; + CLANG_CXX_LIBRARY = "libc++"; + GCC_PREFIX_HEADER = "ReactiveCocoa/ReactiveCocoa-Prefix.pch"; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Profile; + }; + D095BDD115CB2F9D00E9BB13 /* Profile */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = D094E45617775B1000906BF7 /* Profile.xcconfig */; + buildSettings = { + ARCHS = "$(ARCHS_STANDARD_64_BIT)"; + CLANG_WARN_IMPLICIT_SIGN_CONVERSION = YES; + GCC_WARN_ABOUT_MISSING_NEWLINE = YES; + GCC_WARN_STRICT_SELECTOR_MATCH = YES; + GCC_WARN_UNDECLARED_SELECTOR = YES; + IPHONEOS_DEPLOYMENT_TARGET = 5.0; + MACOSX_DEPLOYMENT_TARGET = 10.7; + SDKROOT = macosx; + TARGETED_DEVICE_FAMILY = "1,2"; + VALID_ARCHS = x86_64; + WARNING_CFLAGS = ( + "-Werror", + "-Wall", + ); + }; + name = Profile; + }; + D095BDD215CB2F9D00E9BB13 /* Profile */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = D094E46417775B1000906BF7 /* Mac-Framework.xcconfig */; + buildSettings = { + DYLIB_COMPATIBILITY_VERSION = 1; + DYLIB_CURRENT_VERSION = 1; + FRAMEWORK_VERSION = A; + GCC_PREFIX_HEADER = "ReactiveCocoa/ReactiveCocoa-Prefix.pch"; + INFOPLIST_FILE = "ReactiveCocoa/ReactiveCocoa-Info.plist"; + PRODUCT_NAME = "$(TARGET_NAME)"; + WRAPPER_EXTENSION = framework; + }; + name = Profile; + }; + D095BDD315CB2F9D00E9BB13 /* Profile */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = D094E45F17775B1000906BF7 /* iOS-StaticLibrary.xcconfig */; + buildSettings = { + GCC_PREFIX_HEADER = "ReactiveCocoa/ReactiveCocoa-Prefix.pch"; + PRODUCT_NAME = "$(TARGET_NAME)"; + PUBLIC_HEADERS_FOLDER_PATH = include/ReactiveCocoa; + }; + name = Profile; + }; + D095BDD415CB2F9D00E9BB13 /* Profile */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = D094E46117775B1000906BF7 /* Mac-Application.xcconfig */; + buildSettings = { + FRAMEWORK_SEARCH_PATHS = "$(DEVELOPER_LIBRARY_DIR)/Frameworks"; + GCC_PREFIX_HEADER = "ReactiveCocoaTests/ReactiveCocoaTests-Prefix.pch"; + HEADER_SEARCH_PATHS = ( + "\"$(PROJECT_DIR)/../external/specta/src\"", + "\"$(PROJECT_DIR)/../external/expecta/src\"/**", + ); + INFOPLIST_FILE = "ReactiveCocoaTests/ReactiveCocoaTests-Info.plist"; + OTHER_LDFLAGS = "-ObjC"; + PRODUCT_NAME = ReactiveCocoaTests; + VALID_ARCHS = x86_64; + WRAPPER_EXTENSION = octest; + }; + name = Profile; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + 1860F44C177C91B500C7B3C9 /* Build configuration list for PBXNativeTarget "ReactiveCocoa-iOS-UIKitTestHost" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 1860F440177C91B500C7B3C9 /* Debug */, + 1860F441177C91B500C7B3C9 /* Test */, + 1860F442177C91B500C7B3C9 /* Release */, + 1860F443177C91B500C7B3C9 /* Profile */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 1860F44D177C91B500C7B3C9 /* Build configuration list for PBXNativeTarget "ReactiveCocoa-iOS-UIKitTestHostTests" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 1860F444177C91B500C7B3C9 /* Debug */, + 1860F445177C91B500C7B3C9 /* Test */, + 1860F446177C91B500C7B3C9 /* Release */, + 1860F447177C91B500C7B3C9 /* Profile */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 5FAF523D174D4C2000CAC810 /* Build configuration list for PBXNativeTarget "ReactiveCocoaTests-iOS" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 5FAF5233174D4C2000CAC810 /* Debug */, + 5FAF5234174D4C2000CAC810 /* Test */, + 5FAF5235174D4C2000CAC810 /* Release */, + 5FAF5236174D4C2000CAC810 /* Profile */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 88037F8F15056328001A5B19 /* Build configuration list for PBXNativeTarget "ReactiveCocoa" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 88037F9015056328001A5B19 /* Debug */, + 88997CAB1728912B00C569A6 /* Test */, + 88037F9115056328001A5B19 /* Release */, + D095BDD215CB2F9D00E9BB13 /* Profile */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 88CDF7B515000FCE00163A9F /* Build configuration list for PBXProject "ReactiveCocoa" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 88CDF7EB15000FCF00163A9F /* Debug */, + 88997CAA1728912B00C569A6 /* Test */, + 88CDF7EC15000FCF00163A9F /* Release */, + D095BDD115CB2F9D00E9BB13 /* Profile */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 88CDF7F015000FCF00163A9F /* Build configuration list for PBXNativeTarget "ReactiveCocoaTests" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 88CDF7F115000FCF00163A9F /* Debug */, + 88997CAD1728912B00C569A6 /* Test */, + 88CDF7F215000FCF00163A9F /* Release */, + D095BDD415CB2F9D00E9BB13 /* Profile */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 88F440B3153DAC820097B4C3 /* Build configuration list for PBXNativeTarget "ReactiveCocoa-iOS" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 88F440B4153DAC820097B4C3 /* Debug */, + 88997CAC1728912B00C569A6 /* Test */, + 88F440B5153DAC820097B4C3 /* Release */, + D095BDD315CB2F9D00E9BB13 /* Profile */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + D05AD3BD17F2D5710080895B /* Build configuration list for PBXNativeTarget "ReactiveCocoa-Mac" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + D05AD3B117F2D5710080895B /* Debug */, + D05AD3B217F2D5710080895B /* Test */, + D05AD3B317F2D5710080895B /* Release */, + D05AD3B417F2D5710080895B /* Profile */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = 88CDF7B215000FCE00163A9F /* Project object */; +}
diff --git a/ReactiveCocoaFramework/ReactiveCocoa.xcodeproj/project.xcworkspace/contents.xcworkspacedata b/ReactiveCocoaFramework/ReactiveCocoa.xcodeproj/project.xcworkspace/contents.xcworkspacedata new file mode 100644 index 0000000..a8ff253 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa.xcodeproj/project.xcworkspace/contents.xcworkspacedata
@@ -0,0 +1,7 @@ +<?xml version="1.0" encoding="UTF-8"?> +<Workspace + version = "1.0"> + <FileRef + location = "self:ReactiveCocoa.xcodeproj"> + </FileRef> +</Workspace>
diff --git a/ReactiveCocoaFramework/ReactiveCocoa.xcodeproj/xcshareddata/xcschemes/ReactiveCocoa-Mac.xcscheme b/ReactiveCocoaFramework/ReactiveCocoa.xcodeproj/xcshareddata/xcschemes/ReactiveCocoa-Mac.xcscheme new file mode 100644 index 0000000..b7efc3f --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa.xcodeproj/xcshareddata/xcschemes/ReactiveCocoa-Mac.xcscheme
@@ -0,0 +1,69 @@ +<?xml version="1.0" encoding="UTF-8"?> +<Scheme + LastUpgradeVersion = "0510" + version = "1.3"> + <BuildAction + parallelizeBuildables = "YES" + buildImplicitDependencies = "YES"> + <BuildActionEntries> + <BuildActionEntry + buildForTesting = "YES" + buildForRunning = "YES" + buildForProfiling = "YES" + buildForArchiving = "YES" + buildForAnalyzing = "YES"> + <BuildableReference + BuildableIdentifier = "primary" + BlueprintIdentifier = "D05AD39317F2D56F0080895B" + BuildableName = "libReactiveCocoa-Mac.a" + BlueprintName = "ReactiveCocoa-Mac" + ReferencedContainer = "container:ReactiveCocoa.xcodeproj"> + </BuildableReference> + </BuildActionEntry> + </BuildActionEntries> + </BuildAction> + <TestAction + selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB" + selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB" + shouldUseLaunchSchemeArgsEnv = "YES" + buildConfiguration = "Debug"> + <Testables> + <TestableReference + skipped = "NO"> + <BuildableReference + BuildableIdentifier = "primary" + BlueprintIdentifier = "D05AD3A117F2D5700080895B" + BuildableName = "ReactiveCocoa-MacTests.xctest" + BlueprintName = "ReactiveCocoa-MacTests" + ReferencedContainer = "container:ReactiveCocoa.xcodeproj"> + </BuildableReference> + </TestableReference> + </Testables> + </TestAction> + <LaunchAction + selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB" + selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB" + launchStyle = "0" + useCustomWorkingDirectory = "NO" + buildConfiguration = "Debug" + ignoresPersistentStateOnLaunch = "NO" + debugDocumentVersioning = "YES" + allowLocationSimulation = "YES"> + <AdditionalOptions> + </AdditionalOptions> + </LaunchAction> + <ProfileAction + shouldUseLaunchSchemeArgsEnv = "YES" + savedToolIdentifier = "" + useCustomWorkingDirectory = "NO" + buildConfiguration = "Release" + debugDocumentVersioning = "YES"> + </ProfileAction> + <AnalyzeAction + buildConfiguration = "Debug"> + </AnalyzeAction> + <ArchiveAction + buildConfiguration = "Release" + revealArchiveInOrganizer = "YES"> + </ArchiveAction> +</Scheme>
diff --git a/ReactiveCocoaFramework/ReactiveCocoa.xcodeproj/xcshareddata/xcschemes/ReactiveCocoa-iOS-UIKitTestHost.xcscheme b/ReactiveCocoaFramework/ReactiveCocoa.xcodeproj/xcshareddata/xcschemes/ReactiveCocoa-iOS-UIKitTestHost.xcscheme new file mode 100644 index 0000000..306864a --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa.xcodeproj/xcshareddata/xcschemes/ReactiveCocoa-iOS-UIKitTestHost.xcscheme
@@ -0,0 +1,110 @@ +<?xml version="1.0" encoding="UTF-8"?> +<Scheme + LastUpgradeVersion = "0500" + version = "1.3"> + <BuildAction + parallelizeBuildables = "YES" + buildImplicitDependencies = "YES"> + <BuildActionEntries> + <BuildActionEntry + buildForTesting = "YES" + buildForRunning = "YES" + buildForProfiling = "YES" + buildForArchiving = "YES" + buildForAnalyzing = "YES"> + <BuildableReference + BuildableIdentifier = "primary" + BlueprintIdentifier = "1860F411177C91B500C7B3C9" + BuildableName = "ReactiveCocoa-iOS-UIKitTestHost.app" + BlueprintName = "ReactiveCocoa-iOS-UIKitTestHost" + ReferencedContainer = "container:ReactiveCocoa.xcodeproj"> + </BuildableReference> + </BuildActionEntry> + <BuildActionEntry + buildForTesting = "YES" + buildForRunning = "YES" + buildForProfiling = "NO" + buildForArchiving = "NO" + buildForAnalyzing = "YES"> + <BuildableReference + BuildableIdentifier = "primary" + BlueprintIdentifier = "1860F42F177C91B500C7B3C9" + BuildableName = "ReactiveCocoa-iOS-UIKitTestHostTests.octest" + BlueprintName = "ReactiveCocoa-iOS-UIKitTestHostTests" + ReferencedContainer = "container:ReactiveCocoa.xcodeproj"> + </BuildableReference> + </BuildActionEntry> + </BuildActionEntries> + </BuildAction> + <TestAction + selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB" + selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB" + shouldUseLaunchSchemeArgsEnv = "YES" + buildConfiguration = "Test"> + <Testables> + <TestableReference + skipped = "NO"> + <BuildableReference + BuildableIdentifier = "primary" + BlueprintIdentifier = "1860F42F177C91B500C7B3C9" + BuildableName = "ReactiveCocoa-iOS-UIKitTestHostTests.octest" + BlueprintName = "ReactiveCocoa-iOS-UIKitTestHostTests" + ReferencedContainer = "container:ReactiveCocoa.xcodeproj"> + </BuildableReference> + </TestableReference> + </Testables> + <MacroExpansion> + <BuildableReference + BuildableIdentifier = "primary" + BlueprintIdentifier = "1860F411177C91B500C7B3C9" + BuildableName = "ReactiveCocoa-iOS-UIKitTestHost.app" + BlueprintName = "ReactiveCocoa-iOS-UIKitTestHost" + ReferencedContainer = "container:ReactiveCocoa.xcodeproj"> + </BuildableReference> + </MacroExpansion> + </TestAction> + <LaunchAction + selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB" + selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB" + launchStyle = "0" + useCustomWorkingDirectory = "NO" + buildConfiguration = "Debug" + ignoresPersistentStateOnLaunch = "NO" + debugDocumentVersioning = "YES" + allowLocationSimulation = "YES"> + <BuildableProductRunnable> + <BuildableReference + BuildableIdentifier = "primary" + BlueprintIdentifier = "1860F411177C91B500C7B3C9" + BuildableName = "ReactiveCocoa-iOS-UIKitTestHost.app" + BlueprintName = "ReactiveCocoa-iOS-UIKitTestHost" + ReferencedContainer = "container:ReactiveCocoa.xcodeproj"> + </BuildableReference> + </BuildableProductRunnable> + <AdditionalOptions> + </AdditionalOptions> + </LaunchAction> + <ProfileAction + shouldUseLaunchSchemeArgsEnv = "YES" + savedToolIdentifier = "" + useCustomWorkingDirectory = "NO" + buildConfiguration = "Profile" + debugDocumentVersioning = "YES"> + <BuildableProductRunnable> + <BuildableReference + BuildableIdentifier = "primary" + BlueprintIdentifier = "1860F411177C91B500C7B3C9" + BuildableName = "ReactiveCocoa-iOS-UIKitTestHost.app" + BlueprintName = "ReactiveCocoa-iOS-UIKitTestHost" + ReferencedContainer = "container:ReactiveCocoa.xcodeproj"> + </BuildableReference> + </BuildableProductRunnable> + </ProfileAction> + <AnalyzeAction + buildConfiguration = "Debug"> + </AnalyzeAction> + <ArchiveAction + buildConfiguration = "Release" + revealArchiveInOrganizer = "YES"> + </ArchiveAction> +</Scheme>
diff --git a/ReactiveCocoaFramework/ReactiveCocoa.xcodeproj/xcshareddata/xcschemes/ReactiveCocoa-iOS.xcscheme b/ReactiveCocoaFramework/ReactiveCocoa.xcodeproj/xcshareddata/xcschemes/ReactiveCocoa-iOS.xcscheme new file mode 100644 index 0000000..a31da25 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa.xcodeproj/xcshareddata/xcschemes/ReactiveCocoa-iOS.xcscheme
@@ -0,0 +1,83 @@ +<?xml version="1.0" encoding="UTF-8"?> +<Scheme + LastUpgradeVersion = "0510" + version = "1.3"> + <BuildAction + parallelizeBuildables = "YES" + buildImplicitDependencies = "YES"> + <BuildActionEntries> + <BuildActionEntry + buildForTesting = "YES" + buildForRunning = "YES" + buildForProfiling = "YES" + buildForArchiving = "YES" + buildForAnalyzing = "YES"> + <BuildableReference + BuildableIdentifier = "primary" + BlueprintIdentifier = "88F440AA153DAC820097B4C3" + BuildableName = "libReactiveCocoa-iOS.a" + BlueprintName = "ReactiveCocoa-iOS" + ReferencedContainer = "container:ReactiveCocoa.xcodeproj"> + </BuildableReference> + </BuildActionEntry> + <BuildActionEntry + buildForTesting = "YES" + buildForRunning = "YES" + buildForProfiling = "NO" + buildForArchiving = "NO" + buildForAnalyzing = "YES"> + <BuildableReference + BuildableIdentifier = "primary" + BlueprintIdentifier = "5FAF5222174D4C2000CAC810" + BuildableName = "ReactiveCocoaTests-iOS.octest" + BlueprintName = "ReactiveCocoaTests-iOS" + ReferencedContainer = "container:ReactiveCocoa.xcodeproj"> + </BuildableReference> + </BuildActionEntry> + </BuildActionEntries> + </BuildAction> + <TestAction + selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB" + selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB" + shouldUseLaunchSchemeArgsEnv = "YES" + buildConfiguration = "Test"> + <Testables> + <TestableReference + skipped = "NO"> + <BuildableReference + BuildableIdentifier = "primary" + BlueprintIdentifier = "5FAF5222174D4C2000CAC810" + BuildableName = "ReactiveCocoaTests-iOS.octest" + BlueprintName = "ReactiveCocoaTests-iOS" + ReferencedContainer = "container:ReactiveCocoa.xcodeproj"> + </BuildableReference> + </TestableReference> + </Testables> + </TestAction> + <LaunchAction + selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB" + selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB" + launchStyle = "0" + useCustomWorkingDirectory = "NO" + buildConfiguration = "Debug" + ignoresPersistentStateOnLaunch = "NO" + debugDocumentVersioning = "YES" + allowLocationSimulation = "YES"> + <AdditionalOptions> + </AdditionalOptions> + </LaunchAction> + <ProfileAction + shouldUseLaunchSchemeArgsEnv = "YES" + savedToolIdentifier = "" + useCustomWorkingDirectory = "NO" + buildConfiguration = "Profile" + debugDocumentVersioning = "YES"> + </ProfileAction> + <AnalyzeAction + buildConfiguration = "Debug"> + </AnalyzeAction> + <ArchiveAction + buildConfiguration = "Release" + revealArchiveInOrganizer = "YES"> + </ArchiveAction> +</Scheme>
diff --git a/ReactiveCocoaFramework/ReactiveCocoa.xcodeproj/xcshareddata/xcschemes/ReactiveCocoa.xcscheme b/ReactiveCocoaFramework/ReactiveCocoa.xcodeproj/xcshareddata/xcschemes/ReactiveCocoa.xcscheme new file mode 100644 index 0000000..12209cd --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa.xcodeproj/xcshareddata/xcschemes/ReactiveCocoa.xcscheme
@@ -0,0 +1,99 @@ +<?xml version="1.0" encoding="UTF-8"?> +<Scheme + LastUpgradeVersion = "0510" + version = "1.3"> + <BuildAction + parallelizeBuildables = "YES" + buildImplicitDependencies = "YES"> + <BuildActionEntries> + <BuildActionEntry + buildForTesting = "YES" + buildForRunning = "YES" + buildForProfiling = "YES" + buildForArchiving = "YES" + buildForAnalyzing = "YES"> + <BuildableReference + BuildableIdentifier = "primary" + BlueprintIdentifier = "88037F8215056328001A5B19" + BuildableName = "ReactiveCocoa.framework" + BlueprintName = "ReactiveCocoa" + ReferencedContainer = "container:ReactiveCocoa.xcodeproj"> + </BuildableReference> + </BuildActionEntry> + <BuildActionEntry + buildForTesting = "YES" + buildForRunning = "YES" + buildForProfiling = "NO" + buildForArchiving = "NO" + buildForAnalyzing = "YES"> + <BuildableReference + BuildableIdentifier = "primary" + BlueprintIdentifier = "88CDF7DB15000FCF00163A9F" + BuildableName = "ReactiveCocoaTests.octest" + BlueprintName = "ReactiveCocoaTests" + ReferencedContainer = "container:ReactiveCocoa.xcodeproj"> + </BuildableReference> + </BuildActionEntry> + </BuildActionEntries> + </BuildAction> + <TestAction + selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB" + selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB" + shouldUseLaunchSchemeArgsEnv = "NO" + buildConfiguration = "Test"> + <Testables> + <TestableReference + skipped = "NO"> + <BuildableReference + BuildableIdentifier = "primary" + BlueprintIdentifier = "88CDF7DB15000FCF00163A9F" + BuildableName = "ReactiveCocoaTests.octest" + BlueprintName = "ReactiveCocoaTests" + ReferencedContainer = "container:ReactiveCocoa.xcodeproj"> + </BuildableReference> + </TestableReference> + </Testables> + <MacroExpansion> + <BuildableReference + BuildableIdentifier = "primary" + BlueprintIdentifier = "88037F8215056328001A5B19" + BuildableName = "ReactiveCocoa.framework" + BlueprintName = "ReactiveCocoa" + ReferencedContainer = "container:ReactiveCocoa.xcodeproj"> + </BuildableReference> + </MacroExpansion> + <EnvironmentVariables> + <EnvironmentVariable + key = "DYLD_INSERT_LIBRARIES" + value = "$(BUILT_PRODUCTS_DIR)/ReactiveCocoa.framework/ReactiveCocoa" + isEnabled = "YES"> + </EnvironmentVariable> + </EnvironmentVariables> + </TestAction> + <LaunchAction + selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB" + selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB" + launchStyle = "0" + useCustomWorkingDirectory = "NO" + buildConfiguration = "Debug" + ignoresPersistentStateOnLaunch = "NO" + debugDocumentVersioning = "YES" + allowLocationSimulation = "YES"> + <AdditionalOptions> + </AdditionalOptions> + </LaunchAction> + <ProfileAction + shouldUseLaunchSchemeArgsEnv = "YES" + savedToolIdentifier = "" + useCustomWorkingDirectory = "NO" + buildConfiguration = "Profile" + debugDocumentVersioning = "YES"> + </ProfileAction> + <AnalyzeAction + buildConfiguration = "Debug"> + </AnalyzeAction> + <ArchiveAction + buildConfiguration = "Release" + revealArchiveInOrganizer = "YES"> + </ArchiveAction> +</Scheme>
diff --git a/ReactiveCocoaFramework/ReactiveCocoa.xcworkspace/contents.xcworkspacedata b/ReactiveCocoaFramework/ReactiveCocoa.xcworkspace/contents.xcworkspacedata new file mode 100644 index 0000000..4fb1f75 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa.xcworkspace/contents.xcworkspacedata
@@ -0,0 +1,13 @@ +<?xml version="1.0" encoding="UTF-8"?> +<Workspace + version = "1.0"> + <FileRef + location = "group:ReactiveCocoa.xcodeproj"> + </FileRef> + <FileRef + location = "group:../external/expecta/Expecta.xcodeproj"> + </FileRef> + <FileRef + location = "group:../external/specta/Specta.xcodeproj"> + </FileRef> +</Workspace>
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSArray+RACSequenceAdditions.h b/ReactiveCocoaFramework/ReactiveCocoa/NSArray+RACSequenceAdditions.h new file mode 100644 index 0000000..d2d0b3f --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSArray+RACSequenceAdditions.h
@@ -0,0 +1,20 @@ +// +// NSArray+RACSequenceAdditions.h +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-10-29. +// Copyright (c) 2012 GitHub. All rights reserved. +// + +#import <Foundation/Foundation.h> + +@class RACSequence; + +@interface NSArray (RACSequenceAdditions) + +/// Creates and returns a sequence corresponding to the receiver. +/// +/// Mutating the receiver will not affect the sequence after it's been created. +@property (nonatomic, copy, readonly) RACSequence *rac_sequence; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSArray+RACSequenceAdditions.m b/ReactiveCocoaFramework/ReactiveCocoa/NSArray+RACSequenceAdditions.m new file mode 100644 index 0000000..ca2b951 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSArray+RACSequenceAdditions.m
@@ -0,0 +1,18 @@ +// +// NSArray+RACSequenceAdditions.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-10-29. +// Copyright (c) 2012 GitHub. All rights reserved. +// + +#import "NSArray+RACSequenceAdditions.h" +#import "RACArraySequence.h" + +@implementation NSArray (RACSequenceAdditions) + +- (RACSequence *)rac_sequence { + return [RACArraySequence sequenceWithArray:self offset:0]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSControl+RACCommandSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/NSControl+RACCommandSupport.h new file mode 100644 index 0000000..4e51577 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSControl+RACCommandSupport.h
@@ -0,0 +1,22 @@ +// +// NSControl+RACCommandSupport.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 3/3/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import <Cocoa/Cocoa.h> + +@class RACCommand; + +@interface NSControl (RACCommandSupport) + +/// Sets the control's command. When the control is clicked, the command is +/// executed with the sender of the event. The control's enabledness is bound +/// to the command's `canExecute`. +/// +/// Note: this will reset the control's target and action. +@property (nonatomic, strong) RACCommand *rac_command; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSControl+RACCommandSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/NSControl+RACCommandSupport.m new file mode 100644 index 0000000..8778f69 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSControl+RACCommandSupport.m
@@ -0,0 +1,59 @@ +// +// NSControl+RACCommandSupport.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 3/3/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "NSControl+RACCommandSupport.h" +#import "EXTScope.h" +#import "NSObject+RACPropertySubscribing.h" +#import "RACCommand.h" +#import "RACScopedDisposable.h" +#import "RACSignal+Operations.h" +#import <objc/runtime.h> + +static void *NSControlRACCommandKey = &NSControlRACCommandKey; +static void *NSControlEnabledDisposableKey = &NSControlEnabledDisposableKey; + +@implementation NSControl (RACCommandSupport) + +- (RACCommand *)rac_command { + return objc_getAssociatedObject(self, NSControlRACCommandKey); +} + +- (void)setRac_command:(RACCommand *)command { + objc_setAssociatedObject(self, NSControlRACCommandKey, command, OBJC_ASSOCIATION_RETAIN_NONATOMIC); + + // Tear down any previous binding before setting up our new one, or else we + // might get assertion failures. + [objc_getAssociatedObject(self, NSControlEnabledDisposableKey) dispose]; + objc_setAssociatedObject(self, NSControlEnabledDisposableKey, nil, OBJC_ASSOCIATION_RETAIN_NONATOMIC); + + if (command == nil) { + self.enabled = YES; + return; + } + + [self rac_hijackActionAndTargetIfNeeded]; + + RACScopedDisposable *disposable = [[command.enabled setKeyPath:@"enabled" onObject:self] asScopedDisposable]; + objc_setAssociatedObject(self, NSControlEnabledDisposableKey, disposable, OBJC_ASSOCIATION_RETAIN_NONATOMIC); +} + +- (void)rac_hijackActionAndTargetIfNeeded { + SEL hijackSelector = @selector(rac_commandPerformAction:); + if (self.target == self && self.action == hijackSelector) return; + + if (self.target != nil) NSLog(@"WARNING: NSControl.rac_command hijacks the control's existing target and action."); + + self.target = self; + self.action = hijackSelector; +} + +- (void)rac_commandPerformAction:(id)sender { + [self.rac_command execute:sender]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSControl+RACTextSignalSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/NSControl+RACTextSignalSupport.h new file mode 100644 index 0000000..3d3618d --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSControl+RACTextSignalSupport.h
@@ -0,0 +1,24 @@ +// +// NSControl+RACTextSignalSupport.h +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-03-08. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import <Cocoa/Cocoa.h> + +@class RACSignal; + +@interface NSControl (RACTextSignalSupport) + +/// Observes a text-based control for changes. +/// +/// Using this method on a control without editable text is considered undefined +/// behavior. +/// +/// Returns a signal which sends the current string value of the receiver, then +/// the new value any time it changes. +- (RACSignal *)rac_textSignal; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSControl+RACTextSignalSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/NSControl+RACTextSignalSupport.m new file mode 100644 index 0000000..3541bc2 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSControl+RACTextSignalSupport.m
@@ -0,0 +1,38 @@ +// +// NSControl+RACTextSignalSupport.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-03-08. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "NSControl+RACTextSignalSupport.h" +#import "EXTScope.h" +#import "RACDisposable.h" +#import "RACSignal.h" +#import "RACSubscriber.h" +#import "NSObject+RACDescription.h" + +@implementation NSControl (RACTextSignalSupport) + +- (RACSignal *)rac_textSignal { + @weakify(self); + return [[[[RACSignal + createSignal:^(id<RACSubscriber> subscriber) { + @strongify(self); + id observer = [NSNotificationCenter.defaultCenter addObserverForName:NSControlTextDidChangeNotification object:self queue:nil usingBlock:^(NSNotification *note) { + [subscriber sendNext:note.object]; + }]; + + return [RACDisposable disposableWithBlock:^{ + [NSNotificationCenter.defaultCenter removeObserver:observer]; + }]; + }] + map:^(NSControl *control) { + return [control.stringValue copy]; + }] + startWith:[self.stringValue copy]] + setNameWithFormat:@"%@ -rac_textSignal", [self rac_description]]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSData+RACSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/NSData+RACSupport.h new file mode 100644 index 0000000..42198a6 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSData+RACSupport.h
@@ -0,0 +1,22 @@ +// +// NSData+RACSupport.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 5/11/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import <Foundation/Foundation.h> + +@class RACSignal; +@class RACScheduler; + +@interface NSData (RACSupport) + +// Read the data at the URL using -[NSData initWithContentsOfURL:options:error:]. +// Sends the data or the error. +// +// scheduler - cannot be nil. ++ (RACSignal *)rac_readContentsOfURL:(NSURL *)URL options:(NSDataReadingOptions)options scheduler:(RACScheduler *)scheduler; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSData+RACSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/NSData+RACSupport.m new file mode 100644 index 0000000..227eb4d --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSData+RACSupport.m
@@ -0,0 +1,35 @@ +// +// NSData+RACSupport.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 5/11/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "NSData+RACSupport.h" +#import "RACReplaySubject.h" +#import "RACScheduler.h" + +@implementation NSData (RACSupport) + ++ (RACSignal *)rac_readContentsOfURL:(NSURL *)URL options:(NSDataReadingOptions)options scheduler:(RACScheduler *)scheduler { + NSCParameterAssert(scheduler != nil); + + RACReplaySubject *subject = [RACReplaySubject subject]; + [subject setNameWithFormat:@"+rac_readContentsOfURL: %@ options: %lu scheduler: %@", URL, (unsigned long)options, scheduler]; + + [scheduler schedule:^{ + NSError *error = nil; + NSData *data = [[NSData alloc] initWithContentsOfURL:URL options:options error:&error]; + if(data == nil) { + [subject sendError:error]; + } else { + [subject sendNext:data]; + [subject sendCompleted]; + } + }]; + + return subject; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSDictionary+RACSequenceAdditions.h b/ReactiveCocoaFramework/ReactiveCocoa/NSDictionary+RACSequenceAdditions.h new file mode 100644 index 0000000..4871fe7 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSDictionary+RACSequenceAdditions.h
@@ -0,0 +1,31 @@ +// +// NSDictionary+RACSequenceAdditions.h +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-10-29. +// Copyright (c) 2012 GitHub. All rights reserved. +// + +#import <Foundation/Foundation.h> + +@class RACSequence; + +@interface NSDictionary (RACSequenceAdditions) + +/// Creates and returns a sequence of RACTuple key/value pairs. The key will be +/// the first element in the tuple, and the value will be the second. +/// +/// Mutating the receiver will not affect the sequence after it's been created. +@property (nonatomic, copy, readonly) RACSequence *rac_sequence; + +/// Creates and returns a sequence corresponding to the keys in the receiver. +/// +/// Mutating the receiver will not affect the sequence after it's been created. +@property (nonatomic, copy, readonly) RACSequence *rac_keySequence; + +/// Creates and returns a sequence corresponding to the values in the receiver. +/// +/// Mutating the receiver will not affect the sequence after it's been created. +@property (nonatomic, copy, readonly) RACSequence *rac_valueSequence; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSDictionary+RACSequenceAdditions.m b/ReactiveCocoaFramework/ReactiveCocoa/NSDictionary+RACSequenceAdditions.m new file mode 100644 index 0000000..192e6fd --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSDictionary+RACSequenceAdditions.m
@@ -0,0 +1,34 @@ +// +// NSDictionary+RACSequenceAdditions.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-10-29. +// Copyright (c) 2012 GitHub. All rights reserved. +// + +#import "NSDictionary+RACSequenceAdditions.h" +#import "NSArray+RACSequenceAdditions.h" +#import "RACSequence.h" +#import "RACTuple.h" + +@implementation NSDictionary (RACSequenceAdditions) + +- (RACSequence *)rac_sequence { + NSDictionary *immutableDict = [self copy]; + + // TODO: First class support for dictionary sequences. + return [immutableDict.allKeys.rac_sequence map:^(id key) { + id value = immutableDict[key]; + return [RACTuple tupleWithObjects:key, value, nil]; + }]; +} + +- (RACSequence *)rac_keySequence { + return self.allKeys.rac_sequence; +} + +- (RACSequence *)rac_valueSequence { + return self.allValues.rac_sequence; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSEnumerator+RACSequenceAdditions.h b/ReactiveCocoaFramework/ReactiveCocoa/NSEnumerator+RACSequenceAdditions.h new file mode 100644 index 0000000..1d8fc84 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSEnumerator+RACSequenceAdditions.h
@@ -0,0 +1,20 @@ +// +// NSEnumerator+RACSequenceAdditions.h +// ReactiveCocoa +// +// Created by Uri Baghin on 07/01/2013. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import <Foundation/Foundation.h> + +@class RACSequence; + +@interface NSEnumerator (RACSequenceAdditions) + +/// Creates and returns a sequence corresponding to the receiver. +/// +/// The receiver is exhausted lazily as the sequence is enumerated. +@property (nonatomic, copy, readonly) RACSequence *rac_sequence; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSEnumerator+RACSequenceAdditions.m b/ReactiveCocoaFramework/ReactiveCocoa/NSEnumerator+RACSequenceAdditions.m new file mode 100644 index 0000000..aa56eaa --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSEnumerator+RACSequenceAdditions.m
@@ -0,0 +1,22 @@ +// +// NSEnumerator+RACSequenceAdditions.m +// ReactiveCocoa +// +// Created by Uri Baghin on 07/01/2013. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "NSEnumerator+RACSequenceAdditions.h" +#import "RACSequence.h" + +@implementation NSEnumerator (RACSequenceAdditions) + +- (RACSequence *)rac_sequence { + return [RACSequence sequenceWithHeadBlock:^{ + return [self nextObject]; + } tailBlock:^{ + return self.rac_sequence; + }]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSFileHandle+RACSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/NSFileHandle+RACSupport.h new file mode 100644 index 0000000..985398d --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSFileHandle+RACSupport.h
@@ -0,0 +1,19 @@ +// +// NSFileHandle+RACSupport.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 5/10/12. +// Copyright (c) 2012 GitHub. All rights reserved. +// + +#import <Foundation/Foundation.h> + +@class RACSignal; + +@interface NSFileHandle (RACSupport) + +// Read any available data in the background and send it. Completes when data +// length is <= 0. +- (RACSignal *)rac_readInBackground; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSFileHandle+RACSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/NSFileHandle+RACSupport.m new file mode 100644 index 0000000..a258789 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSFileHandle+RACSupport.m
@@ -0,0 +1,39 @@ +// +// NSFileHandle+RACSupport.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 5/10/12. +// Copyright (c) 2012 GitHub. All rights reserved. +// + +#import "NSFileHandle+RACSupport.h" +#import "NSNotificationCenter+RACSupport.h" +#import "RACReplaySubject.h" +#import "RACDisposable.h" + +@implementation NSFileHandle (RACSupport) + +- (RACSignal *)rac_readInBackground { + RACReplaySubject *subject = [RACReplaySubject subject]; + [subject setNameWithFormat:@"%@ -rac_readInBackground", self]; + + RACSignal *dataNotification = [[[NSNotificationCenter defaultCenter] rac_addObserverForName:NSFileHandleReadCompletionNotification object:self] map:^(NSNotification *note) { + return [note.userInfo objectForKey:NSFileHandleNotificationDataItem]; + }]; + + __block RACDisposable *subscription = [dataNotification subscribeNext:^(NSData *data) { + if(data.length > 0) { + [subject sendNext:data]; + [self readInBackgroundAndNotify]; + } else { + [subject sendCompleted]; + [subscription dispose]; + } + }]; + + [self readInBackgroundAndNotify]; + + return subject; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSIndexSet+RACSequenceAdditions.h b/ReactiveCocoaFramework/ReactiveCocoa/NSIndexSet+RACSequenceAdditions.h new file mode 100644 index 0000000..b2066e4 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSIndexSet+RACSequenceAdditions.h
@@ -0,0 +1,20 @@ +// +// NSIndexSet+RACSequenceAdditions.h +// ReactiveCocoa +// +// Created by Sergey Gavrilyuk on 12/17/13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import <Foundation/Foundation.h> +#import "RACSequence.h" + +@interface NSIndexSet (RACSequenceAdditions) + +/// Creates and returns a sequence of indexes (as `NSNumber`s) corresponding to +/// the receiver. +/// +/// Mutating the receiver will not affect the sequence after it's been created. +@property (nonatomic, copy, readonly) RACSequence *rac_sequence; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSIndexSet+RACSequenceAdditions.m b/ReactiveCocoaFramework/ReactiveCocoa/NSIndexSet+RACSequenceAdditions.m new file mode 100644 index 0000000..b3557e6 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSIndexSet+RACSequenceAdditions.m
@@ -0,0 +1,18 @@ +// +// NSIndexSet+RACSequenceAdditions.m +// ReactiveCocoa +// +// Created by Sergey Gavrilyuk on 12/17/13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "NSIndexSet+RACSequenceAdditions.h" +#import "RACIndexSetSequence.h" + +@implementation NSIndexSet (RACSequenceAdditions) + +- (RACSequence *)rac_sequence { + return [RACIndexSetSequence sequenceWithIndexSet:self]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSInvocation+RACTypeParsing.h b/ReactiveCocoaFramework/ReactiveCocoa/NSInvocation+RACTypeParsing.h new file mode 100644 index 0000000..d1e72bf --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSInvocation+RACTypeParsing.h
@@ -0,0 +1,56 @@ +// +// NSInvocation+RACTypeParsing.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 11/17/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import <Foundation/Foundation.h> + +@class RACTuple; + +// A private category of methods to handle wrapping and unwrapping of values. +@interface NSInvocation (RACTypeParsing) + +// Sets the argument for the invocation at the given index by unboxing the given +// object based on the type signature of the argument. +// +// This does not support C arrays or unions. +// +// Note that calling this on a char * or const char * argument can cause all +// arguments to be retained. +// +// object - The object to unbox and set as the argument. +// index - The index of the argument to set. +- (void)rac_setArgument:(id)object atIndex:(NSUInteger)index; + +// Gets the argument for the invocation at the given index based on the +// invocation's method signature. The value is then wrapped in the appropriate +// object type. +// +// This does not support C arrays or unions. +// +// index - The index of the argument to get. +// +// Returns the argument of the invocation, wrapped in an object. +- (id)rac_argumentAtIndex:(NSUInteger)index; + +// Arguments tuple for the invocation. +// +// The arguments tuple excludes implicit variables `self` and `_cmd`. +// +// See -rac_argumentAtIndex: and -rac_setArgumentAtIndex: for further +// description of the underlying behavior. +@property (nonatomic, copy) RACTuple *rac_argumentsTuple; + +// Gets the return value from the invocation based on the invocation's method +// signature. The value is then wrapped in the appropriate object type. +// +// This does not support C arrays or unions. +// +// Returns the return value of the invocation, wrapped in an object. Voids are +// returned as `RACUnit.defaultUnit`. +- (id)rac_returnValue; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSInvocation+RACTypeParsing.m b/ReactiveCocoaFramework/ReactiveCocoa/NSInvocation+RACTypeParsing.m new file mode 100644 index 0000000..a5318e7 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSInvocation+RACTypeParsing.m
@@ -0,0 +1,232 @@ +// +// NSInvocation+RACTypeParsing.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 11/17/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "NSInvocation+RACTypeParsing.h" +#import "RACTuple.h" +#import "RACUnit.h" +#import <CoreGraphics/CoreGraphics.h> + +@implementation NSInvocation (RACTypeParsing) + +- (void)rac_setArgument:(id)object atIndex:(NSUInteger)index { +#define PULL_AND_SET(type, selector) \ + do { \ + type val = [object selector]; \ + [self setArgument:&val atIndex:(NSInteger)index]; \ + } while(0) + + const char *argType = [self.methodSignature getArgumentTypeAtIndex:index]; + // Skip const type qualifier. + if (argType[0] == 'r') { + argType++; + } + + if (strcmp(argType, @encode(id)) == 0 || strcmp(argType, @encode(Class)) == 0) { + [self setArgument:&object atIndex:(NSInteger)index]; + } else if (strcmp(argType, @encode(char)) == 0) { + PULL_AND_SET(char, charValue); + } else if (strcmp(argType, @encode(int)) == 0) { + PULL_AND_SET(int, intValue); + } else if (strcmp(argType, @encode(short)) == 0) { + PULL_AND_SET(short, shortValue); + } else if (strcmp(argType, @encode(long)) == 0) { + PULL_AND_SET(long, longValue); + } else if (strcmp(argType, @encode(long long)) == 0) { + PULL_AND_SET(long long, longLongValue); + } else if (strcmp(argType, @encode(unsigned char)) == 0) { + PULL_AND_SET(unsigned char, unsignedCharValue); + } else if (strcmp(argType, @encode(unsigned int)) == 0) { + PULL_AND_SET(unsigned int, unsignedIntValue); + } else if (strcmp(argType, @encode(unsigned short)) == 0) { + PULL_AND_SET(unsigned short, unsignedShortValue); + } else if (strcmp(argType, @encode(unsigned long)) == 0) { + PULL_AND_SET(unsigned long, unsignedLongValue); + } else if (strcmp(argType, @encode(unsigned long long)) == 0) { + PULL_AND_SET(unsigned long long, unsignedLongLongValue); + } else if (strcmp(argType, @encode(float)) == 0) { + PULL_AND_SET(float, floatValue); + } else if (strcmp(argType, @encode(double)) == 0) { + PULL_AND_SET(double, doubleValue); + } else if (strcmp(argType, @encode(BOOL)) == 0) { + PULL_AND_SET(BOOL, boolValue); + } else if (strcmp(argType, @encode(char *)) == 0) { + const char *cString = [object UTF8String]; + [self setArgument:&cString atIndex:(NSInteger)index]; + [self retainArguments]; + } else if (strcmp(argType, @encode(void (^)(void))) == 0) { + [self setArgument:&object atIndex:(NSInteger)index]; + } else { + NSCParameterAssert([object isKindOfClass:NSValue.class]); + + NSUInteger valueSize = 0; + NSGetSizeAndAlignment([object objCType], &valueSize, NULL); + +#if DEBUG + NSUInteger argSize = 0; + NSGetSizeAndAlignment(argType, &argSize, NULL); + NSCAssert(valueSize == argSize, @"Value size does not match argument size in -rac_setArgument: %@ atIndex: %lu", object, (unsigned long)index); +#endif + + unsigned char valueBytes[valueSize]; + [object getValue:valueBytes]; + + [self setArgument:valueBytes atIndex:(NSInteger)index]; + } + +#undef PULL_AND_SET +} + +- (id)rac_argumentAtIndex:(NSUInteger)index { +#define WRAP_AND_RETURN(type) \ + do { \ + type val = 0; \ + [self getArgument:&val atIndex:(NSInteger)index]; \ + return @(val); \ + } while (0) + + const char *argType = [self.methodSignature getArgumentTypeAtIndex:index]; + // Skip const type qualifier. + if (argType[0] == 'r') { + argType++; + } + + if (strcmp(argType, @encode(id)) == 0 || strcmp(argType, @encode(Class)) == 0) { + __autoreleasing id returnObj; + [self getArgument:&returnObj atIndex:(NSInteger)index]; + return returnObj; + } else if (strcmp(argType, @encode(char)) == 0) { + WRAP_AND_RETURN(char); + } else if (strcmp(argType, @encode(int)) == 0) { + WRAP_AND_RETURN(int); + } else if (strcmp(argType, @encode(short)) == 0) { + WRAP_AND_RETURN(short); + } else if (strcmp(argType, @encode(long)) == 0) { + WRAP_AND_RETURN(long); + } else if (strcmp(argType, @encode(long long)) == 0) { + WRAP_AND_RETURN(long long); + } else if (strcmp(argType, @encode(unsigned char)) == 0) { + WRAP_AND_RETURN(unsigned char); + } else if (strcmp(argType, @encode(unsigned int)) == 0) { + WRAP_AND_RETURN(unsigned int); + } else if (strcmp(argType, @encode(unsigned short)) == 0) { + WRAP_AND_RETURN(unsigned short); + } else if (strcmp(argType, @encode(unsigned long)) == 0) { + WRAP_AND_RETURN(unsigned long); + } else if (strcmp(argType, @encode(unsigned long long)) == 0) { + WRAP_AND_RETURN(unsigned long long); + } else if (strcmp(argType, @encode(float)) == 0) { + WRAP_AND_RETURN(float); + } else if (strcmp(argType, @encode(double)) == 0) { + WRAP_AND_RETURN(double); + } else if (strcmp(argType, @encode(BOOL)) == 0) { + WRAP_AND_RETURN(BOOL); + } else if (strcmp(argType, @encode(char *)) == 0) { + WRAP_AND_RETURN(const char *); + } else if (strcmp(argType, @encode(void (^)(void))) == 0) { + __unsafe_unretained id block = nil; + [self getArgument:&block atIndex:(NSInteger)index]; + return [block copy]; + } else { + NSUInteger valueSize = 0; + NSGetSizeAndAlignment(argType, &valueSize, NULL); + + unsigned char valueBytes[valueSize]; + [self getArgument:valueBytes atIndex:(NSInteger)index]; + + return [NSValue valueWithBytes:valueBytes objCType:argType]; + } + + return nil; + +#undef WRAP_AND_RETURN +} + +- (RACTuple *)rac_argumentsTuple { + NSUInteger numberOfArguments = self.methodSignature.numberOfArguments; + NSMutableArray *argumentsArray = [NSMutableArray arrayWithCapacity:numberOfArguments - 2]; + for (NSUInteger index = 2; index < numberOfArguments; index++) { + [argumentsArray addObject:[self rac_argumentAtIndex:index] ?: RACTupleNil.tupleNil]; + } + + return [RACTuple tupleWithObjectsFromArray:argumentsArray]; +} + +- (void)setRac_argumentsTuple:(RACTuple *)arguments { + NSCAssert(arguments.count == self.methodSignature.numberOfArguments - 2, @"Number of supplied arguments (%lu), does not match the number expected by the signature (%lu)", (unsigned long)arguments.count, (unsigned long)self.methodSignature.numberOfArguments - 2); + + NSUInteger index = 2; + for (id arg in arguments) { + [self rac_setArgument:(arg == RACTupleNil.tupleNil ? nil : arg) atIndex:index]; + index++; + } +} + +- (id)rac_returnValue { +#define WRAP_AND_RETURN(type) \ + do { \ + type val = 0; \ + [self getReturnValue:&val]; \ + return @(val); \ + } while (0) + + const char *returnType = self.methodSignature.methodReturnType; + // Skip const type qualifier. + if (returnType[0] == 'r') { + returnType++; + } + + if (strcmp(returnType, @encode(id)) == 0 || strcmp(returnType, @encode(Class)) == 0 || strcmp(returnType, @encode(void (^)(void))) == 0) { + __autoreleasing id returnObj; + [self getReturnValue:&returnObj]; + return returnObj; + } else if (strcmp(returnType, @encode(char)) == 0) { + WRAP_AND_RETURN(char); + } else if (strcmp(returnType, @encode(int)) == 0) { + WRAP_AND_RETURN(int); + } else if (strcmp(returnType, @encode(short)) == 0) { + WRAP_AND_RETURN(short); + } else if (strcmp(returnType, @encode(long)) == 0) { + WRAP_AND_RETURN(long); + } else if (strcmp(returnType, @encode(long long)) == 0) { + WRAP_AND_RETURN(long long); + } else if (strcmp(returnType, @encode(unsigned char)) == 0) { + WRAP_AND_RETURN(unsigned char); + } else if (strcmp(returnType, @encode(unsigned int)) == 0) { + WRAP_AND_RETURN(unsigned int); + } else if (strcmp(returnType, @encode(unsigned short)) == 0) { + WRAP_AND_RETURN(unsigned short); + } else if (strcmp(returnType, @encode(unsigned long)) == 0) { + WRAP_AND_RETURN(unsigned long); + } else if (strcmp(returnType, @encode(unsigned long long)) == 0) { + WRAP_AND_RETURN(unsigned long long); + } else if (strcmp(returnType, @encode(float)) == 0) { + WRAP_AND_RETURN(float); + } else if (strcmp(returnType, @encode(double)) == 0) { + WRAP_AND_RETURN(double); + } else if (strcmp(returnType, @encode(BOOL)) == 0) { + WRAP_AND_RETURN(BOOL); + } else if (strcmp(returnType, @encode(char *)) == 0) { + WRAP_AND_RETURN(const char *); + } else if (strcmp(returnType, @encode(void)) == 0) { + return RACUnit.defaultUnit; + } else { + NSUInteger valueSize = 0; + NSGetSizeAndAlignment(returnType, &valueSize, NULL); + + unsigned char valueBytes[valueSize]; + [self getReturnValue:valueBytes]; + + return [NSValue valueWithBytes:valueBytes objCType:returnType]; + } + + return nil; + +#undef WRAP_AND_RETURN +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSNotificationCenter+RACSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/NSNotificationCenter+RACSupport.h new file mode 100644 index 0000000..ddb3954 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSNotificationCenter+RACSupport.h
@@ -0,0 +1,18 @@ +// +// NSNotificationCenter+RACSupport.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 5/10/12. +// Copyright (c) 2012 GitHub. All rights reserved. +// + +#import <Foundation/Foundation.h> + +@class RACSignal; + +@interface NSNotificationCenter (RACSupport) + +// Sends the NSNotification every time the notification is posted. +- (RACSignal *)rac_addObserverForName:(NSString *)notificationName object:(id)object; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSNotificationCenter+RACSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/NSNotificationCenter+RACSupport.m new file mode 100644 index 0000000..a0112e9 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSNotificationCenter+RACSupport.m
@@ -0,0 +1,31 @@ +// +// NSNotificationCenter+RACSupport.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 5/10/12. +// Copyright (c) 2012 GitHub. All rights reserved. +// + +#import "NSNotificationCenter+RACSupport.h" +#import "EXTScope.h" +#import "RACSignal.h" +#import "RACSubscriber.h" +#import "RACDisposable.h" + +@implementation NSNotificationCenter (RACSupport) + +- (RACSignal *)rac_addObserverForName:(NSString *)notificationName object:(id)object { + @unsafeify(object); + return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) { + @strongify(object); + id observer = [self addObserverForName:notificationName object:object queue:nil usingBlock:^(NSNotification *note) { + [subscriber sendNext:note]; + }]; + + return [RACDisposable disposableWithBlock:^{ + [self removeObserver:observer]; + }]; + }] setNameWithFormat:@"-rac_addObserverForName: %@ object: <%@: %p>", notificationName, [object class], object]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACAppKitBindings.h b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACAppKitBindings.h new file mode 100644 index 0000000..eaec439 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACAppKitBindings.h
@@ -0,0 +1,40 @@ +// +// NSObject+RACAppKitBindings.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 4/17/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import <Cocoa/Cocoa.h> + +@class RACChannelTerminal; + +@interface NSObject (RACAppKitBindings) + +/// Invokes -rac_channelToBinding:options: without any options. +- (RACChannelTerminal *)rac_channelToBinding:(NSString *)binding; + +/// Applies a Cocoa binding to the receiver, then exposes a RACChannel-based +/// interface for manipulating it. +/// +/// Creating two of the same bindings on the same object will result in undefined +/// behavior. +/// +/// binding - The name of the binding. This must not be nil. +/// options - Any options to pass to Cocoa Bindings. This may be nil. +/// +/// Returns a RACChannelTerminal which will send future values from the receiver, +/// and update the receiver when values are sent to the terminal. +- (RACChannelTerminal *)rac_channelToBinding:(NSString *)binding options:(NSDictionary *)options; + +@end + +@interface NSObject (RACAppKitBindingsDeprecated) + +- (void)rac_bind:(NSString *)binding toObject:(id)object withKeyPath:(NSString *)keyPath __attribute__((deprecated("Use -rac_bind:options: instead"))); +- (void)rac_bind:(NSString *)binding toObject:(id)object withKeyPath:(NSString *)keyPath nilValue:(id)nilValue __attribute__((deprecated("Use -rac_bind:options: instead"))); +- (void)rac_bind:(NSString *)binding toObject:(id)object withKeyPath:(NSString *)keyPath transform:(id (^)(id value))transformBlock __attribute__((deprecated("Use -rac_bind:options: instead"))); +- (void)rac_bind:(NSString *)binding toObject:(id)object withNegatedKeyPath:(NSString *)keyPath __attribute__((deprecated("Use -rac_bind:options: instead"))); + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACAppKitBindings.m b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACAppKitBindings.m new file mode 100644 index 0000000..ea80f83 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACAppKitBindings.m
@@ -0,0 +1,175 @@ +// +// NSObject+RACAppKitBindings.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 4/17/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "NSObject+RACAppKitBindings.h" +#import "EXTKeyPathCoding.h" +#import "EXTScope.h" +#import "NSObject+RACDeallocating.h" +#import "RACChannel.h" +#import "RACCompoundDisposable.h" +#import "RACDisposable.h" +#import "RACKVOChannel.h" +#import "RACMulticastConnection.h" +#import "RACSignal+Operations.h" +#import "RACValueTransformer.h" +#import <objc/runtime.h> + +// Used as an object to bind to, so we can hide the object creation and just +// expose a RACChannel instead. +@interface RACChannelProxy : NSObject + +// The RACChannel used for this Cocoa binding. +@property (nonatomic, strong, readonly) RACChannel *channel; + +// The KVC- and KVO-compliant property to be read and written by the Cocoa +// binding. +// +// This should not be set manually. +@property (nonatomic, strong) id value; + +// The target of the Cocoa binding. +// +// This should be set to nil when the target deallocates. +@property (atomic, unsafe_unretained) id target; + +// The name of the Cocoa binding used. +@property (nonatomic, copy, readonly) NSString *bindingName; + +// Improves the performance of KVO on the receiver. +// +// See the documentation for <NSKeyValueObserving> for more information. +@property (atomic, assign) void *observationInfo; + +// Initializes the receiver and binds to the given target. +// +// target - The target of the Cocoa binding. This must not be nil. +// bindingName - The name of the Cocoa binding to use. This must not be nil. +// options - Any options to pass to the binding. This may be nil. +// +// Returns an initialized channel proxy. +- (id)initWithTarget:(id)target bindingName:(NSString *)bindingName options:(NSDictionary *)options; + +@end + +@implementation NSObject (RACAppKitBindings) + +- (RACChannelTerminal *)rac_channelToBinding:(NSString *)binding { + return [self rac_channelToBinding:binding options:nil]; +} + +- (RACChannelTerminal *)rac_channelToBinding:(NSString *)binding options:(NSDictionary *)options { + NSCParameterAssert(binding != nil); + + RACChannelProxy *proxy = [[RACChannelProxy alloc] initWithTarget:self bindingName:binding options:options]; + return proxy.channel.leadingTerminal; +} + +@end + +@implementation RACChannelProxy + +#pragma mark Properties + +- (void)setValue:(id)value { + [self willChangeValueForKey:@keypath(self.value)]; + _value = value; + [self didChangeValueForKey:@keypath(self.value)]; +} + +#pragma mark Lifecycle + +- (id)initWithTarget:(id)target bindingName:(NSString *)bindingName options:(NSDictionary *)options { + NSCParameterAssert(target != nil); + NSCParameterAssert(bindingName != nil); + + self = [super init]; + if (self == nil) return nil; + + _target = target; + _bindingName = [bindingName copy]; + _channel = [[RACChannel alloc] init]; + + @weakify(self); + + void (^cleanUp)() = ^{ + @strongify(self); + + id target = self.target; + if (target == nil) return; + + self.target = nil; + + [target unbind:bindingName]; + objc_setAssociatedObject(target, (__bridge void *)self, nil, OBJC_ASSOCIATION_RETAIN_NONATOMIC); + }; + + // When the channel terminates, tear down this proxy. + [self.channel.followingTerminal subscribeError:^(NSError *error) { + cleanUp(); + } completed:cleanUp]; + + [self.target bind:bindingName toObject:self withKeyPath:@keypath(self.value) options:options]; + + // Keep the proxy alive as long as the target, or until the property subject + // terminates. + objc_setAssociatedObject(self.target, (__bridge void *)self, self, OBJC_ASSOCIATION_RETAIN_NONATOMIC); + + [[self.target rac_deallocDisposable] addDisposable:[RACDisposable disposableWithBlock:^{ + @strongify(self); + [self.channel.followingTerminal sendCompleted]; + }]]; + + RACChannelTo(self, value, options[NSNullPlaceholderBindingOption]) = self.channel.followingTerminal; + return self; +} + +- (void)dealloc { + [self.channel.followingTerminal sendCompleted]; +} + +#pragma mark NSObject + +- (NSString *)description { + return [NSString stringWithFormat:@"<%@: %p>{ target: %@, binding: %@ }", self.class, self, self.target, self.bindingName]; +} + +#pragma mark NSKeyValueObserving + ++ (BOOL)automaticallyNotifiesObserversForKey:(NSString *)key { + // Generating manual notifications for `value` is simpler and more + // performant than having KVO swizzle our class and add its own logic. + return NO; +} + +@end + +@implementation NSObject (RACAppKitBindingsDeprecated) + +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wdeprecated-implementations" + +- (void)rac_bind:(NSString *)binding toObject:(id)object withKeyPath:(NSString *)keyPath { + [self rac_bind:binding toObject:object withKeyPath:keyPath nilValue:nil]; +} + +- (void)rac_bind:(NSString *)binding toObject:(id)object withKeyPath:(NSString *)keyPath nilValue:(id)nilValue { + [self bind:binding toObject:object withKeyPath:keyPath options:[NSDictionary dictionaryWithObjectsAndKeys:[NSNumber numberWithBool:YES], NSContinuouslyUpdatesValueBindingOption, nilValue, NSNullPlaceholderBindingOption, nil]]; +} + +- (void)rac_bind:(NSString *)binding toObject:(id)object withKeyPath:(NSString *)keyPath transform:(id (^)(id value))transformBlock { + RACValueTransformer *transformer = [RACValueTransformer transformerWithBlock:transformBlock]; + [self bind:binding toObject:object withKeyPath:keyPath options:[NSDictionary dictionaryWithObjectsAndKeys:[NSNumber numberWithBool:YES], NSContinuouslyUpdatesValueBindingOption, transformer, NSValueTransformerBindingOption, nil]]; +} + +- (void)rac_bind:(NSString *)binding toObject:(id)object withNegatedKeyPath:(NSString *)keyPath { + [self bind:binding toObject:object withKeyPath:keyPath options:[NSDictionary dictionaryWithObjectsAndKeys:[NSNumber numberWithBool:YES], NSContinuouslyUpdatesValueBindingOption, NSNegateBooleanTransformerName, NSValueTransformerNameBindingOption, nil]]; +} + +#pragma clang diagnostic pop + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACDeallocating.h b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACDeallocating.h new file mode 100644 index 0000000..1530eb4 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACDeallocating.h
@@ -0,0 +1,34 @@ +// +// NSObject+RACDeallocating.h +// ReactiveCocoa +// +// Created by Kazuo Koga on 2013/03/15. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import <Foundation/Foundation.h> + +@class RACCompoundDisposable; +@class RACDisposable; +@class RACSignal; + +@interface NSObject (RACDeallocating) + +/// The compound disposable which will be disposed of when the receiver is +/// deallocated. +@property (atomic, readonly, strong) RACCompoundDisposable *rac_deallocDisposable; + +/// Returns a signal that will complete immediately before the receiver is fully +/// deallocated. If already deallocated when the signal is subscribed to, +/// a `completed` event will be sent immediately. +- (RACSignal *)rac_willDeallocSignal; + +@end + +@interface NSObject (RACDeallocatingDeprecated) + +- (RACSignal *)rac_didDeallocSignal __attribute__((deprecated("Use -rac_willDeallocSignal"))); + +- (void)rac_addDeallocDisposable:(RACDisposable *)disposable __attribute__((deprecated("Add disposables to -rac_deallocDisposable instead"))); + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACDeallocating.m b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACDeallocating.m new file mode 100644 index 0000000..a81d89c --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACDeallocating.m
@@ -0,0 +1,129 @@ +// +// NSObject+RACDeallocating.m +// ReactiveCocoa +// +// Created by Kazuo Koga on 2013/03/15. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "NSObject+RACDeallocating.h" +#import "RACCompoundDisposable.h" +#import "RACDisposable.h" +#import "RACReplaySubject.h" +#import <objc/message.h> +#import <objc/runtime.h> + +static const void *RACObjectCompoundDisposable = &RACObjectCompoundDisposable; + +static NSMutableSet *swizzledClasses() { + static dispatch_once_t onceToken; + static NSMutableSet *swizzledClasses = nil; + dispatch_once(&onceToken, ^{ + swizzledClasses = [[NSMutableSet alloc] init]; + }); + + return swizzledClasses; +} + +static void swizzleDeallocIfNeeded(Class classToSwizzle) { + @synchronized (swizzledClasses()) { + NSString *className = NSStringFromClass(classToSwizzle); + if ([swizzledClasses() containsObject:className]) return; + + SEL deallocSelector = sel_registerName("dealloc"); + + __block void (*originalDealloc)(__unsafe_unretained id, SEL) = NULL; + + id newDealloc = ^(__unsafe_unretained id self) { + RACCompoundDisposable *compoundDisposable = objc_getAssociatedObject(self, RACObjectCompoundDisposable); + [compoundDisposable dispose]; + + if (originalDealloc == NULL) { + struct objc_super superInfo = { + .receiver = self, + .super_class = class_getSuperclass(classToSwizzle) + }; + + void (*msgSend)(struct objc_super *, SEL) = (__typeof__(msgSend))objc_msgSendSuper; + msgSend(&superInfo, deallocSelector); + } else { + originalDealloc(self, deallocSelector); + } + }; + + IMP newDeallocIMP = imp_implementationWithBlock(newDealloc); + + if (!class_addMethod(classToSwizzle, deallocSelector, newDeallocIMP, "v@:")) { + // The class already contains a method implementation. + Method deallocMethod = class_getInstanceMethod(classToSwizzle, deallocSelector); + + // We need to store original implementation before setting new implementation + // in case method is called at the time of setting. + originalDealloc = (__typeof__(originalDealloc))method_getImplementation(deallocMethod); + + // We need to store original implementation again, in case it just changed. + originalDealloc = (__typeof__(originalDealloc))method_setImplementation(deallocMethod, newDeallocIMP); + } + + [swizzledClasses() addObject:className]; + } +} + +@implementation NSObject (RACDeallocating) + +- (RACSignal *)rac_willDeallocSignal { + RACSignal *signal = objc_getAssociatedObject(self, _cmd); + if (signal != nil) return signal; + + RACReplaySubject *subject = [RACReplaySubject subject]; + + [self.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + [subject sendCompleted]; + }]]; + + objc_setAssociatedObject(self, _cmd, subject, OBJC_ASSOCIATION_RETAIN); + + return subject; +} + +- (RACCompoundDisposable *)rac_deallocDisposable { + @synchronized (self) { + RACCompoundDisposable *compoundDisposable = objc_getAssociatedObject(self, RACObjectCompoundDisposable); + if (compoundDisposable != nil) return compoundDisposable; + + swizzleDeallocIfNeeded(self.class); + + compoundDisposable = [RACCompoundDisposable compoundDisposable]; + objc_setAssociatedObject(self, RACObjectCompoundDisposable, compoundDisposable, OBJC_ASSOCIATION_RETAIN_NONATOMIC); + + return compoundDisposable; + } +} + +@end + +@implementation NSObject (RACDeallocatingDeprecated) + +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wdeprecated-implementations" + +- (RACSignal *)rac_didDeallocSignal { + RACSubject *subject = [RACSubject subject]; + + RACScopedDisposable *disposable = [[RACDisposable + disposableWithBlock:^{ + [subject sendCompleted]; + }] + asScopedDisposable]; + + objc_setAssociatedObject(self, (__bridge void *)disposable, disposable, OBJC_ASSOCIATION_RETAIN_NONATOMIC); + return subject; +} + +- (void)rac_addDeallocDisposable:(RACDisposable *)disposable { + [self.rac_deallocDisposable addDisposable:disposable]; +} + +#pragma clang diagnostic pop + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACDescription.h b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACDescription.h new file mode 100644 index 0000000..41e3d8a --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACDescription.h
@@ -0,0 +1,21 @@ +// +// NSObject+RACDescription.h +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-05-13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import <Foundation/Foundation.h> + +// A private category providing a terser but faster alternative to -description. +@interface NSObject (RACDescription) + +// A simplified description of the receiver, which does not invoke -description +// (and thus should be much faster in many cases). +// +// This is for debugging purposes only, and will return a constant string +// unless the RAC_DEBUG_SIGNAL_NAMES environment variable is set. +- (NSString *)rac_description; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACDescription.m b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACDescription.m new file mode 100644 index 0000000..0088880 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACDescription.m
@@ -0,0 +1,46 @@ +// +// NSObject+RACDescription.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-05-13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "NSObject+RACDescription.h" +#import "RACTuple.h" + +@implementation NSObject (RACDescription) + +- (NSString *)rac_description { + if (getenv("RAC_DEBUG_SIGNAL_NAMES") != NULL) { + return [[NSString alloc] initWithFormat:@"<%@: %p>", self.class, self]; + } else { + return @"(description skipped)"; + } +} + +@end + +@implementation NSValue (RACDescription) + +- (NSString *)rac_description { + return self.description; +} + +@end + +@implementation NSString (RACDescription) + +- (NSString *)rac_description { + return self.description; +} + +@end + +@implementation RACTuple (RACDescription) + +- (NSString *)rac_description { + return self.allObjects.description; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACKVOWrapper.h b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACKVOWrapper.h new file mode 100644 index 0000000..3b9ff2f --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACKVOWrapper.h
@@ -0,0 +1,56 @@ +// +// NSObject+RACKVOWrapper.h +// GitHub +// +// Created by Josh Abernathy on 10/11/11. +// Copyright (c) 2011 GitHub. All rights reserved. +// + +#import <Foundation/Foundation.h> + + +// RAC-specific KVO change dictionary key: Will be @YES if the change was caused +// by the value at the key path or an intermediate value deallocating, @NO +// otherwise. +extern NSString * const RACKeyValueChangeCausedByDeallocationKey; + +// RAC-specific KVO change dictionary key: Will be @YES if the change only +// affected the value of the last key path component leaving the values of the +// intermediate key path components unaltered, @NO otherwise. +extern NSString * const RACKeyValueChangeAffectedOnlyLastComponentKey; + +@class RACDisposable, RACKVOTrampoline; + +// A private category providing a block based interface to KVO. +@interface NSObject (RACKVOWrapper) + +// Adds the given block as the callbacks for when the key path changes. +// +// Unlike direct KVO observation, this handles deallocation of `weak` properties +// by generating an appropriate notification. This will only occur if there is +// an `@property` declaration visible in the observed class, with the `weak` +// memory management attribute. +// +// The observation does not need to be explicitly removed. It will be removed +// when the observer or the receiver deallocate. +// +// keyPath - The key path to observe. Must not be nil. +// options - The KVO observation options. +// observer - The object that requested the observation. May be nil. +// block - The block called when the value at the key path changes. It is +// passed the current value of the key path and the extended KVO +// change dictionary including RAC-specific keys and values. Must not +// be nil. +// +// Returns a disposable that can be used to stop the observation. +- (RACDisposable *)rac_observeKeyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options observer:(NSObject *)observer block:(void (^)(id value, NSDictionary *change))block; + +@end + +typedef void (^RACKVOBlock)(id target, id observer, NSDictionary *change); + +@interface NSObject (RACKVOWrapperDeprecated) + +- (RACKVOTrampoline *)rac_addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options block:(RACKVOBlock)block __attribute((deprecated("Use rac_observeKeyPath:options:observer:block: instead."))); + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACKVOWrapper.m b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACKVOWrapper.m new file mode 100644 index 0000000..7f12312 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACKVOWrapper.m
@@ -0,0 +1,237 @@ +// +// NSObject+RACKVOWrapper.m +// GitHub +// +// Created by Josh Abernathy on 10/11/11. +// Copyright (c) 2011 GitHub. All rights reserved. +// + +#import "NSObject+RACKVOWrapper.h" +#import "EXTRuntimeExtensions.h" +#import "EXTScope.h" +#import "NSObject+RACDeallocating.h" +#import "NSString+RACKeyPathUtilities.h" +#import "RACCompoundDisposable.h" +#import "RACDisposable.h" +#import "RACKVOTrampoline.h" +#import "RACSerialDisposable.h" + +NSString * const RACKeyValueChangeCausedByDeallocationKey = @"RACKeyValueChangeCausedByDeallocationKey"; +NSString * const RACKeyValueChangeAffectedOnlyLastComponentKey = @"RACKeyValueChangeAffectedOnlyLastComponentKey"; + +@implementation NSObject (RACKVOWrapper) + +- (RACDisposable *)rac_observeKeyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options observer:(NSObject *)observer block:(void (^)(id, NSDictionary *))block { + NSCParameterAssert(block != nil); + NSCParameterAssert(keyPath.rac_keyPathComponents.count > 0); + + keyPath = [keyPath copy]; + + @unsafeify(observer); + + NSArray *keyPathComponents = keyPath.rac_keyPathComponents; + BOOL keyPathHasOneComponent = (keyPathComponents.count == 1); + NSString *keyPathHead = keyPathComponents[0]; + NSString *keyPathTail = keyPath.rac_keyPathByDeletingFirstKeyPathComponent; + + RACCompoundDisposable *disposable = [RACCompoundDisposable compoundDisposable]; + + // The disposable that groups all disposal necessary to clean up the callbacks + // added to the value of the first key path component. + RACSerialDisposable *firstComponentSerialDisposable = [RACSerialDisposable serialDisposableWithDisposable:[RACCompoundDisposable compoundDisposable]]; + RACCompoundDisposable * (^firstComponentDisposable)(void) = ^{ + return (RACCompoundDisposable *)firstComponentSerialDisposable.disposable; + }; + + [disposable addDisposable:firstComponentSerialDisposable]; + + // Adds the callback block to the value's deallocation. Also adds the logic to + // clean up the callback to the firstComponentDisposable. + void (^addDeallocObserverToPropertyValue)(NSObject *, NSString *, NSObject *) = ^(NSObject *parent, NSString *propertyKey, NSObject *value) { + // If a key path value is the observer, commonly when a key path begins + // with "self", we prevent deallocation triggered callbacks for any such key + // path components. Thus, the observer's deallocation is not considered a + // change to the key path. + @strongify(observer); + if (value == observer) return; + + objc_property_t property = class_getProperty(object_getClass(parent), propertyKey.UTF8String); + if (property == NULL) { + // If we can't find an Objective-C property for this key, we assume + // that we don't need to observe its deallocation (thus matching + // vanilla KVO behavior). + // + // Even if we wanted to, there's not enough type information on + // ivars to figure out its memory management. + return; + } + + rac_propertyAttributes *attributes = rac_copyPropertyAttributes(property); + if (attributes == NULL) return; + + @onExit { + free(attributes); + }; + + BOOL isNonObject = attributes->objectClass == nil && strstr(attributes->type, @encode(id)) != attributes->type; + BOOL isProtocol = attributes->objectClass == NSClassFromString(@"Protocol"); + BOOL isBlock = strcmp(attributes->type, @encode(void(^)())) == 0; + if (isNonObject || isProtocol || isBlock) { + // If this property isn't actually an object (or is a Class object), + // no point in observing the deallocation of the wrapper returned by + // KVC. + return; + } + + if (!attributes->weak) { + // If this property is an object, but not declared `weak`, we + // don't need to watch for it spontaneously being set to nil. + // + // Attempting to observe non-weak properties will result in + // broken behavior for dynamic getters, so don't even try. + return; + } + + NSDictionary *change = @{ + NSKeyValueChangeKindKey: @(NSKeyValueChangeSetting), + NSKeyValueChangeNewKey: NSNull.null, + RACKeyValueChangeCausedByDeallocationKey: @YES, + RACKeyValueChangeAffectedOnlyLastComponentKey: @(keyPathHasOneComponent) + }; + + RACCompoundDisposable *valueDisposable = value.rac_deallocDisposable; + RACDisposable *deallocDisposable = [RACDisposable disposableWithBlock:^{ + block(nil, change); + }]; + + [valueDisposable addDisposable:deallocDisposable]; + [firstComponentDisposable() addDisposable:[RACDisposable disposableWithBlock:^{ + [valueDisposable removeDisposable:deallocDisposable]; + }]]; + }; + + // Adds the callback block to the remaining path components on the value. Also + // adds the logic to clean up the callbacks to the firstComponentDisposable. + void (^addObserverToValue)(NSObject *) = ^(NSObject *value) { + @strongify(observer); + RACDisposable *observerDisposable = [value rac_observeKeyPath:keyPathTail options:(options & ~NSKeyValueObservingOptionInitial) observer:observer block:block]; + [firstComponentDisposable() addDisposable:observerDisposable]; + }; + + // Observe only the first key path component, when the value changes clean up + // the callbacks on the old value, add callbacks to the new value and call the + // callback block as needed. + // + // Note this does not use NSKeyValueObservingOptionInitial so this only + // handles changes to the value, callbacks to the initial value must be added + // separately. + NSKeyValueObservingOptions trampolineOptions = (options | NSKeyValueObservingOptionPrior) & ~NSKeyValueObservingOptionInitial; + RACKVOTrampoline *trampoline = [[RACKVOTrampoline alloc] initWithTarget:self observer:observer keyPath:keyPathHead options:trampolineOptions block:^(id trampolineTarget, id trampolineObserver, NSDictionary *change) { + // Prepare the change dictionary by adding the RAC specific keys + { + NSMutableDictionary *newChange = [change mutableCopy]; + newChange[RACKeyValueChangeCausedByDeallocationKey] = @NO; + newChange[RACKeyValueChangeAffectedOnlyLastComponentKey] = @(keyPathHasOneComponent); + change = newChange.copy; + } + + // If this is a prior notification, clean up all the callbacks added to the + // previous value and call the callback block. Everything else is deferred + // until after we get the notification after the change. + if ([change[NSKeyValueChangeNotificationIsPriorKey] boolValue]) { + [firstComponentDisposable() dispose]; + + if ((options & NSKeyValueObservingOptionPrior) != 0) { + block([trampolineTarget valueForKeyPath:keyPath], change); + } + + return; + } + + // From here the notification is not prior. + NSObject *value = [trampolineTarget valueForKey:keyPathHead]; + + // If the value has changed but is nil, there is no need to add callbacks to + // it, just call the callback block. + if (value == nil) { + block(nil, change); + return; + } + + // From here the notification is not prior and the value is not nil. + + // Create a new firstComponentDisposable while getting rid of the old one at + // the same time, in case this is being called concurrently. + RACDisposable *oldFirstComponentDisposable = [firstComponentSerialDisposable swapInDisposable:[RACCompoundDisposable compoundDisposable]]; + [oldFirstComponentDisposable dispose]; + + addDeallocObserverToPropertyValue(trampolineTarget, keyPathHead, value); + + // If there are no further key path components, there is no need to add the + // other callbacks, just call the callback block with the value itself. + if (keyPathHasOneComponent) { + block(value, change); + return; + } + + // The value has changed, is not nil, and there are more key path components + // to consider. Add the callbacks to the value for the remaining key path + // components and call the callback block with the current value of the full + // key path. + addObserverToValue(value); + block([value valueForKeyPath:keyPathTail], change); + }]; + + // Stop the KVO observation when this one is disposed of. + [disposable addDisposable:trampoline]; + + // Add the callbacks to the initial value if needed. + NSObject *value = [self valueForKey:keyPathHead]; + if (value != nil) { + addDeallocObserverToPropertyValue(self, keyPathHead, value); + + if (!keyPathHasOneComponent) { + addObserverToValue(value); + } + } + + // Call the block with the initial value if needed. + if ((options & NSKeyValueObservingOptionInitial) != 0) { + id initialValue = [self valueForKeyPath:keyPath]; + NSDictionary *initialChange = @{ + NSKeyValueChangeKindKey: @(NSKeyValueChangeSetting), + NSKeyValueChangeNewKey: initialValue ?: NSNull.null, + RACKeyValueChangeCausedByDeallocationKey: @NO, + RACKeyValueChangeAffectedOnlyLastComponentKey: @(keyPathHasOneComponent) + }; + block(initialValue, initialChange); + } + + + RACCompoundDisposable *observerDisposable = observer.rac_deallocDisposable; + RACCompoundDisposable *selfDisposable = self.rac_deallocDisposable; + // Dispose of this observation if the receiver or the observer deallocate. + [observerDisposable addDisposable:disposable]; + [selfDisposable addDisposable:disposable]; + + return [RACDisposable disposableWithBlock:^{ + [disposable dispose]; + [observerDisposable removeDisposable:disposable]; + [selfDisposable removeDisposable:disposable]; + }]; +} + +@end + +@implementation NSObject (RACKVOWrapperDeprecated) + +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wdeprecated-implementations" + +- (RACKVOTrampoline *)rac_addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options block:(RACKVOBlock)block { + return [[RACKVOTrampoline alloc] initWithTarget:self observer:observer keyPath:keyPath options:options block:block]; +} + +#pragma clang diagnostic pop + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACLifting.h b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACLifting.h new file mode 100644 index 0000000..0feb272 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACLifting.h
@@ -0,0 +1,55 @@ +// +// NSObject+RACLifting.h +// iOSDemo +// +// Created by Josh Abernathy on 10/13/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +@class RACSignal; + +@interface NSObject (RACLifting) + +/// Lifts the selector on the receiver into the reactive world. The selector will +/// be invoked whenever any signal argument sends a value, but only after each +/// signal has sent an initial value. +/// +/// It will replay the most recently sent value to new subscribers. +/// +/// This does not support C arrays or unions. +/// +/// selector - The selector on self to invoke. +/// firstSignal - The signal corresponding to the first method argument. This +/// must not be nil. +/// ... - A list of RACSignals corresponding to the remaining arguments. +/// There must be a non-nil signal for each method argument. +/// +/// Examples +/// +/// [button rac_liftSelector:@selector(setTitleColor:forState:) withSignals:textColorSignal, [RACSignal return:@(UIControlStateNormal)], nil]; +/// +/// Returns a signal which sends the return value from each invocation of the +/// selector. If the selector returns void, it instead sends RACUnit.defaultUnit. +/// It completes only after all the signal arguments complete. +- (RACSignal *)rac_liftSelector:(SEL)selector withSignals:(RACSignal *)firstSignal, ... NS_REQUIRES_NIL_TERMINATION; + +/// Like -rac_liftSelector:withSignals:, but accepts an array instead of +/// a variadic list of arguments. +- (RACSignal *)rac_liftSelector:(SEL)selector withSignalsFromArray:(NSArray *)signals; + +@end + +@interface NSObject (RACLiftingDeprecated) + +- (RACSignal *)rac_liftSelector:(SEL)selector withObjects:(id)arg, ... __attribute__((deprecated("Use -rac_liftSelector:withSignals: instead"))); +- (RACSignal *)rac_liftSelector:(SEL)selector withObjectsFromArray:(NSArray *)args __attribute__((deprecated("Use -rac_liftSelector:withSignalsFromArray: instead"))); +- (RACSignal *)rac_liftBlock:(id)block withArguments:(id)arg, ... NS_REQUIRES_NIL_TERMINATION __attribute__((deprecated("Use +combineLatest:reduce: instead"))); +- (RACSignal *)rac_liftBlock:(id)block withArgumentsFromArray:(NSArray *)args __attribute__((deprecated("Use +combineLatest:reduce: instead"))); + +@end + +@interface NSObject (RACLiftingUnavailable) + +- (instancetype)rac_lift __attribute__((unavailable("Use -rac_liftSelector:withSignals: instead"))); + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACLifting.m b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACLifting.m new file mode 100644 index 0000000..96fea76 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACLifting.m
@@ -0,0 +1,132 @@ +// +// NSObject+RACLifting.m +// iOSDemo +// +// Created by Josh Abernathy on 10/13/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "NSObject+RACLifting.h" +#import "EXTScope.h" +#import "NSInvocation+RACTypeParsing.h" +#import "NSObject+RACDeallocating.h" +#import "RACSignal+Operations.h" +#import "RACTuple.h" +#import "NSObject+RACDescription.h" + +@implementation NSObject (RACLifting) + +- (RACSignal *)rac_liftSelector:(SEL)selector withSignalsFromArray:(NSArray *)signals { + NSCParameterAssert(selector != NULL); + NSCParameterAssert(signals != nil); + NSCParameterAssert(signals.count > 0); + + NSMethodSignature *methodSignature = [self methodSignatureForSelector:selector]; + NSCAssert(methodSignature != nil, @"%@ does not respond to %@", self, NSStringFromSelector(selector)); + + NSUInteger numberOfArguments __attribute__((unused)) = methodSignature.numberOfArguments - 2; + NSCAssert(numberOfArguments == signals.count, @"Wrong number of signals for %@ (expected %lu, got %lu)", NSStringFromSelector(selector), (unsigned long)numberOfArguments, (unsigned long)signals.count); + + @unsafeify(self); + + return [[[[[RACSignal + combineLatest:signals] + takeUntil:self.rac_willDeallocSignal] + map:^(RACTuple *arguments) { + @strongify(self); + + NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:methodSignature]; + invocation.selector = selector; + invocation.rac_argumentsTuple = arguments; + [invocation invokeWithTarget:self]; + + return invocation.rac_returnValue; + }] + replayLast] + setNameWithFormat:@"%@ -rac_liftSelector: %s withSignalsFromArray: %@", [self rac_description], sel_getName(selector), signals]; +} + +- (RACSignal *)rac_liftSelector:(SEL)selector withSignals:(RACSignal *)firstSignal, ... { + NSCParameterAssert(firstSignal != nil); + + NSMutableArray *signals = [NSMutableArray array]; + + va_list args; + va_start(args, firstSignal); + for (id currentSignal = firstSignal; currentSignal != nil; currentSignal = va_arg(args, id)) { + NSCAssert([currentSignal isKindOfClass:RACSignal.class], @"Argument %@ is not a RACSignal", currentSignal); + + [signals addObject:currentSignal]; + } + va_end(args); + + return [[self + rac_liftSelector:selector withSignalsFromArray:signals] + setNameWithFormat:@"%@ -rac_liftSelector: %s withSignals: %@", [self rac_description], sel_getName(selector), signals]; +} + +@end + +@implementation NSObject (RACLiftingDeprecated) + +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wdeprecated-implementations" + +static NSArray *RACMapArgumentsToSignals(NSArray *args) { + NSMutableArray *mappedArgs = [NSMutableArray array]; + for (id arg in args) { + if ([arg isEqual:RACTupleNil.tupleNil]) { + [mappedArgs addObject:[RACSignal return:nil]]; + } else if ([arg isKindOfClass:RACSignal.class]) { + [mappedArgs addObject:arg]; + } else { + [mappedArgs addObject:[RACSignal return:arg]]; + } + } + + return mappedArgs; +} + +- (RACSignal *)rac_liftSelector:(SEL)selector withObjects:(id)arg, ... { + NSMethodSignature *methodSignature = [self methodSignatureForSelector:selector]; + NSMutableArray *arguments = [NSMutableArray array]; + + va_list args; + va_start(args, arg); + for (NSUInteger i = 2; i < methodSignature.numberOfArguments; i++) { + id currentObject = (i == 2 ? arg : va_arg(args, id)); + [arguments addObject:currentObject ?: RACTupleNil.tupleNil]; + } + + va_end(args); + return [self rac_liftSelector:selector withObjectsFromArray:arguments]; +} + +- (RACSignal *)rac_liftSelector:(SEL)selector withObjectsFromArray:(NSArray *)args { + return [self rac_liftSelector:selector withSignalsFromArray:RACMapArgumentsToSignals(args)]; +} + +- (RACSignal *)rac_liftBlock:(id)block withArguments:(id)arg, ... { + NSMutableArray *arguments = [NSMutableArray array]; + + va_list args; + va_start(args, arg); + for (id currentObject = arg; currentObject != nil; currentObject = va_arg(args, id)) { + [arguments addObject:currentObject]; + } + + va_end(args); + return [self rac_liftBlock:block withArgumentsFromArray:arguments]; +} + +- (RACSignal *)rac_liftBlock:(id)block withArgumentsFromArray:(NSArray *)args { + return [[[[RACSignal + combineLatest:RACMapArgumentsToSignals(args)] + reduceEach:block] + takeUntil:self.rac_willDeallocSignal] + replayLast]; +} + +#pragma clang diagnostic pop + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACPropertySubscribing.h b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACPropertySubscribing.h new file mode 100644 index 0000000..2f55195 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACPropertySubscribing.h
@@ -0,0 +1,102 @@ +// +// NSObject+RACPropertySubscribing.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 3/2/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import <Foundation/Foundation.h> +#import "EXTKeyPathCoding.h" +#import "metamacros.h" + +/// Creates a signal which observes `KEYPATH` on `TARGET` for changes. +/// +/// In either case, the observation continues until `TARGET` _or self_ is +/// deallocated. If any intermediate object is deallocated instead, it will be +/// assumed to have been set to nil. +/// +/// Make sure to `@strongify(self)` when using this macro within a block! The +/// macro will _always_ reference `self`, which can silently introduce a retain +/// cycle within a block. As a result, you should make sure that `self` is a weak +/// reference (e.g., created by `@weakify` and `@strongify`) before the +/// expression that uses `RACObserve`. +/// +/// Examples +/// +/// // Observes self, and doesn't stop until self is deallocated. +/// RACSignal *selfSignal = RACObserve(self, arrayController.items); +/// +/// // Observes the array controller, and stops when self _or_ the array +/// // controller is deallocated. +/// RACSignal *arrayControllerSignal = RACObserve(self.arrayController, items); +/// +/// // Observes obj.arrayController, and stops when self _or_ the array +/// // controller is deallocated. +/// RACSignal *signal2 = RACObserve(obj.arrayController, items); +/// +/// @weakify(self); +/// RACSignal *signal3 = [anotherSignal flattenMap:^(NSArrayController *arrayController) { +/// // Avoids a retain cycle because of RACObserve implicitly referencing +/// // self. +/// @strongify(self); +/// return RACObserve(arrayController, items); +/// }]; +/// +/// Returns a signal which sends the current value of the key path on +/// subscription, then sends the new value every time it changes, and sends +/// completed if self or observer is deallocated. +#define RACObserve(TARGET, KEYPATH) \ + [(id)(TARGET) rac_valuesForKeyPath:@keypath(TARGET, KEYPATH) observer:self] + +@class RACDisposable; +@class RACSignal; + +@interface NSObject (RACPropertySubscribing) + +/// Creates a signal to observe the value at the given key path. +/// +/// The initial value is sent on subscription, the subsequent values are sent +/// from whichever thread the change occured on, even if it doesn't have a valid +/// scheduler. +/// +/// Returns a signal that immediately sends the receiver's current value at the +/// given keypath, then any changes thereafter. +- (RACSignal *)rac_valuesForKeyPath:(NSString *)keyPath observer:(NSObject *)observer; + +/// Creates a signal to observe the changes of the given key path. +/// +/// The initial value is sent on subscription, the subsequent values are sent +/// from whichever thread the change occured on, even if it doesn't have a valid +/// scheduler. +/// +/// Returns a signal that sends tuples containing the current value at the key +/// path and the change dictionary for each KVO callback. +- (RACSignal *)rac_valuesAndChangesForKeyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options observer:(NSObject *)observer; + +@end + +#define RACAble(...) \ + metamacro_if_eq(1, metamacro_argcount(__VA_ARGS__)) \ + (_RACAbleObject(self, __VA_ARGS__)) \ + (_RACAbleObject(__VA_ARGS__)) + +#define _RACAbleObject(object, property) [object rac_signalForKeyPath:@keypath(object, property) observer:self] + +#define RACAbleWithStart(...) \ + metamacro_if_eq(1, metamacro_argcount(__VA_ARGS__)) \ + (_RACAbleWithStartObject(self, __VA_ARGS__)) \ + (_RACAbleWithStartObject(__VA_ARGS__)) + +#define _RACAbleWithStartObject(object, property) [object rac_signalWithStartingValueForKeyPath:@keypath(object, property) observer:self] + +@interface NSObject (RACPropertySubscribingDeprecated) + ++ (RACSignal *)rac_signalFor:(NSObject *)object keyPath:(NSString *)keyPath observer:(NSObject *)observer __attribute__((deprecated("Use -rac_valuesForKeyPath:observer: or RACObserve() instead."))); ++ (RACSignal *)rac_signalWithStartingValueFor:(NSObject *)object keyPath:(NSString *)keyPath observer:(NSObject *)observer __attribute__((deprecated("Use -rac_valuesForKeyPath:observer: or RACObserve() instead."))); ++ (RACSignal *)rac_signalWithChangesFor:(NSObject *)object keyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options observer:(NSObject *)observer __attribute__((deprecated("Use -rac_valuesAndChangesForKeyPath:options:observer: instead."))); +- (RACSignal *)rac_signalForKeyPath:(NSString *)keyPath observer:(NSObject *)observer __attribute__((deprecated("Use -rac_valuesForKeyPath:observer: or RACObserve() instead."))); +- (RACSignal *)rac_signalWithStartingValueForKeyPath:(NSString *)keyPath observer:(NSObject *)observer __attribute__((deprecated("Use -rac_valuesForKeyPath:observer: or RACObserve() instead."))); +- (RACDisposable *)rac_deriveProperty:(NSString *)keyPath from:(RACSignal *)signal __attribute__((deprecated("Use -[RACSignal setKeyPath:onObject:] instead"))); + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACPropertySubscribing.m b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACPropertySubscribing.m new file mode 100644 index 0000000..edd2acb --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACPropertySubscribing.m
@@ -0,0 +1,161 @@ +// +// NSObject+RACPropertySubscribing.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 3/2/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "NSObject+RACPropertySubscribing.h" +#import "EXTScope.h" +#import "NSObject+RACDeallocating.h" +#import "NSObject+RACDescription.h" +#import "NSObject+RACKVOWrapper.h" +#import "RACCompoundDisposable.h" +#import "RACDisposable.h" +#import "RACKVOTrampoline.h" +#import "RACSubscriber.h" +#import "RACSignal+Operations.h" +#import "RACTuple.h" +#import <libkern/OSAtomic.h> + +@implementation NSObject (RACPropertySubscribing) + +- (RACSignal *)rac_valuesForKeyPath:(NSString *)keyPath observer:(NSObject *)observer { + return [[[self + rac_valuesAndChangesForKeyPath:keyPath options:NSKeyValueObservingOptionInitial observer:observer] + reduceEach:^(id value, NSDictionary *change) { + return value; + }] + setNameWithFormat:@"RACObserve(%@, %@)", self.rac_description, keyPath]; +} + +- (RACSignal *)rac_valuesAndChangesForKeyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options observer:(NSObject *)observer { + keyPath = [keyPath copy]; + + NSRecursiveLock *objectLock = [[NSRecursiveLock alloc] init]; + objectLock.name = @"com.github.ReactiveCocoa.NSObjectRACPropertySubscribing"; + + __block __unsafe_unretained NSObject *unsafeSelf = self; + __block __unsafe_unretained NSObject *unsafeObserver = observer; + + RACSignal *deallocSignal = [[RACSignal + zip:@[ + self.rac_willDeallocSignal, + observer.rac_willDeallocSignal ?: [RACSignal never] + ]] + doCompleted:^{ + // Forces deallocation to wait if the object variables are currently + // being read on another thread. + [objectLock lock]; + @onExit { + [objectLock unlock]; + }; + + unsafeSelf = nil; + unsafeObserver = nil; + }]; + + return [[[RACSignal + createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) { + // Hold onto the lock the whole time we're setting up the KVO + // observation, because any resurrection that might be caused by our + // retaining below must be balanced out by the time -dealloc returns + // (if another thread is waiting on the lock above). + [objectLock lock]; + @onExit { + [objectLock unlock]; + }; + + __strong NSObject *observer __attribute__((objc_precise_lifetime)) = unsafeObserver; + __strong NSObject *self __attribute__((objc_precise_lifetime)) = unsafeSelf; + + if (self == nil) { + [subscriber sendCompleted]; + return nil; + } + + return [self rac_observeKeyPath:keyPath options:options observer:observer block:^(id value, NSDictionary *change) { + [subscriber sendNext:RACTuplePack(value, change)]; + }]; + }] + takeUntil:deallocSignal] + setNameWithFormat:@"%@ -rac_valueAndChangesForKeyPath: %@ options: %lu observer: %@", self.rac_description, keyPath, (unsigned long)options, observer.rac_description]; +} + +@end + +static RACSignal *signalWithoutChangesFor(Class class, NSObject *object, NSString *keyPath, NSKeyValueObservingOptions options, NSObject *observer) { + NSCParameterAssert(object != nil); + NSCParameterAssert(keyPath != nil); + NSCParameterAssert(observer != nil); + + keyPath = [keyPath copy]; + + @unsafeify(object); + + return [[class + rac_signalWithChangesFor:object keyPath:keyPath options:options observer:observer] + map:^(NSDictionary *change) { + @strongify(object); + return [object valueForKeyPath:keyPath]; + }]; +} + +@implementation NSObject (RACPropertySubscribingDeprecated) + +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wdeprecated-implementations" + ++ (RACSignal *)rac_signalFor:(NSObject *)object keyPath:(NSString *)keyPath observer:(NSObject *)observer { + return signalWithoutChangesFor(self, object, keyPath, 0, observer); +} + ++ (RACSignal *)rac_signalWithStartingValueFor:(NSObject *)object keyPath:(NSString *)keyPath observer:(NSObject *)observer { + return signalWithoutChangesFor(self, object, keyPath, NSKeyValueObservingOptionInitial, observer); +} + ++ (RACSignal *)rac_signalWithChangesFor:(NSObject *)object keyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options observer:(NSObject *)observer { + @unsafeify(observer, object); + return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) { + + @strongify(observer, object); + RACKVOTrampoline *KVOTrampoline = [object rac_addObserver:observer forKeyPath:keyPath options:options block:^(id target, id observer, NSDictionary *change) { + [subscriber sendNext:change]; + }]; + + @weakify(subscriber); + RACDisposable *deallocDisposable = [RACDisposable disposableWithBlock:^{ + @strongify(subscriber); + [KVOTrampoline dispose]; + [subscriber sendCompleted]; + }]; + + [observer.rac_deallocDisposable addDisposable:deallocDisposable]; + [object.rac_deallocDisposable addDisposable:deallocDisposable]; + + RACCompoundDisposable *observerDisposable = observer.rac_deallocDisposable; + RACCompoundDisposable *objectDisposable = object.rac_deallocDisposable; + return [RACDisposable disposableWithBlock:^{ + [observerDisposable removeDisposable:deallocDisposable]; + [objectDisposable removeDisposable:deallocDisposable]; + [KVOTrampoline dispose]; + }]; + }] setNameWithFormat:@"RACAble(%@, %@)", object.rac_description, keyPath]; +} + +- (RACSignal *)rac_signalForKeyPath:(NSString *)keyPath observer:(NSObject *)observer { + return [self.class rac_signalFor:self keyPath:keyPath observer:observer]; +} + +- (RACSignal *)rac_signalWithStartingValueForKeyPath:(NSString *)keyPath observer:(NSObject *)observer { + return [self.class rac_signalWithStartingValueFor:self keyPath:keyPath observer:observer]; +} + +- (RACDisposable *)rac_deriveProperty:(NSString *)keyPath from:(RACSignal *)signal { + return [signal setKeyPath:keyPath onObject:self]; +} + +#pragma clang diagnostic pop + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACSelectorSignal.h b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACSelectorSignal.h new file mode 100644 index 0000000..c6f3de5 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACSelectorSignal.h
@@ -0,0 +1,79 @@ +// +// NSObject+RACSelectorSignal.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 3/18/13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import <Foundation/Foundation.h> + +@class RACSignal; + +/// The domain for any errors originating from -rac_signalForSelector:. +extern NSString * const RACSelectorSignalErrorDomain; + +/// -rac_signalForSelector: was going to add a new method implementation for +/// `selector`, but another thread added an implementation before it was able to. +/// +/// This will _not_ occur for cases where a method implementation exists before +/// -rac_signalForSelector: is invoked. +extern const NSInteger RACSelectorSignalErrorMethodSwizzlingRace; + +@interface NSObject (RACSelectorSignal) + +/// Creates a signal associated with the receiver, which will send a tuple of the +/// method's arguments each time the given selector is invoked. +/// +/// If the selector is already implemented on the receiver, the existing +/// implementation will be invoked _before_ the signal fires. +/// +/// If the selector is not yet implemented on the receiver, the injected +/// implementation will have a `void` return type and accept only object +/// arguments. Invoking the added implementation with non-object values, or +/// expecting a return value, will result in undefined behavior. +/// +/// This is useful for changing an event or delegate callback into a signal. For +/// example, on an NSView: +/// +/// [[view rac_signalForSelector:@selector(mouseDown:)] subscribeNext:^(RACTuple *args) { +/// NSEvent *event = args.first; +/// NSLog(@"mouse button pressed: %@", event); +/// }]; +/// +/// selector - The selector for whose invocations are to be observed. If it +/// doesn't exist, it will be implemented to accept object arguments +/// and return void. This cannot have C arrays or unions as arguments +/// or C arrays, unions, structs, complex or vector types as return +/// type. +/// +/// Returns a signal which will send a tuple of arguments upon each invocation of +/// the selector, then completes when the receiver is deallocated. `next` events +/// will be sent synchronously from the thread that invoked the method. If +/// a runtime call fails, the signal will send an error in the +/// RACSelectorSignalErrorDomain. +- (RACSignal *)rac_signalForSelector:(SEL)selector; + +/// Behaves like -rac_signalForSelector:, but if the selector is not yet +/// implemented on the receiver, its method signature is looked up within +/// `protocol`, and may accept non-object arguments. +/// +/// If the selector is not yet implemented and has a return value, the injected +/// method will return all zero bits (equal to `nil`, `NULL`, 0, 0.0f, etc.). +/// +/// selector - The selector for whose invocations are to be observed. If it +/// doesn't exist, it will be implemented using information from +/// `protocol`, and may accept non-object arguments and return +/// a value. This cannot have C arrays or unions as arguments or +/// return type. +/// protocol - The protocol in which `selector` is declared. This will be used +/// for type information if the selector is not already implemented on +/// the receiver. This must not be `NULL`, and `selector` must exist +/// in this protocol. +/// +/// Returns a signal which will send a tuple of arguments on each invocation of +/// the selector, or an error in RACSelectorSignalErrorDomain if a runtime +/// call fails. +- (RACSignal *)rac_signalForSelector:(SEL)selector fromProtocol:(Protocol *)protocol; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACSelectorSignal.m b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACSelectorSignal.m new file mode 100644 index 0000000..4c3aab9 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSObject+RACSelectorSignal.m
@@ -0,0 +1,322 @@ +// +// NSObject+RACSelectorSignal.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 3/18/13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "NSObject+RACSelectorSignal.h" +#import "EXTRuntimeExtensions.h" +#import "NSInvocation+RACTypeParsing.h" +#import "NSObject+RACDeallocating.h" +#import "RACCompoundDisposable.h" +#import "RACDisposable.h" +#import "RACObjCRuntime.h" +#import "RACSubject.h" +#import "RACTuple.h" +#import "NSObject+RACDescription.h" +#import <objc/message.h> +#import <objc/runtime.h> + +NSString * const RACSelectorSignalErrorDomain = @"RACSelectorSignalErrorDomain"; +const NSInteger RACSelectorSignalErrorMethodSwizzlingRace = 1; + +static NSString * const RACSignalForSelectorAliasPrefix = @"rac_alias_"; +static NSString * const RACSubclassSuffix = @"_RACSelectorSignal"; + +static NSMutableSet *swizzledClasses() { + static NSMutableSet *set; + static dispatch_once_t pred; + + dispatch_once(&pred, ^{ + set = [[NSMutableSet alloc] init]; + }); + + return set; +} + +@implementation NSObject (RACSelectorSignal) + +static BOOL RACForwardInvocation(id self, NSInvocation *invocation) { + SEL aliasSelector = RACAliasForSelector(invocation.selector); + RACSubject *subject = objc_getAssociatedObject(self, aliasSelector); + + Class class = object_getClass(invocation.target); + BOOL respondsToAlias = [class instancesRespondToSelector:aliasSelector]; + if (respondsToAlias) { + invocation.selector = aliasSelector; + [invocation invoke]; + } + + if (subject == nil) return respondsToAlias; + + [subject sendNext:invocation.rac_argumentsTuple]; + return YES; +} + +static void RACSwizzleForwardInvocation(Class class) { + SEL forwardInvocationSEL = @selector(forwardInvocation:); + Method forwardInvocationMethod = class_getInstanceMethod(class, forwardInvocationSEL); + + // Preserve any existing implementation of -forwardInvocation:. + void (*originalForwardInvocation)(id, SEL, NSInvocation *) = NULL; + if (forwardInvocationMethod != NULL) { + originalForwardInvocation = (__typeof__(originalForwardInvocation))method_getImplementation(forwardInvocationMethod); + } + + // Set up a new version of -forwardInvocation:. + // + // If the selector has been passed to -rac_signalForSelector:, invoke + // the aliased method, and forward the arguments to any attached signals. + // + // If the selector has not been passed to -rac_signalForSelector:, + // invoke any existing implementation of -forwardInvocation:. If there + // was no existing implementation, throw an unrecognized selector + // exception. + id newForwardInvocation = ^(id self, NSInvocation *invocation) { + BOOL matched = RACForwardInvocation(self, invocation); + if (matched) return; + + if (originalForwardInvocation == NULL) { + [self doesNotRecognizeSelector:invocation.selector]; + } else { + originalForwardInvocation(self, forwardInvocationSEL, invocation); + } + }; + + class_replaceMethod(class, forwardInvocationSEL, imp_implementationWithBlock(newForwardInvocation), "v@:@"); +} + +static void RACSwizzleRespondsToSelector(Class class) { + SEL respondsToSelectorSEL = @selector(respondsToSelector:); + + // Preserve existing implementation of -respondsToSelector:. + Method respondsToSelectorMethod = class_getInstanceMethod(class, respondsToSelectorSEL); + BOOL (*originalRespondsToSelector)(id, SEL, SEL) = (__typeof__(originalRespondsToSelector))method_getImplementation(respondsToSelectorMethod); + + // Set up a new version of -respondsToSelector: that returns YES for methods + // added by -rac_signalForSelector:. + // + // If the selector has a method defined on the receiver's actual class, and + // if that method's implementation is _objc_msgForward, then returns whether + // the instance has a signal for the selector. + // Otherwise, call the original -respondsToSelector:. + id newRespondsToSelector = ^ BOOL (id self, SEL selector) { + Method method = rac_getImmediateInstanceMethod(object_getClass(self), selector); + + if (method != NULL && method_getImplementation(method) == _objc_msgForward) { + SEL aliasSelector = RACAliasForSelector(selector); + return objc_getAssociatedObject(self, aliasSelector) != nil; + } + + return originalRespondsToSelector(self, respondsToSelectorSEL, selector); + }; + + class_replaceMethod(class, respondsToSelectorSEL, imp_implementationWithBlock(newRespondsToSelector), method_getTypeEncoding(respondsToSelectorMethod)); +} + +static void RACSwizzleGetClass(Class class, Class statedClass) { + SEL selector = @selector(class); + Method method = class_getInstanceMethod(class, selector); + IMP newIMP = imp_implementationWithBlock(^(id self) { + return statedClass; + }); + class_replaceMethod(class, selector, newIMP, method_getTypeEncoding(method)); +} + +static void RACSwizzleMethodSignatureForSelector(Class class) { + IMP newIMP = imp_implementationWithBlock(^(id self, SEL selector) { + // Don't send the -class message to the receiver because we've changed + // that to return the original class. + Class actualClass = object_getClass(self); + Method method = class_getInstanceMethod(actualClass, selector); + if (method == NULL) { + // Messages that the original class dynamically implements fall + // here. + // + // Call the original class' -methodSignatureForSelector:. + struct objc_super target = { + .super_class = class_getSuperclass(class), + .receiver = self, + }; + NSMethodSignature * (*messageSend)(struct objc_super *, SEL, SEL) = (__typeof__(messageSend))objc_msgSendSuper; + return messageSend(&target, @selector(methodSignatureForSelector:), selector); + } + + char const *encoding = method_getTypeEncoding(method); + return [NSMethodSignature signatureWithObjCTypes:encoding]; + }); + + SEL selector = @selector(methodSignatureForSelector:); + Method methodSignatureForSelectorMethod = class_getInstanceMethod(class, selector); + class_replaceMethod(class, selector, newIMP, method_getTypeEncoding(methodSignatureForSelectorMethod)); +} + +// It's hard to tell which struct return types use _objc_msgForward, and +// which use _objc_msgForward_stret instead, so just exclude all struct, array, +// union, complex and vector return types. +static void RACCheckTypeEncoding(const char *typeEncoding) { +#if !NS_BLOCK_ASSERTIONS + // Some types, including vector types, are not encoded. In these cases the + // signature starts with the size of the argument frame. + NSCAssert(*typeEncoding < '1' || *typeEncoding > '9', @"unknown method return type not supported in type encoding: %s", typeEncoding); + NSCAssert(strstr(typeEncoding, "(") != typeEncoding, @"union method return type not supported"); + NSCAssert(strstr(typeEncoding, "{") != typeEncoding, @"struct method return type not supported"); + NSCAssert(strstr(typeEncoding, "[") != typeEncoding, @"array method return type not supported"); + NSCAssert(strstr(typeEncoding, @encode(_Complex float)) != typeEncoding, @"complex float method return type not supported"); + NSCAssert(strstr(typeEncoding, @encode(_Complex double)) != typeEncoding, @"complex double method return type not supported"); + NSCAssert(strstr(typeEncoding, @encode(_Complex long double)) != typeEncoding, @"complex long double method return type not supported"); + +#endif // !NS_BLOCK_ASSERTIONS +} + +static RACSignal *NSObjectRACSignalForSelector(NSObject *self, SEL selector, Protocol *protocol) { + SEL aliasSelector = RACAliasForSelector(selector); + + @synchronized (self) { + RACSubject *subject = objc_getAssociatedObject(self, aliasSelector); + if (subject != nil) return subject; + + Class class = RACSwizzleClass(self); + NSCAssert(class != nil, @"Could not swizzle class of %@", self); + + subject = [[RACSubject subject] setNameWithFormat:@"%@ -rac_signalForSelector: %s", self.rac_description, sel_getName(selector)]; + objc_setAssociatedObject(self, aliasSelector, subject, OBJC_ASSOCIATION_RETAIN); + + [self.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + [subject sendCompleted]; + }]]; + + Method targetMethod = class_getInstanceMethod(class, selector); + if (targetMethod == NULL) { + const char *typeEncoding; + if (protocol == NULL) { + typeEncoding = RACSignatureForUndefinedSelector(selector); + } else { + // Look for the selector as an optional instance method. + struct objc_method_description methodDescription = protocol_getMethodDescription(protocol, selector, NO, YES); + + if (methodDescription.name == NULL) { + // Then fall back to looking for a required instance + // method. + methodDescription = protocol_getMethodDescription(protocol, selector, YES, YES); + NSCAssert(methodDescription.name != NULL, @"Selector %@ does not exist in <%s>", NSStringFromSelector(selector), protocol_getName(protocol)); + } + + typeEncoding = methodDescription.types; + } + + RACCheckTypeEncoding(typeEncoding); + + // Define the selector to call -forwardInvocation:. + if (!class_addMethod(class, selector, _objc_msgForward, typeEncoding)) { + NSDictionary *userInfo = @{ + NSLocalizedDescriptionKey: [NSString stringWithFormat:NSLocalizedString(@"A race condition occurred implementing %@ on class %@", nil), NSStringFromSelector(selector), class], + NSLocalizedRecoverySuggestionErrorKey: NSLocalizedString(@"Invoke -rac_signalForSelector: again to override the implementation.", nil) + }; + + return [RACSignal error:[NSError errorWithDomain:RACSelectorSignalErrorDomain code:RACSelectorSignalErrorMethodSwizzlingRace userInfo:userInfo]]; + } + } else if (method_getImplementation(targetMethod) != _objc_msgForward) { + // Make a method alias for the existing method implementation. + const char *typeEncoding = method_getTypeEncoding(targetMethod); + + RACCheckTypeEncoding(typeEncoding); + + BOOL addedAlias __attribute__((unused)) = class_addMethod(class, aliasSelector, method_getImplementation(targetMethod), typeEncoding); + NSCAssert(addedAlias, @"Original implementation for %@ is already copied to %@ on %@", NSStringFromSelector(selector), NSStringFromSelector(aliasSelector), class); + + // Redefine the selector to call -forwardInvocation:. + class_replaceMethod(class, selector, _objc_msgForward, method_getTypeEncoding(targetMethod)); + } + + return subject; + } +} + +static SEL RACAliasForSelector(SEL originalSelector) { + NSString *selectorName = NSStringFromSelector(originalSelector); + return NSSelectorFromString([RACSignalForSelectorAliasPrefix stringByAppendingString:selectorName]); +} + +static const char *RACSignatureForUndefinedSelector(SEL selector) { + const char *name = sel_getName(selector); + NSMutableString *signature = [NSMutableString stringWithString:@"v@:"]; + + while ((name = strchr(name, ':')) != NULL) { + [signature appendString:@"@"]; + name++; + } + + return signature.UTF8String; +} + +static Class RACSwizzleClass(NSObject *self) { + Class statedClass = self.class; + Class baseClass = object_getClass(self); + NSString *className = NSStringFromClass(baseClass); + + if ([className hasSuffix:RACSubclassSuffix]) { + return baseClass; + } else if (statedClass != baseClass) { + // If the class is already lying about what it is, it's probably a KVO + // dynamic subclass or something else that we shouldn't subclass + // ourselves. + // + // Just swizzle -forwardInvocation: in-place. Since the object's class + // was almost certainly dynamically changed, we shouldn't see another of + // these classes in the hierarchy. + // + // Additionally, swizzle -respondsToSelector: because the default + // implementation may be ignorant of methods added to this class. + @synchronized (swizzledClasses()) { + if (![swizzledClasses() containsObject:className]) { + RACSwizzleForwardInvocation(baseClass); + RACSwizzleRespondsToSelector(baseClass); + RACSwizzleGetClass(baseClass, statedClass); + RACSwizzleGetClass(object_getClass(baseClass), statedClass); + RACSwizzleMethodSignatureForSelector(baseClass); + [swizzledClasses() addObject:className]; + } + } + + return baseClass; + } + + const char *subclassName = [className stringByAppendingString:RACSubclassSuffix].UTF8String; + Class subclass = objc_getClass(subclassName); + + if (subclass == nil) { + subclass = [RACObjCRuntime createClass:subclassName inheritingFromClass:baseClass]; + if (subclass == nil) return nil; + + RACSwizzleForwardInvocation(subclass); + RACSwizzleRespondsToSelector(subclass); + + RACSwizzleGetClass(subclass, statedClass); + RACSwizzleGetClass(object_getClass(subclass), statedClass); + + RACSwizzleMethodSignatureForSelector(subclass); + + objc_registerClassPair(subclass); + } + + object_setClass(self, subclass); + return subclass; +} + +- (RACSignal *)rac_signalForSelector:(SEL)selector { + NSCParameterAssert(selector != NULL); + + return NSObjectRACSignalForSelector(self, selector, NULL); +} + +- (RACSignal *)rac_signalForSelector:(SEL)selector fromProtocol:(Protocol *)protocol { + NSCParameterAssert(selector != NULL); + NSCParameterAssert(protocol != NULL); + + return NSObjectRACSignalForSelector(self, selector, protocol); +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSOrderedSet+RACSequenceAdditions.h b/ReactiveCocoaFramework/ReactiveCocoa/NSOrderedSet+RACSequenceAdditions.h new file mode 100644 index 0000000..8bea2db --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSOrderedSet+RACSequenceAdditions.h
@@ -0,0 +1,20 @@ +// +// NSOrderedSet+RACSequenceAdditions.h +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-10-29. +// Copyright (c) 2012 GitHub. All rights reserved. +// + +#import <Foundation/Foundation.h> + +@class RACSequence; + +@interface NSOrderedSet (RACSequenceAdditions) + +/// Creates and returns a sequence corresponding to the receiver. +/// +/// Mutating the receiver will not affect the sequence after it's been created. +@property (nonatomic, copy, readonly) RACSequence *rac_sequence; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSOrderedSet+RACSequenceAdditions.m b/ReactiveCocoaFramework/ReactiveCocoa/NSOrderedSet+RACSequenceAdditions.m new file mode 100644 index 0000000..55dfd0b --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSOrderedSet+RACSequenceAdditions.m
@@ -0,0 +1,19 @@ +// +// NSOrderedSet+RACSequenceAdditions.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-10-29. +// Copyright (c) 2012 GitHub. All rights reserved. +// + +#import "NSOrderedSet+RACSequenceAdditions.h" +#import "NSArray+RACSequenceAdditions.h" + +@implementation NSOrderedSet (RACSequenceAdditions) + +- (RACSequence *)rac_sequence { + // TODO: First class support for ordered set sequences. + return self.array.rac_sequence; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSSet+RACSequenceAdditions.h b/ReactiveCocoaFramework/ReactiveCocoa/NSSet+RACSequenceAdditions.h new file mode 100644 index 0000000..6665501 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSSet+RACSequenceAdditions.h
@@ -0,0 +1,20 @@ +// +// NSSet+RACSequenceAdditions.h +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-10-29. +// Copyright (c) 2012 GitHub. All rights reserved. +// + +#import <Foundation/Foundation.h> + +@class RACSequence; + +@interface NSSet (RACSequenceAdditions) + +/// Creates and returns a sequence corresponding to the receiver. +/// +/// Mutating the receiver will not affect the sequence after it's been created. +@property (nonatomic, copy, readonly) RACSequence *rac_sequence; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSSet+RACSequenceAdditions.m b/ReactiveCocoaFramework/ReactiveCocoa/NSSet+RACSequenceAdditions.m new file mode 100644 index 0000000..cc07f75 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSSet+RACSequenceAdditions.m
@@ -0,0 +1,19 @@ +// +// NSSet+RACSequenceAdditions.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-10-29. +// Copyright (c) 2012 GitHub. All rights reserved. +// + +#import "NSSet+RACSequenceAdditions.h" +#import "NSArray+RACSequenceAdditions.h" + +@implementation NSSet (RACSequenceAdditions) + +- (RACSequence *)rac_sequence { + // TODO: First class support for set sequences. + return self.allObjects.rac_sequence; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSString+RACKeyPathUtilities.h b/ReactiveCocoaFramework/ReactiveCocoa/NSString+RACKeyPathUtilities.h new file mode 100644 index 0000000..d56cf59 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSString+RACKeyPathUtilities.h
@@ -0,0 +1,34 @@ +// +// NSString+RACKeyPathUtilities.h +// ReactiveCocoa +// +// Created by Uri Baghin on 05/05/2013. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import <Foundation/Foundation.h> + +// A private category of methods to extract parts of a key path. +@interface NSString (RACKeyPathUtilities) + +// Returns an array of the components of the receiver. +// +// Calling this method on a string that isn't a key path is considered undefined +// behavior. +- (NSArray *)rac_keyPathComponents; + +// Returns a key path with all the components of the receiver except for the +// last one. +// +// Calling this method on a string that isn't a key path is considered undefined +// behavior. +- (NSString *)rac_keyPathByDeletingLastKeyPathComponent; + +// Returns a key path with all the components of the receiver expect for the +// first one. +// +// Calling this method on a string that isn't a key path is considered undefined +// behavior. +- (NSString *)rac_keyPathByDeletingFirstKeyPathComponent; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSString+RACKeyPathUtilities.m b/ReactiveCocoaFramework/ReactiveCocoa/NSString+RACKeyPathUtilities.m new file mode 100644 index 0000000..63a100c --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSString+RACKeyPathUtilities.m
@@ -0,0 +1,36 @@ +// +// NSString+RACKeyPathUtilities.m +// ReactiveCocoa +// +// Created by Uri Baghin on 05/05/2013. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "NSString+RACKeyPathUtilities.h" + +@implementation NSString (RACKeyPathUtilities) + +- (NSArray *)rac_keyPathComponents { + if (self.length == 0) { + return nil; + } + return [self componentsSeparatedByString:@"."]; +} + +- (NSString *)rac_keyPathByDeletingLastKeyPathComponent { + NSUInteger lastDotIndex = [self rangeOfString:@"." options:NSBackwardsSearch].location; + if (lastDotIndex == NSNotFound) { + return nil; + } + return [self substringToIndex:lastDotIndex]; +} + +- (NSString *)rac_keyPathByDeletingFirstKeyPathComponent { + NSUInteger firstDotIndex = [self rangeOfString:@"."].location; + if (firstDotIndex == NSNotFound) { + return nil; + } + return [self substringFromIndex:firstDotIndex + 1]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSString+RACSequenceAdditions.h b/ReactiveCocoaFramework/ReactiveCocoa/NSString+RACSequenceAdditions.h new file mode 100644 index 0000000..0116231 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSString+RACSequenceAdditions.h
@@ -0,0 +1,21 @@ +// +// NSString+RACSequenceAdditions.h +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-10-29. +// Copyright (c) 2012 GitHub. All rights reserved. +// + +#import <Foundation/Foundation.h> + +@class RACSequence; + +@interface NSString (RACSequenceAdditions) + +/// Creates and returns a sequence containing strings corresponding to each +/// composed character sequence in the receiver. +/// +/// Mutating the receiver will not affect the sequence after it's been created. +@property (nonatomic, copy, readonly) RACSequence *rac_sequence; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSString+RACSequenceAdditions.m b/ReactiveCocoaFramework/ReactiveCocoa/NSString+RACSequenceAdditions.m new file mode 100644 index 0000000..eb6a76e --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSString+RACSequenceAdditions.m
@@ -0,0 +1,18 @@ +// +// NSString+RACSequenceAdditions.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-10-29. +// Copyright (c) 2012 GitHub. All rights reserved. +// + +#import "NSString+RACSequenceAdditions.h" +#import "RACStringSequence.h" + +@implementation NSString (RACSequenceAdditions) + +- (RACSequence *)rac_sequence { + return [RACStringSequence sequenceWithString:self offset:0]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSString+RACSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/NSString+RACSupport.h new file mode 100644 index 0000000..d904a4c --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSString+RACSupport.h
@@ -0,0 +1,22 @@ +// +// NSString+RACSupport.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 5/11/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import <Foundation/Foundation.h> + +@class RACSignal; +@class RACScheduler; + +@interface NSString (RACSupport) + +// Reads in the contents of the file using +[NSString stringWithContentsOfURL:usedEncoding:error:]. +// Note that encoding won't be valid until the signal completes successfully. +// +// scheduler - cannot be nil. ++ (RACSignal *)rac_readContentsOfURL:(NSURL *)URL usedEncoding:(NSStringEncoding *)encoding scheduler:(RACScheduler *)scheduler; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSString+RACSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/NSString+RACSupport.m new file mode 100644 index 0000000..c6ebe0b --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSString+RACSupport.m
@@ -0,0 +1,35 @@ +// +// NSString+RACSupport.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 5/11/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "NSString+RACSupport.h" +#import "RACReplaySubject.h" +#import "RACScheduler.h" + +@implementation NSString (RACSupport) + ++ (RACSignal *)rac_readContentsOfURL:(NSURL *)URL usedEncoding:(NSStringEncoding *)encoding scheduler:(RACScheduler *)scheduler { + NSCParameterAssert(scheduler != nil); + + RACReplaySubject *subject = [RACReplaySubject subject]; + [subject setNameWithFormat:@"+rac_readContentsOfURL: %@ usedEncoding:scheduler: %@", URL, scheduler]; + + [scheduler schedule:^{ + NSError *error = nil; + NSString *string = [NSString stringWithContentsOfURL:URL usedEncoding:encoding error:&error]; + if(string == nil) { + [subject sendError:error]; + } else { + [subject sendNext:string]; + [subject sendCompleted]; + } + }]; + + return subject; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSText+RACSignalSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/NSText+RACSignalSupport.h new file mode 100644 index 0000000..e3fc8ed --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSText+RACSignalSupport.h
@@ -0,0 +1,19 @@ +// +// NSText+RACSignalSupport.h +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-03-08. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import <Cocoa/Cocoa.h> + +@class RACSignal; + +@interface NSText (RACSignalSupport) + +/// Returns a signal which sends the current `string` of the receiver, then the +/// new value any time it changes. +- (RACSignal *)rac_textSignal; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSText+RACSignalSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/NSText+RACSignalSupport.m new file mode 100644 index 0000000..7e63f2a --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSText+RACSignalSupport.m
@@ -0,0 +1,38 @@ +// +// NSText+RACSignalSupport.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-03-08. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "NSText+RACSignalSupport.h" +#import "EXTScope.h" +#import "RACDisposable.h" +#import "RACSignal.h" +#import "RACSubscriber.h" +#import "NSObject+RACDescription.h" + +@implementation NSText (RACSignalSupport) + +- (RACSignal *)rac_textSignal { + @unsafeify(self); + return [[[[RACSignal + createSignal:^(id<RACSubscriber> subscriber) { + @strongify(self); + id observer = [NSNotificationCenter.defaultCenter addObserverForName:NSTextDidChangeNotification object:self queue:nil usingBlock:^(NSNotification *note) { + [subscriber sendNext:note.object]; + }]; + + return [RACDisposable disposableWithBlock:^{ + [NSNotificationCenter.defaultCenter removeObserver:observer]; + }]; + }] + map:^(NSText *text) { + return [text.string copy]; + }] + startWith:[self.string copy]] + setNameWithFormat:@"%@ -rac_textSignal", [self rac_description]]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSURLConnection+RACSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/NSURLConnection+RACSupport.h new file mode 100644 index 0000000..e9bf04f --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSURLConnection+RACSupport.h
@@ -0,0 +1,25 @@ +// +// NSURLConnection+RACSupport.h +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-10-01. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import <Foundation/Foundation.h> + +@class RACSignal; + +@interface NSURLConnection (RACSupport) + +// Lazily loads data for the given request in the background. +// +// request - The URL request to load. This must not be nil. +// +// Returns a signal which will begin loading the request upon each subscription, +// then send a `RACTuple` of the received `NSURLResponse` and downloaded +// `NSData`, and complete on a background thread. If any errors occur, the +// returned signal will error out. ++ (RACSignal *)rac_sendAsynchronousRequest:(NSURLRequest *)request; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSURLConnection+RACSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/NSURLConnection+RACSupport.m new file mode 100644 index 0000000..3eaa2c3 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSURLConnection+RACSupport.m
@@ -0,0 +1,53 @@ +// +// NSURLConnection+RACSupport.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-10-01. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "NSURLConnection+RACSupport.h" +#import "RACDisposable.h" +#import "RACSignal.h" +#import "RACSignal+Operations.h" +#import "RACSubscriber.h" +#import "RACTuple.h" + +@implementation NSURLConnection (RACSupport) + ++ (RACSignal *)rac_sendAsynchronousRequest:(NSURLRequest *)request { + NSCParameterAssert(request != nil); + + return [[RACSignal + createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) { + NSOperationQueue *queue = [[NSOperationQueue alloc] init]; + queue.name = @"com.github.ReactiveCocoa.NSURLConnectionRACSupport"; + + [NSURLConnection sendAsynchronousRequest:request queue:queue completionHandler:^(NSURLResponse *response, NSData *data, NSError *error) { + // The docs say that `nil` data means an error occurred, but + // `nil` responses can also occur in practice (circumstances + // unknown). Consider either to be an error. + // + // Note that _empty_ data is not necessarily erroneous, as there + // may be headers but no HTTP body. + if (response == nil || data == nil) { + [subscriber sendError:error]; + } else { + [subscriber sendNext:RACTuplePack(response, data)]; + [subscriber sendCompleted]; + } + }]; + + return [RACDisposable disposableWithBlock:^{ + // It's not clear if this will actually cancel the connection, + // but we can at least prevent _some_ unnecessary work -- + // without writing all the code for a proper delegate, which + // doesn't really belong in RAC. + queue.suspended = YES; + [queue cancelAllOperations]; + }]; + }] + setNameWithFormat:@"+rac_sendAsynchronousRequest: %@", request]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSUserDefaults+RACSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/NSUserDefaults+RACSupport.h new file mode 100644 index 0000000..8482fb3 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSUserDefaults+RACSupport.h
@@ -0,0 +1,27 @@ +// +// NSUserDefaults+RACSupport.h +// ReactiveCocoa +// +// Created by Matt Diephouse on 12/19/13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import <Foundation/Foundation.h> + +@class RACChannelTerminal; + +@interface NSUserDefaults (RACSupport) + +/// Creates and returns a terminal for binding the user defaults key. +/// +/// **Note:** The value in the user defaults is *asynchronously* updated with +/// values sent to the channel. +/// +/// key - The user defaults key to create the channel terminal for. +/// +/// Returns a channel terminal that sends the value of the user defaults key +/// upon subscription, sends an updated value whenever the default changes, and +/// updates the default asynchronously with values it receives. +- (RACChannelTerminal *)rac_channelTerminalForKey:(NSString *)key; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/NSUserDefaults+RACSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/NSUserDefaults+RACSupport.m new file mode 100644 index 0000000..a8624a1 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/NSUserDefaults+RACSupport.m
@@ -0,0 +1,58 @@ +// +// NSUserDefaults+RACSupport.m +// ReactiveCocoa +// +// Created by Matt Diephouse on 12/19/13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "NSUserDefaults+RACSupport.h" + +#import "EXTScope.h" +#import "RACChannel.h" +#import "RACScheduler.h" +#import "RACSignal+Operations.h" +#import "NSNotificationCenter+RACSupport.h" +#import "NSObject+RACDeallocating.h" +#import "NSObject+RACLifting.h" + +@implementation NSUserDefaults (RACSupport) + +- (RACChannelTerminal *)rac_channelTerminalForKey:(NSString *)key { + RACChannel *channel = [RACChannel new]; + + RACScheduler *scheduler = [RACScheduler scheduler]; + __block BOOL ignoreNextValue = NO; + + @weakify(self); + [[[[[[[NSNotificationCenter.defaultCenter + rac_addObserverForName:NSUserDefaultsDidChangeNotification object:self] + map:^(id _) { + @strongify(self); + return [self objectForKey:key]; + }] + startWith:[self objectForKey:key]] + // Don't send values that were set on the other side of the terminal. + filter:^ BOOL (id _) { + if (RACScheduler.currentScheduler == scheduler && ignoreNextValue) { + ignoreNextValue = NO; + return NO; + } + return YES; + }] + distinctUntilChanged] + takeUntil:self.rac_willDeallocSignal] + subscribe:channel.leadingTerminal]; + + [[channel.leadingTerminal + deliverOn:scheduler] + subscribeNext:^(id value) { + @strongify(self); + ignoreNextValue = YES; + [self setObject:value forKey:key]; + }]; + + return channel.followingTerminal; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACArraySequence.h b/ReactiveCocoaFramework/ReactiveCocoa/RACArraySequence.h new file mode 100644 index 0000000..e9d948e --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACArraySequence.h
@@ -0,0 +1,18 @@ +// +// RACArraySequence.h +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-10-29. +// Copyright (c) 2012 GitHub. All rights reserved. +// + +#import "RACSequence.h" + +// Private class that adapts an array to the RACSequence interface. +@interface RACArraySequence : RACSequence + +// Returns a sequence for enumerating over the given array, starting from the +// given offset. The array will be copied to prevent mutation. ++ (instancetype)sequenceWithArray:(NSArray *)array offset:(NSUInteger)offset; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACArraySequence.m b/ReactiveCocoaFramework/ReactiveCocoa/RACArraySequence.m new file mode 100644 index 0000000..f7ca69d --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACArraySequence.m
@@ -0,0 +1,125 @@ +// +// RACArraySequence.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-10-29. +// Copyright (c) 2012 GitHub. All rights reserved. +// + +#import "RACArraySequence.h" + +@interface RACArraySequence () + +// Redeclared from the superclass and marked deprecated to prevent using `array` +// where `backingArray` is intended. +@property (nonatomic, copy, readonly) NSArray *array __attribute__((deprecated)); + +// The array being sequenced. +@property (nonatomic, copy, readonly) NSArray *backingArray; + +// The index in the array from which the sequence starts. +@property (nonatomic, assign, readonly) NSUInteger offset; + +@end + +@implementation RACArraySequence + +#pragma mark Lifecycle + ++ (instancetype)sequenceWithArray:(NSArray *)array offset:(NSUInteger)offset { + NSCParameterAssert(offset <= array.count); + + if (offset == array.count) return self.empty; + + RACArraySequence *seq = [[self alloc] init]; + seq->_backingArray = [array copy]; + seq->_offset = offset; + return seq; +} + +#pragma mark RACSequence + +- (id)head { + return [self.backingArray objectAtIndex:self.offset]; +} + +- (RACSequence *)tail { + RACSequence *sequence = [self.class sequenceWithArray:self.backingArray offset:self.offset + 1]; + sequence.name = self.name; + return sequence; +} + +#pragma mark NSFastEnumeration + +- (NSUInteger)countByEnumeratingWithState:(NSFastEnumerationState *)state objects:(__unsafe_unretained id[])stackbuf count:(NSUInteger)len { + NSCParameterAssert(len > 0); + + if (state->state >= self.backingArray.count) { + // Enumeration has completed. + return 0; + } + + if (state->state == 0) { + state->state = self.offset; + + // Since a sequence doesn't mutate, this just needs to be set to + // something non-NULL. + state->mutationsPtr = state->extra; + } + + state->itemsPtr = stackbuf; + + NSUInteger startIndex = state->state; + NSUInteger index = 0; + + for (id value in self.backingArray) { + // Constructing an index set for -enumerateObjectsAtIndexes: can actually be + // slower than just skipping the items we don't care about. + if (index < startIndex) { + ++index; + continue; + } + + stackbuf[index - startIndex] = value; + + ++index; + if (index - startIndex >= len) break; + } + + NSCAssert(index > startIndex, @"Final index (%lu) should be greater than start index (%lu)", (unsigned long)index, (unsigned long)startIndex); + + state->state = index; + return index - startIndex; +} + +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wdeprecated-implementations" +- (NSArray *)array { + return [self.backingArray subarrayWithRange:NSMakeRange(self.offset, self.backingArray.count - self.offset)]; +} +#pragma clang diagnostic pop + +#pragma mark NSCoding + +- (id)initWithCoder:(NSCoder *)coder { + self = [super initWithCoder:coder]; + if (self == nil) return nil; + + _backingArray = [coder decodeObjectForKey:@"array"]; + _offset = 0; + + return self; +} + +- (void)encodeWithCoder:(NSCoder *)coder { + // Encoding is handled in RACSequence. + [super encodeWithCoder:coder]; +} + +#pragma mark NSObject + +- (NSString *)description { + return [NSString stringWithFormat:@"<%@: %p>{ name = %@, array = %@ }", self.class, self, self.name, self.backingArray]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACBacktrace.h b/ReactiveCocoaFramework/ReactiveCocoa/RACBacktrace.h new file mode 100644 index 0000000..8588c80 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACBacktrace.h
@@ -0,0 +1,70 @@ +// +// RACBacktrace.h +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-08-20. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#ifdef DEBUG + +extern void rac_dispatch_async(dispatch_queue_t queue, dispatch_block_t block); +extern void rac_dispatch_barrier_async(dispatch_queue_t queue, dispatch_block_t block); +extern void rac_dispatch_after(dispatch_time_t time, dispatch_queue_t queue, dispatch_block_t block); +extern void rac_dispatch_async_f(dispatch_queue_t queue, void *context, dispatch_function_t function); +extern void rac_dispatch_barrier_async_f(dispatch_queue_t queue, void *context, dispatch_function_t function); +extern void rac_dispatch_after_f(dispatch_time_t time, dispatch_queue_t queue, void *context, dispatch_function_t function); + +#define dispatch_async rac_dispatch_async +#define dispatch_barrier_async rac_dispatch_barrier_async +#define dispatch_after rac_dispatch_after +#define dispatch_async_f rac_dispatch_async_f +#define dispatch_barrier_async_f rac_dispatch_barrier_async_f +#define dispatch_after_f rac_dispatch_after_f + +/// Preserves backtraces across asynchronous calls. +/// +/// On OS X, you can enable the automatic capturing of asynchronous backtraces +/// (in Debug builds) by setting the `DYLD_INSERT_LIBRARIES` environment variable +/// to `@executable_path/../Frameworks/ReactiveCocoa.framework/ReactiveCocoa` in +/// your scheme's Run action settings. +/// +/// On iOS, your project and RAC will automatically use the `rac_` GCD functions +/// (declared above) for asynchronous work. Unfortunately, unlike OS X, it's +/// impossible to capture backtraces inside NSOperationQueue or other code +/// outside of your project. +/// +/// Once backtraces are being captured, you can `po [RACBacktrace backtrace]` in +/// the debugger to print them out at any time. You can even set up an alias in +/// ~/.lldbinit to do so: +/// +/// command alias racbt po [RACBacktrace backtrace] +/// +@interface RACBacktrace : NSObject + +/// The backtrace from any previous thread. +@property (nonatomic, strong, readonly) RACBacktrace *previousThreadBacktrace; + +/// The call stack of this backtrace's thread. +@property (nonatomic, copy, readonly) NSArray *callStackSymbols; + +/// Captures the current thread's backtrace, appending it to any backtrace from +/// a previous thread. ++ (instancetype)backtrace; + +/// Same as +backtrace, but omits the specified number of frames at the +/// top of the stack (in addition to this method itself). ++ (instancetype)backtraceIgnoringFrames:(NSUInteger)ignoreCount; + +@end + +#else + +#define rac_dispatch_async dispatch_async +#define rac_dispatch_barrier_async dispatch_barrier_async +#define rac_dispatch_after dispatch_after +#define rac_dispatch_async_f dispatch_async_f +#define rac_dispatch_barrier_async_f dispatch_barrier_async_f +#define rac_dispatch_after_f dispatch_after_f + +#endif
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACBacktrace.m b/ReactiveCocoaFramework/ReactiveCocoa/RACBacktrace.m new file mode 100644 index 0000000..c2724d4 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACBacktrace.m
@@ -0,0 +1,249 @@ +// +// RACBacktrace.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-08-16. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import <execinfo.h> +#import <pthread.h> +#import "RACBacktrace.h" + +#define RAC_BACKTRACE_MAX_CALL_STACK_FRAMES 128 + +#ifdef DEBUG + +// Undefine the macros that hide the real GCD functions. +#undef dispatch_async +#undef dispatch_barrier_async +#undef dispatch_after +#undef dispatch_async_f +#undef dispatch_barrier_async_f +#undef dispatch_after_f + +@interface RACBacktrace () { + void *_callStackAddresses[RAC_BACKTRACE_MAX_CALL_STACK_FRAMES]; + int _callStackSize; +} + +@property (nonatomic, strong, readwrite) RACBacktrace *previousThreadBacktrace; +@end + +@interface RACDispatchInfo : NSObject + +// The recorded backtrace. +@property (nonatomic, strong, readonly) RACBacktrace *backtrace; + +// The information for the original dispatch. +@property (nonatomic, readonly) dispatch_function_t function; +@property (nonatomic, readonly) void *context; +@property (nonatomic, readonly) dispatch_queue_t queue; + +- (id)initWithQueue:(dispatch_queue_t)queue function:(dispatch_function_t)function context:(void *)context; + +@end + +// Function for use with dispatch_async_f and friends, which will save the +// backtrace onto the current queue, then call through to the original dispatch. +static void RACTraceDispatch (void *ptr) { + // Balance out the retain necessary for async calls. + RACDispatchInfo *info __attribute__((objc_precise_lifetime)) = CFBridgingRelease(ptr); + + dispatch_queue_set_specific(info.queue, (void *)pthread_self(), (__bridge void *)info.backtrace, NULL); + info.function(info.context); + dispatch_queue_set_specific(info.queue, (void *)pthread_self(), NULL, NULL); +} + +// Always inline this function, for consistency in backtraces. +__attribute__((always_inline)) +static dispatch_block_t RACBacktraceBlock (dispatch_queue_t queue, dispatch_block_t block) { + RACBacktrace *backtrace = [RACBacktrace backtrace]; + + return [^{ + RACBacktrace *backtraceKeptAlive __attribute__((objc_precise_lifetime)) = backtrace; + + dispatch_queue_set_specific(queue, (void *)pthread_self(), (__bridge void *)backtraceKeptAlive, NULL); + block(); + dispatch_queue_set_specific(queue, (void *)pthread_self(), NULL, NULL); + } copy]; +} + +void rac_dispatch_async(dispatch_queue_t queue, dispatch_block_t block) { + dispatch_async(queue, RACBacktraceBlock(queue, block)); +} + +void rac_dispatch_barrier_async(dispatch_queue_t queue, dispatch_block_t block) { + dispatch_barrier_async(queue, RACBacktraceBlock(queue, block)); +} + +void rac_dispatch_after(dispatch_time_t time, dispatch_queue_t queue, dispatch_block_t block) { + dispatch_after(time, queue, RACBacktraceBlock(queue, block)); +} + +void rac_dispatch_async_f(dispatch_queue_t queue, void *context, dispatch_function_t function) { + RACDispatchInfo *info = [[RACDispatchInfo alloc] initWithQueue:queue function:function context:context]; + dispatch_async_f(queue, (void *)CFBridgingRetain(info), &RACTraceDispatch); +} + +void rac_dispatch_barrier_async_f(dispatch_queue_t queue, void *context, dispatch_function_t function) { + RACDispatchInfo *info = [[RACDispatchInfo alloc] initWithQueue:queue function:function context:context]; + dispatch_barrier_async_f(queue, (void *)CFBridgingRetain(info), &RACTraceDispatch); +} + +void rac_dispatch_after_f(dispatch_time_t time, dispatch_queue_t queue, void *context, dispatch_function_t function) { + RACDispatchInfo *info = [[RACDispatchInfo alloc] initWithQueue:queue function:function context:context]; + dispatch_after_f(time, queue, (void *)CFBridgingRetain(info), &RACTraceDispatch); +} + +// This is what actually performs the injection. +// +// The DYLD_INSERT_LIBRARIES environment variable must include the RAC dynamic +// library in order for this to work. +__attribute__((used)) static struct { const void *replacement; const void *replacee; } interposers[] __attribute__((section("__DATA,__interpose"))) = { + { (const void *)&rac_dispatch_async, (const void *)&dispatch_async }, + { (const void *)&rac_dispatch_barrier_async, (const void *)&dispatch_barrier_async }, + { (const void *)&rac_dispatch_after, (const void *)&dispatch_after }, + { (const void *)&rac_dispatch_async_f, (const void *)&dispatch_async_f }, + { (const void *)&rac_dispatch_barrier_async_f, (const void *)&dispatch_barrier_async_f }, + { (const void *)&rac_dispatch_after_f, (const void *)&dispatch_after_f }, +}; + +static void RACSignalHandler (int sig) { + NSLog(@"Backtrace: %@", [RACBacktrace backtrace]); + fflush(stdout); + + // Restore the default action and raise the signal again. + signal(sig, SIG_DFL); + raise(sig); +} + +static void RACExceptionHandler (NSException *ex) { + NSLog(@"Uncaught exception %@", ex); + NSLog(@"Backtrace: %@", [RACBacktrace backtrace]); + fflush(stdout); +} + +@implementation RACBacktrace + +#pragma mark Properties + +- (NSArray *)callStackSymbols { + if (_callStackSize == 0) return @[]; + + char **symbols = backtrace_symbols(_callStackAddresses, _callStackSize); + NSMutableArray *array = [NSMutableArray arrayWithCapacity:(NSUInteger)_callStackSize]; + + for (int i = 0; i < _callStackSize; i++) { + NSString *str = @(symbols[i]); + [array addObject:str]; + } + + free(symbols); + return array; +} + +#pragma mark Lifecycle + ++ (void)load { + @autoreleasepool { + NSString *libraries = [[[NSProcessInfo processInfo] environment] objectForKey:@"DYLD_INSERT_LIBRARIES"]; + + // Don't install our handlers if we're not actually intercepting function + // calls. + if ([libraries rangeOfString:@"ReactiveCocoa"].length == 0) return; + + NSLog(@"*** Enabling asynchronous backtraces"); + + NSSetUncaughtExceptionHandler(&RACExceptionHandler); + } + + signal(SIGILL, &RACSignalHandler); + signal(SIGTRAP, &RACSignalHandler); + signal(SIGABRT, &RACSignalHandler); + signal(SIGFPE, &RACSignalHandler); + signal(SIGBUS, &RACSignalHandler); + signal(SIGSEGV, &RACSignalHandler); + signal(SIGSYS, &RACSignalHandler); + signal(SIGPIPE, &RACSignalHandler); +} + +- (void)dealloc { + __autoreleasing RACBacktrace *previous __attribute__((unused)) = self.previousThreadBacktrace; + self.previousThreadBacktrace = nil; +} + +#pragma mark Backtraces + ++ (instancetype)backtrace { + return [self backtraceIgnoringFrames:1]; +} + ++ (instancetype)backtraceIgnoringFrames:(NSUInteger)ignoreCount { + @autoreleasepool { + RACBacktrace *oldBacktrace = (__bridge id)dispatch_get_specific((void *)pthread_self()); + + RACBacktrace *newBacktrace = [[RACBacktrace alloc] init]; + newBacktrace.previousThreadBacktrace = oldBacktrace; + + int size = backtrace(newBacktrace->_callStackAddresses, RAC_BACKTRACE_MAX_CALL_STACK_FRAMES); + + // Omit this method plus however many others from the backtrace. + ++ignoreCount; + if ((NSUInteger)size > ignoreCount) { + memmove(newBacktrace->_callStackAddresses, newBacktrace->_callStackAddresses + ignoreCount, ((NSUInteger)size - ignoreCount) * sizeof(char *)); + size -= (int)ignoreCount; + } + + newBacktrace->_callStackSize = size; + return newBacktrace; + } +} + +#pragma mark NSObject + +- (NSString *)description { + NSString *str = [NSString stringWithFormat:@"%@", self.callStackSymbols]; + if (self.previousThreadBacktrace != nil) { + str = [str stringByAppendingFormat:@"\n\n... asynchronously invoked from: %@", self.previousThreadBacktrace]; + } + + return str; +} + +@end + +@implementation RACDispatchInfo + +#pragma mark Lifecycle + +- (id)initWithQueue:(dispatch_queue_t)queue function:(dispatch_function_t)function context:(void *)context { + @autoreleasepool { + NSCParameterAssert(queue != NULL); + NSCParameterAssert(function != NULL); + + self = [super init]; + if (self == nil) return nil; + + _backtrace = [RACBacktrace backtraceIgnoringFrames:1]; + + dispatch_retain(queue); + _queue = queue; + + _function = function; + _context = context; + + return self; + } +} + +- (void)dealloc { + if (_queue != NULL) { + dispatch_release(_queue); + _queue = NULL; + } +} + +@end + +#endif
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACBehaviorSubject.h b/ReactiveCocoaFramework/ReactiveCocoa/RACBehaviorSubject.h new file mode 100644 index 0000000..2f9e0db --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACBehaviorSubject.h
@@ -0,0 +1,19 @@ +// +// RACBehaviorSubject.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 3/16/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACSubject.h" + + +/// A behavior subject sends the last value it received when it is subscribed to. +@interface RACBehaviorSubject : RACSubject + +/// Creates a new behavior subject with a default value. If it hasn't received +/// any values when it gets subscribed to, it sends the default value. ++ (instancetype)behaviorSubjectWithDefaultValue:(id)value; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACBehaviorSubject.m b/ReactiveCocoaFramework/ReactiveCocoa/RACBehaviorSubject.m new file mode 100644 index 0000000..dfda2ac --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACBehaviorSubject.m
@@ -0,0 +1,56 @@ +// +// RACBehaviorSubject.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 3/16/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACBehaviorSubject.h" +#import "RACDisposable.h" +#import "RACScheduler+Private.h" + +@interface RACBehaviorSubject () + +// This property should only be used while synchronized on self. +@property (nonatomic, strong) id currentValue; + +@end + +@implementation RACBehaviorSubject + +#pragma mark Lifecycle + ++ (instancetype)behaviorSubjectWithDefaultValue:(id)value { + RACBehaviorSubject *subject = [self subject]; + subject.currentValue = value; + return subject; +} + +#pragma mark RACSignal + +- (RACDisposable *)subscribe:(id<RACSubscriber>)subscriber { + RACDisposable *subscriptionDisposable = [super subscribe:subscriber]; + + RACDisposable *schedulingDisposable = [RACScheduler.subscriptionScheduler schedule:^{ + @synchronized (self) { + [subscriber sendNext:self.currentValue]; + } + }]; + + return [RACDisposable disposableWithBlock:^{ + [subscriptionDisposable dispose]; + [schedulingDisposable dispose]; + }]; +} + +#pragma mark RACSubscriber + +- (void)sendNext:(id)value { + @synchronized (self) { + self.currentValue = value; + [super sendNext:value]; + } +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACBlockTrampoline.h b/ReactiveCocoaFramework/ReactiveCocoa/RACBlockTrampoline.h new file mode 100644 index 0000000..3857d7c --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACBlockTrampoline.h
@@ -0,0 +1,30 @@ +// +// RACBlockTrampoline.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 10/21/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import <Foundation/Foundation.h> + +@class RACTuple; + +// A private class that allows a limited type of dynamic block invocation. +@interface RACBlockTrampoline : NSObject + +// Invokes the given block with the given arguments. All of the block's +// argument types must be objects and it must be typed to return an object. +// +// At this time, it only supports blocks that take up to 15 arguments. Any more +// is just cray. +// +// block - The block to invoke. Must accept as many arguments as are given in +// the arguments array. Cannot be nil. +// arguments - The arguments with which to invoke the block. `RACTupleNil`s will +// be passed as nils. +// +// Returns the return value of invoking the block. ++ (id)invokeBlock:(id)block withArguments:(RACTuple *)arguments; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACBlockTrampoline.m b/ReactiveCocoaFramework/ReactiveCocoa/RACBlockTrampoline.m new file mode 100644 index 0000000..07903dd --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACBlockTrampoline.m
@@ -0,0 +1,156 @@ +// +// RACBlockTrampoline.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 10/21/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACBlockTrampoline.h" +#import "RACTuple.h" + +@interface RACBlockTrampoline () +@property (nonatomic, readonly, copy) id block; +@end + +@implementation RACBlockTrampoline + +#pragma mark API + +- (id)initWithBlock:(id)block { + self = [super init]; + if (self == nil) return nil; + + _block = [block copy]; + + return self; +} + ++ (id)invokeBlock:(id)block withArguments:(RACTuple *)arguments { + NSCParameterAssert(block != NULL); + + RACBlockTrampoline *trampoline = [[self alloc] initWithBlock:block]; + return [trampoline invokeWithArguments:arguments]; +} + +- (id)invokeWithArguments:(RACTuple *)arguments { + SEL selector = [self selectorForArgumentCount:arguments.count]; + NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:[self methodSignatureForSelector:selector]]; + invocation.selector = selector; + invocation.target = self; + + for (NSUInteger i = 0; i < arguments.count; i++) { + id arg = arguments[i]; + NSInteger argIndex = (NSInteger)(i + 2); + [invocation setArgument:&arg atIndex:argIndex]; + } + + [invocation invoke]; + + __unsafe_unretained id returnVal; + [invocation getReturnValue:&returnVal]; + return returnVal; +} + +- (SEL)selectorForArgumentCount:(NSUInteger)count { + NSCParameterAssert(count > 0); + + switch (count) { + case 0: return NULL; + case 1: return @selector(performWith:); + case 2: return @selector(performWith::); + case 3: return @selector(performWith:::); + case 4: return @selector(performWith::::); + case 5: return @selector(performWith:::::); + case 6: return @selector(performWith::::::); + case 7: return @selector(performWith:::::::); + case 8: return @selector(performWith::::::::); + case 9: return @selector(performWith:::::::::); + case 10: return @selector(performWith::::::::::); + case 11: return @selector(performWith:::::::::::); + case 12: return @selector(performWith::::::::::::); + case 13: return @selector(performWith:::::::::::::); + case 14: return @selector(performWith::::::::::::::); + case 15: return @selector(performWith:::::::::::::::); + } + + NSCAssert(NO, @"The argument count is too damn high! Only blocks of up to 15 arguments are currently supported."); + return NULL; +} + +- (id)performWith:(id)obj1 { + id (^block)(id) = self.block; + return block(obj1); +} + +- (id)performWith:(id)obj1 :(id)obj2 { + id (^block)(id, id) = self.block; + return block(obj1, obj2); +} + +- (id)performWith:(id)obj1 :(id)obj2 :(id)obj3 { + id (^block)(id, id, id) = self.block; + return block(obj1, obj2, obj3); +} + +- (id)performWith:(id)obj1 :(id)obj2 :(id)obj3 :(id)obj4 { + id (^block)(id, id, id, id) = self.block; + return block(obj1, obj2, obj3, obj4); +} + +- (id)performWith:(id)obj1 :(id)obj2 :(id)obj3 :(id)obj4 :(id)obj5 { + id (^block)(id, id, id, id, id) = self.block; + return block(obj1, obj2, obj3, obj4, obj5); +} + +- (id)performWith:(id)obj1 :(id)obj2 :(id)obj3 :(id)obj4 :(id)obj5 :(id)obj6 { + id (^block)(id, id, id, id, id, id) = self.block; + return block(obj1, obj2, obj3, obj4, obj5, obj6); +} + +- (id)performWith:(id)obj1 :(id)obj2 :(id)obj3 :(id)obj4 :(id)obj5 :(id)obj6 :(id)obj7 { + id (^block)(id, id, id, id, id, id, id) = self.block; + return block(obj1, obj2, obj3, obj4, obj5, obj6, obj7); +} + +- (id)performWith:(id)obj1 :(id)obj2 :(id)obj3 :(id)obj4 :(id)obj5 :(id)obj6 :(id)obj7 :(id)obj8 { + id (^block)(id, id, id, id, id, id, id, id) = self.block; + return block(obj1, obj2, obj3, obj4, obj5, obj6, obj7, obj8); +} + +- (id)performWith:(id)obj1 :(id)obj2 :(id)obj3 :(id)obj4 :(id)obj5 :(id)obj6 :(id)obj7 :(id)obj8 :(id)obj9 { + id (^block)(id, id, id, id, id, id, id, id, id) = self.block; + return block(obj1, obj2, obj3, obj4, obj5, obj6, obj7, obj8, obj9); +} + +- (id)performWith:(id)obj1 :(id)obj2 :(id)obj3 :(id)obj4 :(id)obj5 :(id)obj6 :(id)obj7 :(id)obj8 :(id)obj9 :(id)obj10 { + id (^block)(id, id, id, id, id, id, id, id, id, id) = self.block; + return block(obj1, obj2, obj3, obj4, obj5, obj6, obj7, obj8, obj9, obj10); +} + +- (id)performWith:(id)obj1 :(id)obj2 :(id)obj3 :(id)obj4 :(id)obj5 :(id)obj6 :(id)obj7 :(id)obj8 :(id)obj9 :(id)obj10 :(id)obj11 { + id (^block)(id, id, id, id, id, id, id, id, id, id, id) = self.block; + return block(obj1, obj2, obj3, obj4, obj5, obj6, obj7, obj8, obj9, obj10, obj11); +} + +- (id)performWith:(id)obj1 :(id)obj2 :(id)obj3 :(id)obj4 :(id)obj5 :(id)obj6 :(id)obj7 :(id)obj8 :(id)obj9 :(id)obj10 :(id)obj11 :(id)obj12 { + id (^block)(id, id, id, id, id, id, id, id, id, id, id, id) = self.block; + return block(obj1, obj2, obj3, obj4, obj5, obj6, obj7, obj8, obj9, obj10, obj11, obj12); +} + +- (id)performWith:(id)obj1 :(id)obj2 :(id)obj3 :(id)obj4 :(id)obj5 :(id)obj6 :(id)obj7 :(id)obj8 :(id)obj9 :(id)obj10 :(id)obj11 :(id)obj12 :(id)obj13 { + id (^block)(id, id, id, id, id, id, id, id, id, id, id, id, id) = self.block; + return block(obj1, obj2, obj3, obj4, obj5, obj6, obj7, obj8, obj9, obj10, obj11, obj12, obj13); +} + +- (id)performWith:(id)obj1 :(id)obj2 :(id)obj3 :(id)obj4 :(id)obj5 :(id)obj6 :(id)obj7 :(id)obj8 :(id)obj9 :(id)obj10 :(id)obj11 :(id)obj12 :(id)obj13 :(id)obj14 { + id (^block)(id, id, id, id, id, id, id, id, id, id, id, id, id, id) = self.block; + return block(obj1, obj2, obj3, obj4, obj5, obj6, obj7, obj8, obj9, obj10, obj11, obj12, obj13, obj14); +} + +- (id)performWith:(id)obj1 :(id)obj2 :(id)obj3 :(id)obj4 :(id)obj5 :(id)obj6 :(id)obj7 :(id)obj8 :(id)obj9 :(id)obj10 :(id)obj11 :(id)obj12 :(id)obj13 :(id)obj14 :(id)obj15 { + id (^block)(id, id, id, id, id, id, id, id, id, id, id, id, id, id, id) = self.block; + return block(obj1, obj2, obj3, obj4, obj5, obj6, obj7, obj8, obj9, obj10, obj11, obj12, obj13, obj14, obj15); +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACChannel.h b/ReactiveCocoaFramework/ReactiveCocoa/RACChannel.h new file mode 100644 index 0000000..ef1d6f1 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACChannel.h
@@ -0,0 +1,70 @@ +// +// RACChannel.h +// ReactiveCocoa +// +// Created by Uri Baghin on 01/01/2013. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACSignal.h" +#import "RACSubscriber.h" + +@class RACChannelTerminal; + +/// A two-way channel. +/// +/// Conceptually, RACChannel can be thought of as a bidirectional connection, +/// composed of two controllable signals that work in parallel. +/// +/// For example, when connecting between a view and a model: +/// +/// Model View +/// `leadingTerminal` ------> `followingTerminal` +/// `leadingTerminal` <------ `followingTerminal` +/// +/// The initial value of the model and all future changes to it are _sent on_ the +/// `leadingTerminal`, and _received by_ subscribers of the `followingTerminal`. +/// +/// Likewise, whenever the user changes the value of the view, that value is sent +/// on the `followingTerminal`, and received in the model from the +/// `leadingTerminal`. However, the initial value of the view is not received +/// from the `leadingTerminal` (only future changes). +@interface RACChannel : NSObject + +/// The terminal which "leads" the channel, by sending its latest value +/// immediately to new subscribers of the `followingTerminal`. +/// +/// New subscribers to this terminal will not receive a starting value, but will +/// receive all future values that are sent to the `followingTerminal`. +@property (nonatomic, strong, readonly) RACChannelTerminal *leadingTerminal; + +/// The terminal which "follows" the lead of the other terminal, only sending +/// _future_ values to the subscribers of the `leadingTerminal`. +/// +/// The latest value sent to the `leadingTerminal` (if any) will be sent +/// immediately to new subscribers of this terminal, and then all future values +/// as well. +@property (nonatomic, strong, readonly) RACChannelTerminal *followingTerminal; + +@end + +/// Represents one end of a RACChannel. +/// +/// An terminal is similar to a socket or pipe -- it represents one end of +/// a connection (the RACChannel, in this case). Values sent to this terminal +/// will _not_ be received by its subscribers. Instead, the values will be sent +/// to the subscribers of the RACChannel's _other_ terminal. +/// +/// For example, when using the `followingTerminal`, _sent_ values can only be +/// _received_ from the `leadingTerminal`, and vice versa. +/// +/// To make it easy to terminate a RACChannel, `error` and `completed` events +/// sent to either terminal will be received by the subscribers of _both_ +/// terminals. +/// +/// Do not instantiate this class directly. Create a RACChannel instead. +@interface RACChannelTerminal : RACSignal <RACSubscriber> + +- (id)init __attribute__((unavailable("Instantiate a RACChannel instead"))); + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACChannel.m b/ReactiveCocoaFramework/ReactiveCocoa/RACChannel.m new file mode 100644 index 0000000..7222858 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACChannel.m
@@ -0,0 +1,91 @@ +// +// RACChannel.m +// ReactiveCocoa +// +// Created by Uri Baghin on 01/01/2013. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACChannel.h" +#import "RACDisposable.h" +#import "RACReplaySubject.h" +#import "RACSignal+Operations.h" +#import "RACUnit.h" + +@interface RACChannelTerminal () + +// The values for this terminal. +@property (nonatomic, strong, readonly) RACSignal *values; + +// A subscriber will will send values to the other terminal. +@property (nonatomic, strong, readonly) id<RACSubscriber> otherTerminal; + +- (id)initWithValues:(RACSignal *)values otherTerminal:(id<RACSubscriber>)otherTerminal; + +@end + +@implementation RACChannel + +- (id)init { + self = [super init]; + if (self == nil) return nil; + + // We don't want any starting value from the leadingSubject, but we do want + // error and completion to be replayed. + RACReplaySubject *leadingSubject = [[RACReplaySubject replaySubjectWithCapacity:0] setNameWithFormat:@"leadingSubject"]; + RACReplaySubject *followingSubject = [[RACReplaySubject replaySubjectWithCapacity:1] setNameWithFormat:@"followingSubject"]; + + // Propagate errors and completion to everything. + [[leadingSubject ignoreValues] subscribe:followingSubject]; + [[followingSubject ignoreValues] subscribe:leadingSubject]; + + _leadingTerminal = [[[RACChannelTerminal alloc] initWithValues:leadingSubject otherTerminal:followingSubject] setNameWithFormat:@"leadingTerminal"]; + _followingTerminal = [[[RACChannelTerminal alloc] initWithValues:followingSubject otherTerminal:leadingSubject] setNameWithFormat:@"followingTerminal"]; + + return self; +} + +@end + +@implementation RACChannelTerminal + +#pragma mark Lifecycle + +- (id)initWithValues:(RACSignal *)values otherTerminal:(id<RACSubscriber>)otherTerminal { + NSCParameterAssert(values != nil); + NSCParameterAssert(otherTerminal != nil); + + self = [super init]; + if (self == nil) return nil; + + _values = values; + _otherTerminal = otherTerminal; + + return self; +} + +#pragma mark RACSignal + +- (RACDisposable *)subscribe:(id<RACSubscriber>)subscriber { + return [self.values subscribe:subscriber]; +} + +#pragma mark <RACSubscriber> + +- (void)sendNext:(id)value { + [self.otherTerminal sendNext:value]; +} + +- (void)sendError:(NSError *)error { + [self.otherTerminal sendError:error]; +} + +- (void)sendCompleted { + [self.otherTerminal sendCompleted]; +} + +- (void)didSubscribeWithDisposable:(RACCompoundDisposable *)disposable { + [self.otherTerminal didSubscribeWithDisposable:disposable]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACCommand.h b/ReactiveCocoaFramework/ReactiveCocoa/RACCommand.h new file mode 100644 index 0000000..653d46b --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACCommand.h
@@ -0,0 +1,123 @@ +// +// RACCommand.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 3/3/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import <Foundation/Foundation.h> + +@class RACSignal; + +/// The domain for errors originating within `RACCommand`. +extern NSString * const RACCommandErrorDomain; + +/// -execute: was invoked while the command was disabled. +extern const NSInteger RACCommandErrorNotEnabled; + +/// A `userInfo` key for an error, associated with the `RACCommand` that the +/// error originated from. +/// +/// This is included only when the error code is `RACCommandErrorNotEnabled`. +extern NSString * const RACUnderlyingCommandErrorKey; + +/// A command is a signal triggered in response to some action, typically +/// UI-related. +@interface RACCommand : NSObject + +/// A signal of the signals returned by successful invocations of -execute: +/// (i.e., while the receiver is `enabled`). +/// +/// Errors will be automatically caught upon the inner signals, and sent upon +/// `errors` instead. If you _want_ to receive inner errors, use -execute: or +/// -[RACSignal materialize]. +/// +/// Only executions that begin _after_ subscription will be sent upon this +/// signal. All inner signals will arrive upon the main thread. +@property (nonatomic, strong, readonly) RACSignal *executionSignals; + +/// A signal of whether this command is currently executing. +/// +/// This will send YES whenever -execute: is invoked and the created signal has +/// not yet terminated. Once all executions have terminated, `executing` will +/// send NO. +/// +/// This signal will send its current value upon subscription, and then all +/// future values on the main thread. +@property (nonatomic, strong, readonly) RACSignal *executing; + +/// A signal of whether this command is able to execute. +/// +/// This will send NO if: +/// +/// - The command was created with an `enabledSignal`, and NO is sent upon that +/// signal, or +/// - `allowsConcurrentExecution` is NO and the command has started executing. +/// +/// Once the above conditions are no longer met, the signal will send YES. +/// +/// This signal will send its current value upon subscription, and then all +/// future values on the main thread. +@property (nonatomic, strong, readonly) RACSignal *enabled; + +/// Forwards any errors that occur within signals returned by -execute:. +/// +/// When an error occurs on a signal returned from -execute:, this signal will +/// send the associated NSError value as a `next` event (since an `error` event +/// would terminate the stream). +/// +/// After subscription, this signal will send all future errors on the main +/// thread. +@property (nonatomic, strong, readonly) RACSignal *errors; + +/// Whether the command allows multiple executions to proceed concurrently. +/// +/// The default value for this property is NO. +@property (atomic, assign) BOOL allowsConcurrentExecution; + +/// Invokes -initWithEnabled:signalBlock: with a nil `enabledSignal`. +- (id)initWithSignalBlock:(RACSignal * (^)(id input))signalBlock; + +/// Initializes a command that is conditionally enabled. +/// +/// This is the designated initializer for this class. +/// +/// enabledSignal - A signal of BOOLs which indicate whether the command should +/// be enabled. `enabled` will be based on the latest value sent +/// from this signal. Before any values are sent, `enabled` will +/// default to YES. This argument may be nil. +/// signalBlock - A block which will map each input value (passed to -execute:) +/// to a signal of work. The returned signal will be multicasted +/// to a replay subject, sent on `executionSignals`, then +/// subscribed to synchronously. Neither the block nor the +/// returned signal may be nil. +- (id)initWithEnabled:(RACSignal *)enabledSignal signalBlock:(RACSignal * (^)(id input))signalBlock; + +/// If the receiver is enabled, this method will: +/// +/// 1. Invoke the `signalBlock` given at the time of initialization. +/// 2. Multicast the returned signal to a RACReplaySubject. +/// 3. Send the multicasted signal on `executionSignals`. +/// 4. Subscribe (connect) to the original signal on the main thread. +/// +/// input - The input value to pass to the receiver's `signalBlock`. This may be +/// nil. +/// +/// Returns the multicasted signal, after subscription. If the receiver is not +/// enabled, returns a signal that will send an error with code +/// RACCommandErrorNotEnabled. +- (RACSignal *)execute:(id)input; + +@end + +@interface RACCommand (Unavailable) + +@property (atomic, readonly) BOOL canExecute __attribute__((unavailable("Use the 'enabled' signal instead"))); + ++ (instancetype)command __attribute__((unavailable("Use -initWithSignalBlock: instead"))); ++ (instancetype)commandWithCanExecuteSignal:(RACSignal *)canExecuteSignal __attribute__((unavailable("Use -initWithEnabled:signalBlock: instead"))); +- (id)initWithCanExecuteSignal:(RACSignal *)canExecuteSignal __attribute__((unavailable("Use -initWithEnabled:signalBlock: instead"))); +- (RACSignal *)addSignalBlock:(RACSignal * (^)(id value))signalBlock __attribute__((unavailable("Pass the signalBlock to -initWithSignalBlock: instead"))); + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACCommand.m b/ReactiveCocoaFramework/ReactiveCocoa/RACCommand.m new file mode 100644 index 0000000..0bc864b --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACCommand.m
@@ -0,0 +1,268 @@ +// +// RACCommand.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 3/3/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACCommand.h" +#import "EXTScope.h" +#import "NSArray+RACSequenceAdditions.h" +#import "NSObject+RACDeallocating.h" +#import "NSObject+RACDescription.h" +#import "NSObject+RACPropertySubscribing.h" +#import "RACMulticastConnection.h" +#import "RACReplaySubject.h" +#import "RACScheduler.h" +#import "RACSequence.h" +#import "RACSerialDisposable.h" +#import "RACSignal+Operations.h" +#import <libkern/OSAtomic.h> + +NSString * const RACCommandErrorDomain = @"RACCommandErrorDomain"; +NSString * const RACUnderlyingCommandErrorKey = @"RACUnderlyingCommandErrorKey"; + +const NSInteger RACCommandErrorNotEnabled = 1; + +@interface RACCommand () { + // The mutable array backing `activeExecutionSignals`. + // + // This should only be used while synchronized on `self`. + NSMutableArray *_activeExecutionSignals; + + // Atomic backing variable for `allowsConcurrentExecution`. + volatile uint32_t _allowsConcurrentExecution; +} + +// An array of signals representing in-flight executions, in the order they +// began. +// +// This property is KVO-compliant. +@property (atomic, copy, readonly) NSArray *activeExecutionSignals; + +// `enabled`, but without a hop to the main thread. +// +// Values from this signal may arrive on any thread. +@property (nonatomic, strong, readonly) RACSignal *immediateEnabled; + +// The signal block that the receiver was initialized with. +@property (nonatomic, copy, readonly) RACSignal * (^signalBlock)(id input); + +// Adds a signal to `activeExecutionSignals` and generates a KVO notification. +- (void)addActiveExecutionSignal:(RACSignal *)signal; + +// Removes a signal from `activeExecutionSignals` and generates a KVO +// notification. +- (void)removeActiveExecutionSignal:(RACSignal *)signal; + +@end + +@implementation RACCommand + +#pragma mark Properties + +- (BOOL)allowsConcurrentExecution { + return _allowsConcurrentExecution != 0; +} + +- (void)setAllowsConcurrentExecution:(BOOL)allowed { + [self willChangeValueForKey:@keypath(self.allowsConcurrentExecution)]; + + if (allowed) { + OSAtomicOr32Barrier(1, &_allowsConcurrentExecution); + } else { + OSAtomicAnd32Barrier(0, &_allowsConcurrentExecution); + } + + [self didChangeValueForKey:@keypath(self.allowsConcurrentExecution)]; +} + +- (NSArray *)activeExecutionSignals { + @synchronized (self) { + return [_activeExecutionSignals copy]; + } +} + +- (void)addActiveExecutionSignal:(RACSignal *)signal { + NSCParameterAssert([signal isKindOfClass:RACSignal.class]); + + @synchronized (self) { + // The KVO notification has to be generated while synchronized, because + // it depends on the index remaining consistent. + NSIndexSet *indexes = [NSIndexSet indexSetWithIndex:_activeExecutionSignals.count]; + [self willChange:NSKeyValueChangeInsertion valuesAtIndexes:indexes forKey:@keypath(self.activeExecutionSignals)]; + [_activeExecutionSignals addObject:signal]; + [self didChange:NSKeyValueChangeInsertion valuesAtIndexes:indexes forKey:@keypath(self.activeExecutionSignals)]; + } +} + +- (void)removeActiveExecutionSignal:(RACSignal *)signal { + NSCParameterAssert([signal isKindOfClass:RACSignal.class]); + + @synchronized (self) { + // The indexes have to be calculated and the notification generated + // while synchronized, because they depend on the indexes remaining + // consistent. + NSIndexSet *indexes = [_activeExecutionSignals indexesOfObjectsPassingTest:^ BOOL (RACSignal *obj, NSUInteger index, BOOL *stop) { + return obj == signal; + }]; + + if (indexes.count == 0) return; + + [self willChange:NSKeyValueChangeRemoval valuesAtIndexes:indexes forKey:@keypath(self.activeExecutionSignals)]; + [_activeExecutionSignals removeObjectsAtIndexes:indexes]; + [self didChange:NSKeyValueChangeRemoval valuesAtIndexes:indexes forKey:@keypath(self.activeExecutionSignals)]; + } +} + +#pragma mark Lifecycle + +- (id)init { + NSCAssert(NO, @"Use -initWithSignalBlock: instead"); + return nil; +} + +- (id)initWithSignalBlock:(RACSignal * (^)(id input))signalBlock { + return [self initWithEnabled:nil signalBlock:signalBlock]; +} + +- (id)initWithEnabled:(RACSignal *)enabledSignal signalBlock:(RACSignal * (^)(id input))signalBlock { + NSCParameterAssert(signalBlock != nil); + + self = [super init]; + if (self == nil) return nil; + + _activeExecutionSignals = [[NSMutableArray alloc] init]; + _signalBlock = [signalBlock copy]; + + // A signal of additions to `activeExecutionSignals`. + RACSignal *newActiveExecutionSignals = [[[[[self + rac_valuesAndChangesForKeyPath:@keypath(self.activeExecutionSignals) options:NSKeyValueObservingOptionNew observer:nil] + reduceEach:^(id _, NSDictionary *change) { + NSArray *signals = change[NSKeyValueChangeNewKey]; + if (signals == nil) return [RACSignal empty]; + + return [signals.rac_sequence signalWithScheduler:RACScheduler.immediateScheduler]; + }] + concat] + publish] + autoconnect]; + + _executionSignals = [[[newActiveExecutionSignals + map:^(RACSignal *signal) { + return [signal catchTo:[RACSignal empty]]; + }] + deliverOn:RACScheduler.mainThreadScheduler] + setNameWithFormat:@"%@ -executionSignals", self]; + + // `errors` needs to be multicasted so that it picks up all + // `activeExecutionSignals` that are added. + // + // In other words, if someone subscribes to `errors` _after_ an execution + // has started, it should still receive any error from that execution. + RACMulticastConnection *errorsConnection = [[[newActiveExecutionSignals + flattenMap:^(RACSignal *signal) { + return [[signal + ignoreValues] + catch:^(NSError *error) { + return [RACSignal return:error]; + }]; + }] + deliverOn:RACScheduler.mainThreadScheduler] + publish]; + + _errors = [errorsConnection.signal setNameWithFormat:@"%@ -errors", self]; + [errorsConnection connect]; + + RACSignal *immediateExecuting = [RACObserve(self, activeExecutionSignals) map:^(NSArray *activeSignals) { + return @(activeSignals.count > 0); + }]; + + _executing = [[[[[immediateExecuting + deliverOn:RACScheduler.mainThreadScheduler] + // This is useful before the first value arrives on the main thread. + startWith:@NO] + distinctUntilChanged] + replayLast] + setNameWithFormat:@"%@ -executing", self]; + + RACSignal *moreExecutionsAllowed = [RACSignal + if:RACObserve(self, allowsConcurrentExecution) + then:[RACSignal return:@YES] + else:[immediateExecuting not]]; + + if (enabledSignal == nil) { + enabledSignal = [RACSignal return:@YES]; + } else { + enabledSignal = [[[enabledSignal + startWith:@YES] + takeUntil:self.rac_willDeallocSignal] + replayLast]; + } + + _immediateEnabled = [[RACSignal + combineLatest:@[ enabledSignal, moreExecutionsAllowed ]] + and]; + + _enabled = [[[[[self.immediateEnabled + take:1] + concat:[[self.immediateEnabled skip:1] deliverOn:RACScheduler.mainThreadScheduler]] + distinctUntilChanged] + replayLast] + setNameWithFormat:@"%@ -enabled", self]; + + return self; +} + +#pragma mark Execution + +- (RACSignal *)execute:(id)input { + // `immediateEnabled` is guaranteed to send a value upon subscription, so + // -first is acceptable here. + BOOL enabled = [[self.immediateEnabled first] boolValue]; + if (!enabled) { + NSError *error = [NSError errorWithDomain:RACCommandErrorDomain code:RACCommandErrorNotEnabled userInfo:@{ + NSLocalizedDescriptionKey: NSLocalizedString(@"The command is disabled and cannot be executed", nil), + RACUnderlyingCommandErrorKey: self + }]; + + return [RACSignal error:error]; + } + + RACSignal *signal = self.signalBlock(input); + NSCAssert(signal != nil, @"nil signal returned from signal block for value: %@", input); + + // We subscribe to the signal on the main thread so that it occurs _after_ + // -addActiveExecutionSignal: completes below. + // + // This means that `executing` and `enabled` will send updated values before + // the signal actually starts performing work. + RACMulticastConnection *connection = [[signal + subscribeOn:RACScheduler.mainThreadScheduler] + multicast:[RACReplaySubject subject]]; + + @weakify(self); + + [self addActiveExecutionSignal:connection.signal]; + [connection.signal subscribeError:^(NSError *error) { + @strongify(self); + [self removeActiveExecutionSignal:connection.signal]; + } completed:^{ + @strongify(self); + [self removeActiveExecutionSignal:connection.signal]; + }]; + + [connection connect]; + return [connection.signal setNameWithFormat:@"%@ -execute: %@", self, [input rac_description]]; +} + +#pragma mark NSKeyValueObserving + ++ (BOOL)automaticallyNotifiesObserversForKey:(NSString *)key { + // Generate all KVO notifications manually to avoid the performance impact + // of unnecessary swizzling. + return NO; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACCompoundDisposable.h b/ReactiveCocoaFramework/ReactiveCocoa/RACCompoundDisposable.h new file mode 100644 index 0000000..bb25f7d --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACCompoundDisposable.h
@@ -0,0 +1,48 @@ +// +// RACCompoundDisposable.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 11/30/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACDisposable.h" + +/// A disposable of disposables. When it is disposed, it disposes of all its +/// contained disposables. +/// +/// If -addDisposable: is called after the compound disposable has been disposed +/// of, the given disposable is immediately disposed. This allows a compound +/// disposable to act as a stand-in for a disposable that will be delivered +/// asynchronously. +@interface RACCompoundDisposable : RACDisposable + +/// Creates and returns a new compound disposable. ++ (instancetype)compoundDisposable; + +/// Creates and returns a new compound disposable containing the given +/// disposables. ++ (instancetype)compoundDisposableWithDisposables:(NSArray *)disposables; + +/// Adds the given disposable. If the receiving disposable has already been +/// disposed of, the given disposable is disposed immediately. +/// +/// This method is thread-safe. +/// +/// disposable - The disposable to add. This may be nil, in which case nothing +/// happens. +- (void)addDisposable:(RACDisposable *)disposable; + +/// Removes the specified disposable from the compound disposable (regardless of +/// its disposed status), or does nothing if it's not in the compound disposable. +/// +/// This is mainly useful for limiting the memory usage of the compound +/// disposable for long-running operations. +/// +/// This method is thread-safe. +/// +/// disposable - The disposable to remove. This argument may be nil (to make the +/// use of weak references easier). +- (void)removeDisposable:(RACDisposable *)disposable; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACCompoundDisposable.m b/ReactiveCocoaFramework/ReactiveCocoa/RACCompoundDisposable.m new file mode 100644 index 0000000..3b0471c --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACCompoundDisposable.m
@@ -0,0 +1,239 @@ +// +// RACCompoundDisposable.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 11/30/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACCompoundDisposable.h" +#import "RACCompoundDisposableProvider.h" +#import <libkern/OSAtomic.h> + +// The number of child disposables for which space will be reserved directly in +// `RACCompoundDisposable`. +// +// This number has been empirically determined to provide a good tradeoff +// between performance, memory usage, and `RACCompoundDisposable` instance size +// in a moderately complex GUI application. +// +// Profile any change! +#define RACCompoundDisposableInlineCount 2 + +static CFMutableArrayRef RACCreateDisposablesArray(void) { + // Compare values using only pointer equality. + CFArrayCallBacks callbacks = kCFTypeArrayCallBacks; + callbacks.equal = NULL; + + return CFArrayCreateMutable(NULL, 0, &callbacks); +} + +@interface RACCompoundDisposable () { + // Used for synchronization. + OSSpinLock _spinLock; + + #if RACCompoundDisposableInlineCount + // A fast array to the first N of the receiver's disposables. + // + // Once this is full, `_disposables` will be created and used for additional + // disposables. + // + // This array should only be manipulated while _spinLock is held. + RACDisposable *_inlineDisposables[RACCompoundDisposableInlineCount]; + #endif + + // Contains the receiver's disposables. + // + // This array should only be manipulated while _spinLock is held. If + // `_disposed` is YES, this may be NULL. + CFMutableArrayRef _disposables; + + // Whether the receiver has already been disposed. + // + // This ivar should only be accessed while _spinLock is held. + BOOL _disposed; +} + +@end + +@implementation RACCompoundDisposable + +#pragma mark Properties + +- (BOOL)isDisposed { + OSSpinLockLock(&_spinLock); + BOOL disposed = _disposed; + OSSpinLockUnlock(&_spinLock); + + return disposed; +} + +#pragma mark Lifecycle + ++ (instancetype)compoundDisposable { + return [[self alloc] initWithDisposables:nil]; +} + ++ (instancetype)compoundDisposableWithDisposables:(NSArray *)disposables { + return [[self alloc] initWithDisposables:disposables]; +} + +- (id)initWithDisposables:(NSArray *)otherDisposables { + self = [self init]; + if (self == nil) return nil; + + #if RACCompoundDisposableInlineCount + [otherDisposables enumerateObjectsUsingBlock:^(RACDisposable *disposable, NSUInteger index, BOOL *stop) { + _inlineDisposables[index] = disposable; + + // Stop after this iteration if we've reached the end of the inlined + // array. + if (index == RACCompoundDisposableInlineCount - 1) *stop = YES; + }]; + #endif + + if (otherDisposables.count > RACCompoundDisposableInlineCount) { + _disposables = RACCreateDisposablesArray(); + + CFRange range = CFRangeMake(RACCompoundDisposableInlineCount, (CFIndex)otherDisposables.count - RACCompoundDisposableInlineCount); + CFArrayAppendArray(_disposables, (__bridge CFArrayRef)otherDisposables, range); + } + + return self; +} + +- (id)initWithBlock:(void (^)(void))block { + RACDisposable *disposable = [RACDisposable disposableWithBlock:block]; + return [self initWithDisposables:@[ disposable ]]; +} + +- (void)dealloc { + #if RACCompoundDisposableInlineCount + for (unsigned i = 0; i < RACCompoundDisposableInlineCount; i++) { + _inlineDisposables[i] = nil; + } + #endif + + if (_disposables != NULL) { + CFRelease(_disposables); + _disposables = NULL; + } +} + +#pragma mark Addition and Removal + +- (void)addDisposable:(RACDisposable *)disposable { + NSCParameterAssert(disposable != self); + if (disposable == nil) return; + + BOOL shouldDispose = NO; + + OSSpinLockLock(&_spinLock); + { + if (_disposed) { + shouldDispose = YES; + } else { + #if RACCompoundDisposableInlineCount + for (unsigned i = 0; i < RACCompoundDisposableInlineCount; i++) { + if (_inlineDisposables[i] == nil) { + _inlineDisposables[i] = disposable; + goto foundSlot; + } + } + #endif + + if (_disposables == NULL) _disposables = RACCreateDisposablesArray(); + CFArrayAppendValue(_disposables, (__bridge void *)disposable); + + if (RACCOMPOUNDDISPOSABLE_ADDED_ENABLED()) { + RACCOMPOUNDDISPOSABLE_ADDED(self.description.UTF8String, disposable.description.UTF8String, CFArrayGetCount(_disposables) + RACCompoundDisposableInlineCount); + } + + #if RACCompoundDisposableInlineCount + foundSlot:; + #endif + } + } + OSSpinLockUnlock(&_spinLock); + + // Performed outside of the lock in case the compound disposable is used + // recursively. + if (shouldDispose) [disposable dispose]; +} + +- (void)removeDisposable:(RACDisposable *)disposable { + if (disposable == nil) return; + + OSSpinLockLock(&_spinLock); + { + if (!_disposed) { + #if RACCompoundDisposableInlineCount + for (unsigned i = 0; i < RACCompoundDisposableInlineCount; i++) { + if (_inlineDisposables[i] == disposable) _inlineDisposables[i] = nil; + } + #endif + + if (_disposables != NULL) { + CFIndex count = CFArrayGetCount(_disposables); + for (CFIndex i = count - 1; i >= 0; i--) { + const void *item = CFArrayGetValueAtIndex(_disposables, i); + if (item == (__bridge void *)disposable) { + CFArrayRemoveValueAtIndex(_disposables, i); + } + } + + if (RACCOMPOUNDDISPOSABLE_REMOVED_ENABLED()) { + RACCOMPOUNDDISPOSABLE_REMOVED(self.description.UTF8String, disposable.description.UTF8String, CFArrayGetCount(_disposables) + RACCompoundDisposableInlineCount); + } + } + } + } + OSSpinLockUnlock(&_spinLock); +} + +#pragma mark RACDisposable + +static void disposeEach(const void *value, void *context) { + RACDisposable *disposable = (__bridge id)value; + [disposable dispose]; +} + +- (void)dispose { + #if RACCompoundDisposableInlineCount + RACDisposable *inlineCopy[RACCompoundDisposableInlineCount]; + #endif + + CFArrayRef remainingDisposables = NULL; + + OSSpinLockLock(&_spinLock); + { + _disposed = YES; + + #if RACCompoundDisposableInlineCount + for (unsigned i = 0; i < RACCompoundDisposableInlineCount; i++) { + inlineCopy[i] = _inlineDisposables[i]; + _inlineDisposables[i] = nil; + } + #endif + + remainingDisposables = _disposables; + _disposables = NULL; + } + OSSpinLockUnlock(&_spinLock); + + #if RACCompoundDisposableInlineCount + // Dispose outside of the lock in case the compound disposable is used + // recursively. + for (unsigned i = 0; i < RACCompoundDisposableInlineCount; i++) { + [inlineCopy[i] dispose]; + } + #endif + + if (remainingDisposables == NULL) return; + + CFIndex count = CFArrayGetCount(remainingDisposables); + CFArrayApplyFunction(remainingDisposables, CFRangeMake(0, count), &disposeEach, NULL); + CFRelease(remainingDisposables); +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACCompoundDisposableProvider.d b/ReactiveCocoaFramework/ReactiveCocoa/RACCompoundDisposableProvider.d new file mode 100644 index 0000000..847db19 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACCompoundDisposableProvider.d
@@ -0,0 +1,4 @@ +provider RACCompoundDisposable { + probe added(char *compoundDisposable, char *disposable, long newTotal); + probe removed(char *compoundDisposable, char *disposable, long newTotal); +};
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACDelegateProxy.h b/ReactiveCocoaFramework/ReactiveCocoa/RACDelegateProxy.h new file mode 100644 index 0000000..9ec96bd --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACDelegateProxy.h
@@ -0,0 +1,28 @@ +// +// RACDelegateProxy.h +// ReactiveCocoa +// +// Created by Cody Krieger on 5/19/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import <Foundation/Foundation.h> + +@class RACSignal; + +// A private delegate object suitable for using +// -rac_signalForSelector:fromProtocol: upon. +@interface RACDelegateProxy : NSObject + +// The delegate to which messages should be forwarded if not handled by +// any -signalForSelector: applications. +@property (nonatomic, unsafe_unretained) id rac_proxiedDelegate; + +// Creates a delegate proxy capable of responding to selectors from `protocol`. +- (instancetype)initWithProtocol:(Protocol *)protocol; + +// Calls -rac_signalForSelector:fromProtocol: using the `protocol` specified +// during initialization. +- (RACSignal *)signalForSelector:(SEL)selector; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACDelegateProxy.m b/ReactiveCocoaFramework/ReactiveCocoa/RACDelegateProxy.m new file mode 100644 index 0000000..1d4fcbc --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACDelegateProxy.m
@@ -0,0 +1,78 @@ +// +// RACDelegateProxy.m +// ReactiveCocoa +// +// Created by Cody Krieger on 5/19/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACDelegateProxy.h" +#import "RACSignal+Operations.h" +#import "NSObject+RACSelectorSignal.h" +#import "NSObject+RACDeallocating.h" +#import <objc/runtime.h> + +@interface RACDelegateProxy () { + // Declared as an ivar to avoid method naming conflicts. + Protocol *_protocol; +} + +@end + +@implementation RACDelegateProxy + +#pragma mark Lifecycle + +- (instancetype)initWithProtocol:(Protocol *)protocol { + NSCParameterAssert(protocol != NULL); + + self = [super init]; + if (self == nil) return nil; + + class_addProtocol(self.class, protocol); + + _protocol = protocol; + + return self; +} + +#pragma mark API + +- (RACSignal *)signalForSelector:(SEL)selector { + return [self rac_signalForSelector:selector fromProtocol:_protocol]; +} + +#pragma mark NSObject + +- (BOOL)isProxy { + return YES; +} + +- (void)forwardInvocation:(NSInvocation *)invocation { + [invocation invokeWithTarget:self.rac_proxiedDelegate]; +} + +- (NSMethodSignature *)methodSignatureForSelector:(SEL)selector { + // Look for the selector as an optional instance method. + struct objc_method_description methodDescription = protocol_getMethodDescription(_protocol, selector, NO, YES); + + if (methodDescription.name == NULL) { + // Then fall back to looking for a required instance + // method. + methodDescription = protocol_getMethodDescription(_protocol, selector, YES, YES); + if (methodDescription.name == NULL) return [super methodSignatureForSelector:selector]; + } + + return [NSMethodSignature signatureWithObjCTypes:methodDescription.types]; +} + +- (BOOL)respondsToSelector:(SEL)selector { + // Add the delegate to the autorelease pool, so it doesn't get deallocated + // between this method call and -forwardInvocation:. + __autoreleasing id delegate = self.rac_proxiedDelegate; + if ([delegate respondsToSelector:selector]) return YES; + + return [super respondsToSelector:selector]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACDisposable.h b/ReactiveCocoaFramework/ReactiveCocoa/RACDisposable.h new file mode 100644 index 0000000..1267d44 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACDisposable.h
@@ -0,0 +1,36 @@ +// +// RACDisposable.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 3/16/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import <Foundation/Foundation.h> + +@class RACScopedDisposable; + + +/// A disposable encapsulates the work necessary to tear down and cleanup a +/// subscription. +@interface RACDisposable : NSObject + +/// Whether the receiver has been disposed. +/// +/// Use of this property is discouraged, since it may be set to `YES` +/// concurrently at any time. +/// +/// This property is not KVO-compliant. +@property (atomic, assign, getter = isDisposed, readonly) BOOL disposed; + ++ (instancetype)disposableWithBlock:(void (^)(void))block; + +/// Performs the disposal work. Can be called multiple times, though subsequent +/// calls won't do anything. +- (void)dispose; + +/// Returns a new disposable which will dispose of this disposable when it gets +/// dealloc'd. +- (RACScopedDisposable *)asScopedDisposable; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACDisposable.m b/ReactiveCocoaFramework/ReactiveCocoa/RACDisposable.m new file mode 100644 index 0000000..08eceb2 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACDisposable.m
@@ -0,0 +1,92 @@ +// +// RACDisposable.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 3/16/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACDisposable.h" +#import "RACScopedDisposable.h" +#import <libkern/OSAtomic.h> + +@interface RACDisposable () { + // A copied block of type void (^)(void) containing the logic for disposal, + // a pointer to `self` if no logic should be performed upon disposal, or + // NULL if the receiver is already disposed. + // + // This should only be used atomically. + void * volatile _disposeBlock; +} + +@end + +@implementation RACDisposable + +#pragma mark Properties + +- (BOOL)isDisposed { + return _disposeBlock == NULL; +} + +#pragma mark Lifecycle + +- (id)init { + self = [super init]; + if (self == nil) return nil; + + _disposeBlock = (__bridge void *)self; + OSMemoryBarrier(); + + return self; +} + +- (id)initWithBlock:(void (^)(void))block { + NSCParameterAssert(block != nil); + + self = [super init]; + if (self == nil) return nil; + + _disposeBlock = (void *)CFBridgingRetain([block copy]); + OSMemoryBarrier(); + + return self; +} + ++ (instancetype)disposableWithBlock:(void (^)(void))block { + return [[self alloc] initWithBlock:block]; +} + +- (void)dealloc { + if (_disposeBlock == NULL || _disposeBlock == (__bridge void *)self) return; + + CFRelease(_disposeBlock); + _disposeBlock = NULL; +} + +#pragma mark Disposal + +- (void)dispose { + void (^disposeBlock)(void) = NULL; + + while (YES) { + void *blockPtr = _disposeBlock; + if (OSAtomicCompareAndSwapPtrBarrier(blockPtr, NULL, &_disposeBlock)) { + if (blockPtr != (__bridge void *)self) { + disposeBlock = CFBridgingRelease(blockPtr); + } + + break; + } + } + + if (disposeBlock != nil) disposeBlock(); +} + +#pragma mark Scoped Disposables + +- (RACScopedDisposable *)asScopedDisposable { + return [RACScopedDisposable scopedDisposableWithDisposable:self]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACDynamicSequence.h b/ReactiveCocoaFramework/ReactiveCocoa/RACDynamicSequence.h new file mode 100644 index 0000000..1e103e3 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACDynamicSequence.h
@@ -0,0 +1,20 @@ +// +// RACDynamicSequence.h +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-10-29. +// Copyright (c) 2012 GitHub. All rights reserved. +// + +#import "RACSequence.h" + +// Private class that implements a sequence dynamically using blocks. +@interface RACDynamicSequence : RACSequence + +// Returns a sequence which evaluates `dependencyBlock` only once, the first +// time either `headBlock` or `tailBlock` is evaluated. The result of +// `dependencyBlock` will be passed into `headBlock` and `tailBlock` when +// invoked. ++ (RACSequence *)sequenceWithLazyDependency:(id (^)(void))dependencyBlock headBlock:(id (^)(id dependency))headBlock tailBlock:(RACSequence *(^)(id dependency))tailBlock; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACDynamicSequence.m b/ReactiveCocoaFramework/ReactiveCocoa/RACDynamicSequence.m new file mode 100644 index 0000000..48a977b --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACDynamicSequence.m
@@ -0,0 +1,197 @@ +// +// RACDynamicSequence.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-10-29. +// Copyright (c) 2012 GitHub. All rights reserved. +// + +#import "RACDynamicSequence.h" +#import <libkern/OSAtomic.h> + +// Determines how RACDynamicSequences will be deallocated before the next one is +// shifted onto the autorelease pool. +// +// This avoids stack overflows when deallocating long chains of dynamic +// sequences. +#define DEALLOC_OVERFLOW_GUARD 100 + +@interface RACDynamicSequence () { + // The value for the "head" property, if it's been evaluated already. + // + // Because it's legal for head to be nil, this ivar is valid any time + // headBlock is nil. + // + // This ivar should only be accessed while synchronized on self. + id _head; + + // The value for the "tail" property, if it's been evaluated already. + // + // Because it's legal for tail to be nil, this ivar is valid any time + // tailBlock is nil. + // + // This ivar should only be accessed while synchronized on self. + RACSequence *_tail; + + // The result of an evaluated `dependencyBlock`. + // + // This ivar is valid any time `hasDependency` is YES and `dependencyBlock` + // is nil. + // + // This ivar should only be accessed while synchronized on self. + id _dependency; +} + +// A block used to evaluate head. This should be set to nil after `_head` has been +// initialized. +// +// This is marked `strong` instead of `copy` because of some bizarre block +// copying bug. See https://github.com/ReactiveCocoa/ReactiveCocoa/pull/506. +// +// The signature of this block varies based on the value of `hasDependency`: +// +// - If YES, this block is of type `id (^)(id)`. +// - If NO, this block is of type `id (^)(void)`. +// +// This property should only be accessed while synchronized on self. +@property (nonatomic, strong) id headBlock; + +// A block used to evaluate tail. This should be set to nil after `_tail` has been +// initialized. +// +// This is marked `strong` instead of `copy` because of some bizarre block +// copying bug. See https://github.com/ReactiveCocoa/ReactiveCocoa/pull/506. +// +// The signature of this block varies based on the value of `hasDependency`: +// +// - If YES, this block is of type `RACSequence * (^)(id)`. +// - If NO, this block is of type `RACSequence * (^)(void)`. +// +// This property should only be accessed while synchronized on self. +@property (nonatomic, strong) id tailBlock; + +// Whether the receiver was initialized with a `dependencyBlock`. +// +// This property should only be accessed while synchronized on self. +@property (nonatomic, assign) BOOL hasDependency; + +// A dependency which must be evaluated before `headBlock` and `tailBlock`. This +// should be set to nil after `_dependency` and `dependencyBlockExecuted` have +// been set. +// +// This is marked `strong` instead of `copy` because of some bizarre block +// copying bug. See https://github.com/ReactiveCocoa/ReactiveCocoa/pull/506. +// +// This property should only be accessed while synchronized on self. +@property (nonatomic, strong) id (^dependencyBlock)(void); + +@end + +@implementation RACDynamicSequence + +#pragma mark Lifecycle + ++ (RACSequence *)sequenceWithHeadBlock:(id (^)(void))headBlock tailBlock:(RACSequence *(^)(void))tailBlock { + NSCParameterAssert(headBlock != nil); + + RACDynamicSequence *seq = [[RACDynamicSequence alloc] init]; + seq.headBlock = [headBlock copy]; + seq.tailBlock = [tailBlock copy]; + seq.hasDependency = NO; + return seq; +} + ++ (RACSequence *)sequenceWithLazyDependency:(id (^)(void))dependencyBlock headBlock:(id (^)(id dependency))headBlock tailBlock:(RACSequence *(^)(id dependency))tailBlock { + NSCParameterAssert(dependencyBlock != nil); + NSCParameterAssert(headBlock != nil); + + RACDynamicSequence *seq = [[RACDynamicSequence alloc] init]; + seq.headBlock = [headBlock copy]; + seq.tailBlock = [tailBlock copy]; + seq.dependencyBlock = [dependencyBlock copy]; + seq.hasDependency = YES; + return seq; +} + +- (void)dealloc { + static volatile int32_t directDeallocCount = 0; + + if (OSAtomicIncrement32(&directDeallocCount) >= DEALLOC_OVERFLOW_GUARD) { + OSAtomicAdd32(-DEALLOC_OVERFLOW_GUARD, &directDeallocCount); + + // Put this sequence's tail onto the autorelease pool so we stop + // recursing. + __autoreleasing RACSequence *tail __attribute__((unused)) = _tail; + } + + _tail = nil; +} + +#pragma mark RACSequence + +- (id)head { + @synchronized (self) { + id untypedHeadBlock = self.headBlock; + if (untypedHeadBlock == nil) return _head; + + if (self.hasDependency) { + if (self.dependencyBlock != nil) { + _dependency = self.dependencyBlock(); + self.dependencyBlock = nil; + } + + id (^headBlock)(id) = untypedHeadBlock; + _head = headBlock(_dependency); + } else { + id (^headBlock)(void) = untypedHeadBlock; + _head = headBlock(); + } + + self.headBlock = nil; + return _head; + } +} + +- (RACSequence *)tail { + @synchronized (self) { + id untypedTailBlock = self.tailBlock; + if (untypedTailBlock == nil) return _tail; + + if (self.hasDependency) { + if (self.dependencyBlock != nil) { + _dependency = self.dependencyBlock(); + self.dependencyBlock = nil; + } + + RACSequence * (^tailBlock)(id) = untypedTailBlock; + _tail = tailBlock(_dependency); + } else { + RACSequence * (^tailBlock)(void) = untypedTailBlock; + _tail = tailBlock(); + } + + if (_tail.name == nil) _tail.name = self.name; + + self.tailBlock = nil; + return _tail; + } +} + +#pragma mark NSObject + +- (NSString *)description { + id head = @"(unresolved)"; + id tail = @"(unresolved)"; + + @synchronized (self) { + if (self.headBlock == nil) head = _head; + if (self.tailBlock == nil) { + tail = _tail; + if (tail == self) tail = @"(self)"; + } + } + + return [NSString stringWithFormat:@"<%@: %p>{ name = %@, head = %@, tail = %@ }", self.class, self, self.name, head, tail]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACDynamicSignal.h b/ReactiveCocoaFramework/ReactiveCocoa/RACDynamicSignal.h new file mode 100644 index 0000000..81ac6db --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACDynamicSignal.h
@@ -0,0 +1,17 @@ +// +// RACDynamicSignal.h +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-10-10. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACSignal.h" + +// A private `RACSignal` subclasses that implements its subscription behavior +// using a block. +@interface RACDynamicSignal : RACSignal + ++ (RACSignal *)createSignal:(RACDisposable * (^)(id<RACSubscriber> subscriber))didSubscribe; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACDynamicSignal.m b/ReactiveCocoaFramework/ReactiveCocoa/RACDynamicSignal.m new file mode 100644 index 0000000..7a8ec32 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACDynamicSignal.m
@@ -0,0 +1,189 @@ +// +// RACDynamicSignal.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-10-10. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACDynamicSignal.h" +#import "EXTScope.h" +#import "RACPassthroughSubscriber.h" +#import "RACScheduler+Private.h" +#import "RACSubscriber.h" +#import "RACCompoundDisposable.h" +#import <libkern/OSAtomic.h> + +// Retains dynamic signals while they wait for subscriptions. +// +// This set must only be used on the main thread. +static CFMutableSetRef RACActiveSignals = nil; + +// A linked list of RACDynamicSignals, used in RACActiveSignalsToCheck. +typedef struct RACSignalList { + CFTypeRef retainedSignal; + struct RACSignalList * restrict next; +} RACSignalList; + +// An atomic queue of signals to check for subscribers. If any signals with zero +// subscribers are found in this queue, they are removed from RACActiveSignals. +static OSQueueHead RACActiveSignalsToCheck = OS_ATOMIC_QUEUE_INIT; + +// Whether RACActiveSignalsToCheck will be enumerated on the next iteration on +// the main run loop. +static volatile uint32_t RACWillCheckActiveSignals = 0; + +@interface RACDynamicSignal () { + // Contains all subscribers to the receiver. + // + // All access to this array must be synchronized using `_subscribersLock`. + NSMutableArray *_subscribers; + + // Synchronizes access to `_subscribers`. + OSSpinLock _subscribersLock; +} + +// The block to invoke for each subscriber. +@property (nonatomic, copy, readonly) RACDisposable * (^didSubscribe)(id<RACSubscriber> subscriber); + +@end + +@implementation RACDynamicSignal + +#pragma mark Lifecycle + ++ (void)initialize { + if (self != RACDynamicSignal.class) return; + + CFSetCallBacks callbacks = kCFTypeSetCallBacks; + + // Use pointer equality and hashes for membership testing. + callbacks.equal = NULL; + callbacks.hash = NULL; + + RACActiveSignals = CFSetCreateMutable(NULL, 0, &callbacks); +} + ++ (RACSignal *)createSignal:(RACDisposable * (^)(id<RACSubscriber> subscriber))didSubscribe { + RACDynamicSignal *signal = [[self alloc] init]; + signal->_didSubscribe = [didSubscribe copy]; + return [signal setNameWithFormat:@"+createSignal:"]; +} + +- (instancetype)init { + self = [super init]; + if (self == nil) return nil; + + // As soon as we're created we're already trying to be released. Such is life. + [self invalidateGlobalRefIfNoNewSubscribersShowUp]; + + return self; +} + +static void RACCheckActiveSignals(void) { + // Clear this flag now, so another thread can re-dispatch to the main queue + // as needed. + OSAtomicAnd32Barrier(0, &RACWillCheckActiveSignals); + + RACSignalList * restrict elem; + + while ((elem = OSAtomicDequeue(&RACActiveSignalsToCheck, offsetof(RACSignalList, next))) != NULL) { + RACDynamicSignal *signal = CFBridgingRelease(elem->retainedSignal); + free(elem); + + if (signal.hasSubscribers) { + // We want to keep the signal around until all its subscribers are done + CFSetAddValue(RACActiveSignals, (__bridge void *)signal); + } else { + CFSetRemoveValue(RACActiveSignals, (__bridge void *)signal); + } + } +} + +- (void)invalidateGlobalRefIfNoNewSubscribersShowUp { + // If no one subscribes in one pass of the main run loop, then we're free to + // go. It's up to the caller to keep us alive if they still want us. + RACSignalList *elem = malloc(sizeof(*elem)); + + // This also serves to retain the signal until the next pass. + elem->retainedSignal = CFBridgingRetain(self); + OSAtomicEnqueue(&RACActiveSignalsToCheck, elem, offsetof(RACSignalList, next)); + + // Not using a barrier because duplicate scheduling isn't erroneous, just + // less optimized. + int32_t willCheck = OSAtomicOr32Orig(1, &RACWillCheckActiveSignals); + + // Only schedule a check if RACWillCheckActiveSignals was 0 before. + if (willCheck == 0) { + dispatch_async(dispatch_get_main_queue(), ^{ + RACCheckActiveSignals(); + }); + } +} + +#pragma mark Managing Subscribers + +- (BOOL)hasSubscribers { + OSSpinLockLock(&_subscribersLock); + BOOL hasSubscribers = _subscribers.count > 0; + OSSpinLockUnlock(&_subscribersLock); + + return hasSubscribers; +} + +- (RACDisposable *)subscribe:(id<RACSubscriber>)subscriber { + NSCParameterAssert(subscriber != nil); + + RACCompoundDisposable *disposable = [RACCompoundDisposable compoundDisposable]; + subscriber = [[RACPassthroughSubscriber alloc] initWithSubscriber:subscriber signal:self disposable:disposable]; + + OSSpinLockLock(&_subscribersLock); + if (_subscribers == nil) { + _subscribers = [NSMutableArray arrayWithObject:subscriber]; + } else { + [_subscribers addObject:subscriber]; + } + OSSpinLockUnlock(&_subscribersLock); + + @weakify(self); + RACDisposable *defaultDisposable = [RACDisposable disposableWithBlock:^{ + @strongify(self); + if (self == nil) return; + + BOOL stillHasSubscribers = YES; + + OSSpinLockLock(&_subscribersLock); + { + // Since newer subscribers are generally shorter-lived, search + // starting from the end of the list. + NSUInteger index = [_subscribers indexOfObjectWithOptions:NSEnumerationReverse passingTest:^ BOOL (id<RACSubscriber> obj, NSUInteger index, BOOL *stop) { + return obj == subscriber; + }]; + + if (index != NSNotFound) { + [_subscribers removeObjectAtIndex:index]; + stillHasSubscribers = _subscribers.count > 0; + } + } + OSSpinLockUnlock(&_subscribersLock); + + if (!stillHasSubscribers) { + [self invalidateGlobalRefIfNoNewSubscribersShowUp]; + } + }]; + + [disposable addDisposable:defaultDisposable]; + + if (self.didSubscribe != NULL) { + RACDisposable *schedulingDisposable = [RACScheduler.subscriptionScheduler schedule:^{ + RACDisposable *innerDisposable = self.didSubscribe(subscriber); + [disposable addDisposable:innerDisposable]; + }]; + + [disposable addDisposable:schedulingDisposable]; + } + + return disposable; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACEagerSequence.h b/ReactiveCocoaFramework/ReactiveCocoa/RACEagerSequence.h new file mode 100644 index 0000000..ab5aa9f --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACEagerSequence.h
@@ -0,0 +1,14 @@ +// +// RACEagerSequence.h +// ReactiveCocoa +// +// Created by Uri Baghin on 02/01/2013. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACArraySequence.h" + +// Private class that implements an eager sequence. +@interface RACEagerSequence : RACArraySequence + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACEagerSequence.m b/ReactiveCocoaFramework/ReactiveCocoa/RACEagerSequence.m new file mode 100644 index 0000000..f12fbe9 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACEagerSequence.m
@@ -0,0 +1,66 @@ +// +// RACEagerSequence.m +// ReactiveCocoa +// +// Created by Uri Baghin on 02/01/2013. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACEagerSequence.h" +#import "NSObject+RACDescription.h" +#import "RACArraySequence.h" + +@implementation RACEagerSequence + +#pragma mark RACStream + ++ (instancetype)return:(id)value { + return [[self sequenceWithArray:@[ value ] offset:0] setNameWithFormat:@"+return: %@", [value rac_description]]; +} + +- (instancetype)bind:(RACStreamBindBlock (^)(void))block { + NSCParameterAssert(block != nil); + RACStreamBindBlock bindBlock = block(); + NSArray *currentArray = self.array; + NSMutableArray *resultArray = [NSMutableArray arrayWithCapacity:currentArray.count]; + + for (id value in currentArray) { + BOOL stop = NO; + RACSequence *boundValue = (id)bindBlock(value, &stop); + if (boundValue == nil) break; + + for (id x in boundValue) { + [resultArray addObject:x]; + } + + if (stop) break; + } + + return [[self.class sequenceWithArray:resultArray offset:0] setNameWithFormat:@"[%@] -bind:", self.name]; +} + +- (instancetype)concat:(RACSequence *)sequence { + NSCParameterAssert(sequence != nil); + NSCParameterAssert([sequence isKindOfClass:RACSequence.class]); + + NSArray *array = [self.array arrayByAddingObjectsFromArray:sequence.array]; + return [[self.class sequenceWithArray:array offset:0] setNameWithFormat:@"[%@] -concat: %@", self.name, sequence]; +} + +#pragma mark Extended methods + +- (RACSequence *)eagerSequence { + return self; +} + +- (RACSequence *)lazySequence { + return [RACArraySequence sequenceWithArray:self.array offset:0]; +} + +- (id)foldRightWithStart:(id)start reduce:(id (^)(id, RACSequence *rest))reduce { + return [super foldRightWithStart:start reduce:^(id first, RACSequence *rest) { + return reduce(first, rest.eagerSequence); + }]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACEmptySequence.h b/ReactiveCocoaFramework/ReactiveCocoa/RACEmptySequence.h new file mode 100644 index 0000000..140c78b --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACEmptySequence.h
@@ -0,0 +1,14 @@ +// +// RACEmptySequence.h +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-10-29. +// Copyright (c) 2012 GitHub. All rights reserved. +// + +#import "RACSequence.h" + +// Private class representing an empty sequence. +@interface RACEmptySequence : RACSequence + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACEmptySequence.m b/ReactiveCocoaFramework/ReactiveCocoa/RACEmptySequence.m new file mode 100644 index 0000000..e4df150 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACEmptySequence.m
@@ -0,0 +1,71 @@ +// +// RACEmptySequence.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-10-29. +// Copyright (c) 2012 GitHub. All rights reserved. +// + +#import "RACEmptySequence.h" + +@implementation RACEmptySequence + +#pragma mark Lifecycle + ++ (instancetype)empty { + static id singleton; + static dispatch_once_t pred; + + dispatch_once(&pred, ^{ + singleton = [[self alloc] init]; + }); + + return singleton; +} + +#pragma mark RACSequence + +- (id)head { + return nil; +} + +- (RACSequence *)tail { + return nil; +} + +- (RACSequence *)bind:(RACStreamBindBlock)bindBlock passingThroughValuesFromSequence:(RACSequence *)passthroughSequence { + return passthroughSequence ?: self; +} + +#pragma mark NSCoding + +- (Class)classForCoder { + // Empty sequences should be encoded as themselves, not array sequences. + return self.class; +} + +- (id)initWithCoder:(NSCoder *)coder { + // Return the singleton. + return self.class.empty; +} + +- (void)encodeWithCoder:(NSCoder *)coder { +} + +#pragma mark NSObject + +- (NSString *)description { + return [NSString stringWithFormat:@"<%@: %p>{ name = %@ }", self.class, self, self.name]; +} + +- (NSUInteger)hash { + // This hash isn't ideal, but it's better than -[RACSequence hash], which + // would just be zero because we have no head. + return (NSUInteger)(__bridge void *)self; +} + +- (BOOL)isEqual:(RACSequence *)seq { + return (self == seq); +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACEmptySignal.h b/ReactiveCocoaFramework/ReactiveCocoa/RACEmptySignal.h new file mode 100644 index 0000000..90b4f00 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACEmptySignal.h
@@ -0,0 +1,17 @@ +// +// RACEmptySignal.h +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-10-10. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACSignal.h" + +// A private `RACSignal` subclasses that synchronously sends completed to any +// subscribers. +@interface RACEmptySignal : RACSignal + ++ (RACSignal *)empty; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACEmptySignal.m b/ReactiveCocoaFramework/ReactiveCocoa/RACEmptySignal.m new file mode 100644 index 0000000..8bc8f41 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACEmptySignal.m
@@ -0,0 +1,62 @@ +// +// RACEmptySignal.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-10-10. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACEmptySignal.h" +#import "RACScheduler+Private.h" +#import "RACSubscriber.h" + +@implementation RACEmptySignal + +#pragma mark Properties + +// Only allow this signal's name to be customized in DEBUG, since it's +// a singleton in release builds (see +empty). +- (void)setName:(NSString *)name { +#ifdef DEBUG + [super setName:name]; +#endif +} + +- (NSString *)name { +#ifdef DEBUG + return super.name; +#else + return @"+empty"; +#endif +} + +#pragma mark Lifecycle + ++ (RACSignal *)empty { +#ifdef DEBUG + // Create multiple instances of this class in DEBUG so users can set custom + // names on each. + return [[[self alloc] init] setNameWithFormat:@"+empty"]; +#else + static id singleton; + static dispatch_once_t pred; + + dispatch_once(&pred, ^{ + singleton = [[self alloc] init]; + }); + + return singleton; +#endif +} + +#pragma mark Subscription + +- (RACDisposable *)subscribe:(id<RACSubscriber>)subscriber { + NSCParameterAssert(subscriber != nil); + + return [RACScheduler.subscriptionScheduler schedule:^{ + [subscriber sendCompleted]; + }]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACErrorSignal.h b/ReactiveCocoaFramework/ReactiveCocoa/RACErrorSignal.h new file mode 100644 index 0000000..c942f9e --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACErrorSignal.h
@@ -0,0 +1,17 @@ +// +// RACErrorSignal.h +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-10-10. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACSignal.h" + +// A private `RACSignal` subclasses that synchronously sends an error to any +// subscribers. +@interface RACErrorSignal : RACSignal + ++ (RACSignal *)error:(NSError *)error; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACErrorSignal.m b/ReactiveCocoaFramework/ReactiveCocoa/RACErrorSignal.m new file mode 100644 index 0000000..fd6778c --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACErrorSignal.m
@@ -0,0 +1,47 @@ +// +// RACErrorSignal.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-10-10. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACErrorSignal.h" +#import "RACScheduler+Private.h" +#import "RACSubscriber.h" + +@interface RACErrorSignal () + +// The error to send upon subscription. +@property (nonatomic, strong, readonly) NSError *error; + +@end + +@implementation RACErrorSignal + +#pragma mark Lifecycle + ++ (RACSignal *)error:(NSError *)error { + RACErrorSignal *signal = [[self alloc] init]; + signal->_error = error; + +#ifdef DEBUG + [signal setNameWithFormat:@"+error: %@", error]; +#else + signal.name = @"+error:"; +#endif + + return signal; +} + +#pragma mark Subscription + +- (RACDisposable *)subscribe:(id<RACSubscriber>)subscriber { + NSCParameterAssert(subscriber != nil); + + return [RACScheduler.subscriptionScheduler schedule:^{ + [subscriber sendError:self.error]; + }]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACEvent.h b/ReactiveCocoaFramework/ReactiveCocoa/RACEvent.h new file mode 100644 index 0000000..9e64e5a --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACEvent.h
@@ -0,0 +1,51 @@ +// +// RACEvent.h +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-01-07. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import <Foundation/Foundation.h> + +/// Describes the type of a RACEvent. +/// +/// RACEventTypeCompleted - A `completed` event. +/// RACEventTypeError - An `error` event. +/// RACEventTypeNext - A `next` event. +typedef enum : NSUInteger { + RACEventTypeCompleted, + RACEventTypeError, + RACEventTypeNext +} RACEventType; + +/// Represents an event sent by a RACSignal. +/// +/// This corresponds to the `Notification` class in Rx. +@interface RACEvent : NSObject <NSCopying> + +/// Returns a singleton RACEvent representing the `completed` event. ++ (instancetype)completedEvent; + +/// Returns a new event of type RACEventTypeError, containing the given error. ++ (instancetype)eventWithError:(NSError *)error; + +/// Returns a new event of type RACEventTypeNext, containing the given value. ++ (instancetype)eventWithValue:(id)value; + +/// The type of event represented by the receiver. +@property (nonatomic, assign, readonly) RACEventType eventType; + +/// Returns whether the receiver is of type RACEventTypeCompleted or +/// RACEventTypeError. +@property (nonatomic, getter = isFinished, assign, readonly) BOOL finished; + +/// The error associated with an event of type RACEventTypeError. This will be +/// nil for all other event types. +@property (nonatomic, strong, readonly) NSError *error; + +/// The value associated with an event of type RACEventTypeNext. This will be +/// nil for all other event types. +@property (nonatomic, strong, readonly) id value; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACEvent.m b/ReactiveCocoaFramework/ReactiveCocoa/RACEvent.m new file mode 100644 index 0000000..270a95d --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACEvent.m
@@ -0,0 +1,113 @@ +// +// RACEvent.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-01-07. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACEvent.h" + +@interface RACEvent () + +// An object associated with this event. This will be used for the error and +// value properties. +@property (nonatomic, strong, readonly) id object; + +// Initializes the receiver with the given type and object. +- (id)initWithEventType:(RACEventType)type object:(id)object; + +@end + +@implementation RACEvent + +#pragma mark Properties + +- (BOOL)isFinished { + return self.eventType == RACEventTypeCompleted || self.eventType == RACEventTypeError; +} + +- (NSError *)error { + return (self.eventType == RACEventTypeError ? self.object : nil); +} + +- (id)value { + return (self.eventType == RACEventTypeNext ? self.object : nil); +} + +#pragma mark Lifecycle + ++ (instancetype)completedEvent { + static dispatch_once_t pred; + static id singleton; + + dispatch_once(&pred, ^{ + singleton = [[self alloc] initWithEventType:RACEventTypeCompleted object:nil]; + }); + + return singleton; +} + ++ (instancetype)eventWithError:(NSError *)error { + return [[self alloc] initWithEventType:RACEventTypeError object:error]; +} + ++ (instancetype)eventWithValue:(id)value { + return [[self alloc] initWithEventType:RACEventTypeNext object:value]; +} + +- (id)initWithEventType:(RACEventType)type object:(id)object { + self = [super init]; + if (self == nil) return nil; + + _eventType = type; + _object = object; + + return self; +} + +#pragma mark NSCopying + +- (id)copyWithZone:(NSZone *)zone { + return self; +} + +#pragma mark NSObject + +- (NSString *)description { + NSString *eventDescription = nil; + + switch (self.eventType) { + case RACEventTypeCompleted: + eventDescription = @"completed"; + break; + + case RACEventTypeError: + eventDescription = [NSString stringWithFormat:@"error = %@", self.object]; + break; + + case RACEventTypeNext: + eventDescription = [NSString stringWithFormat:@"next = %@", self.object]; + break; + + default: + NSCAssert(NO, @"Unrecognized event type: %i", (int)self.eventType); + } + + return [NSString stringWithFormat:@"<%@: %p>{ %@ }", self.class, self, eventDescription]; +} + +- (NSUInteger)hash { + return self.eventType ^ [self.object hash]; +} + +- (BOOL)isEqual:(id)event { + if (event == self) return YES; + if (![event isKindOfClass:RACEvent.class]) return NO; + if (self.eventType != [event eventType]) return NO; + + // Catches the nil case too. + return self.object == [event object] || [self.object isEqual:[event object]]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACGroupedSignal.h b/ReactiveCocoaFramework/ReactiveCocoa/RACGroupedSignal.h new file mode 100644 index 0000000..697d922 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACGroupedSignal.h
@@ -0,0 +1,20 @@ +// +// RACGroupedSignal.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 5/2/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACSubject.h" + + +/// A grouped signal is used by -[RACSignal groupBy:transform:]. +@interface RACGroupedSignal : RACSubject + +/// The key shared by the group. +@property (nonatomic, readonly, copy) id<NSCopying> key; + ++ (instancetype)signalWithKey:(id<NSCopying>)key; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACGroupedSignal.m b/ReactiveCocoaFramework/ReactiveCocoa/RACGroupedSignal.m new file mode 100644 index 0000000..00e0378 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACGroupedSignal.m
@@ -0,0 +1,25 @@ +// +// RACGroupedSignal.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 5/2/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACGroupedSignal.h" + +@interface RACGroupedSignal () +@property (nonatomic, copy) id<NSCopying> key; +@end + +@implementation RACGroupedSignal + +#pragma mark API + ++ (instancetype)signalWithKey:(id<NSCopying>)key { + RACGroupedSignal *subject = [self subject]; + subject.key = key; + return subject; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACImmediateScheduler.h b/ReactiveCocoaFramework/ReactiveCocoa/RACImmediateScheduler.h new file mode 100644 index 0000000..76b5b50 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACImmediateScheduler.h
@@ -0,0 +1,14 @@ +// +// RACImmediateScheduler.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 11/30/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACScheduler.h" + +// A private scheduler which immediately executes its scheduled blocks. +@interface RACImmediateScheduler : RACScheduler + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACImmediateScheduler.m b/ReactiveCocoaFramework/ReactiveCocoa/RACImmediateScheduler.m new file mode 100644 index 0000000..f32eda3 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACImmediateScheduler.m
@@ -0,0 +1,44 @@ +// +// RACImmediateScheduler.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 11/30/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACImmediateScheduler.h" +#import "RACScheduler+Private.h" + +@implementation RACImmediateScheduler + +#pragma mark Lifecycle + +- (id)init { + return [super initWithName:@"com.ReactiveCocoa.RACScheduler.immediateScheduler"]; +} + +#pragma mark RACScheduler + +- (RACDisposable *)schedule:(void (^)(void))block { + NSCParameterAssert(block != NULL); + + block(); + return nil; +} + +- (RACDisposable *)after:(NSDate *)date schedule:(void (^)(void))block { + NSCParameterAssert(date != nil); + NSCParameterAssert(block != NULL); + + [NSThread sleepUntilDate:date]; + block(); + + return nil; +} + +- (RACDisposable *)after:(NSDate *)date repeatingEvery:(NSTimeInterval)interval withLeeway:(NSTimeInterval)leeway schedule:(void (^)(void))block { + NSCAssert(NO, @"+[RACScheduler immediateScheduler] does not support %@.", NSStringFromSelector(_cmd)); + return nil; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACIndexSetSequence.h b/ReactiveCocoaFramework/ReactiveCocoa/RACIndexSetSequence.h new file mode 100644 index 0000000..eab84a3 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACIndexSetSequence.h
@@ -0,0 +1,16 @@ +// +// RACIndexSetSequence.h +// ReactiveCocoa +// +// Created by Sergey Gavrilyuk on 12/18/13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACSequence.h" + +// Private class that adapts an array to the RACSequence interface. +@interface RACIndexSetSequence : RACSequence + ++ (instancetype)sequenceWithIndexSet:(NSIndexSet *)indexSet; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACIndexSetSequence.m b/ReactiveCocoaFramework/ReactiveCocoa/RACIndexSetSequence.m new file mode 100644 index 0000000..7ac8f53 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACIndexSetSequence.m
@@ -0,0 +1,108 @@ +// +// RACIndexSetSequence.m +// ReactiveCocoa +// +// Created by Sergey Gavrilyuk on 12/18/13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACIndexSetSequence.h" + +@interface RACIndexSetSequence () + +// A buffer holding the `NSUInteger` values to enumerate over. +// +// This is mostly used for memory management. Most access should go through +// `indexes` instead. +@property (nonatomic, strong, readonly) NSData *data; + +// The indexes that this sequence should enumerate. +@property (nonatomic, readonly) const NSUInteger *indexes; + +// The number of indexes to enumerate. +@property (nonatomic, readonly) NSUInteger count; + +@end + +@implementation RACIndexSetSequence + +#pragma mark Lifecycle + ++ (instancetype)sequenceWithIndexSet:(NSIndexSet *)indexSet { + NSUInteger count = indexSet.count; + NSUInteger sizeInBytes = sizeof(NSUInteger) * count; + + NSMutableData *data = [[NSMutableData alloc] initWithCapacity:sizeInBytes]; + [indexSet getIndexes:data.mutableBytes maxCount:count inIndexRange:NULL]; + + RACIndexSetSequence *seq = [[self alloc] init]; + seq->_data = data; + seq->_indexes = data.bytes; + seq->_count = count; + return seq; +} + ++ (instancetype)sequenceWithIndexSetSequence:(RACIndexSetSequence *)indexSetSequence offset:(NSUInteger)offset { + NSCParameterAssert(offset < indexSetSequence.count); + + RACIndexSetSequence *seq = [[self alloc] init]; + seq->_data = indexSetSequence.data; + seq->_indexes = indexSetSequence.indexes + offset; + seq->_count = indexSetSequence.count - offset; + return seq; +} + +#pragma mark RACSequence + +- (id)head { + return @(self.indexes[0]); +} + +- (RACSequence *)tail { + if (self.count <= 1) return [RACSequence empty]; + + return [self.class sequenceWithIndexSetSequence:self offset:1]; +} + +#pragma mark NSFastEnumeration + +- (NSUInteger)countByEnumeratingWithState:(NSFastEnumerationState *)state objects:(__unsafe_unretained id[])stackbuf count:(NSUInteger)len { + NSCParameterAssert(len > 0); + + if (state->state >= self.count) { + // Enumeration has completed. + return 0; + } + + if (state->state == 0) { + // Enumeration begun, mark the mutation flag. + state->mutationsPtr = state->extra; + } + + state->itemsPtr = stackbuf; + + unsigned long index = 0; + while (index < MIN(self.count - state->state, len)) { + stackbuf[index] = @(self.indexes[index + state->state]); + ++index; + } + + state->state += index; + return index; +} + +#pragma mark NSObject + +- (NSString *)description { + NSMutableString *indexesStr = [NSMutableString string]; + + for (unsigned int i = 0; i < self.count; ++i) { + if (i > 0) [indexesStr appendString:@", "]; + + [indexesStr appendFormat:@"%lu", (unsigned long)self.indexes[i]]; + } + + return [NSString stringWithFormat:@"<%@: %p>{ name = %@, indexes = %@ }", self.class, self, self.name, indexesStr]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACKVOChannel.h b/ReactiveCocoaFramework/ReactiveCocoa/RACKVOChannel.h new file mode 100644 index 0000000..0f72995 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACKVOChannel.h
@@ -0,0 +1,97 @@ +// +// RACKVOChannel.h +// ReactiveCocoa +// +// Created by Uri Baghin on 27/12/2012. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACChannel.h" +#import "EXTKeyPathCoding.h" +#import "metamacros.h" + +/// Creates a RACKVOChannel to the given key path. When the targeted object +/// deallocates, the channel will complete. +/// +/// If RACChannelTo() is used as an expression, it returns a RACChannelTerminal that +/// can be used to watch the specified property for changes, and set new values +/// for it. The terminal will start with the property's current value upon +/// subscription. +/// +/// If RACChannelTo() is used on the left-hand side of an assignment, there must a +/// RACChannelTerminal on the right-hand side of the assignment. The two will be +/// subscribed to one another: the property's value is immediately set to the +/// value of the channel terminal on the right-hand side, and subsequent changes +/// to either terminal will be reflected on the other. +/// +/// There are two different versions of this macro: +/// +/// - RACChannelTo(TARGET, KEYPATH, NILVALUE) will create a channel to the `KEYPATH` +/// of `TARGET`. If the terminal is ever sent a `nil` value, the property will +/// be set to `NILVALUE` instead. `NILVALUE` may itself be `nil` for object +/// properties, but an NSValue should be used for primitive properties, to +/// avoid an exception if `nil` is sent (which might occur if an intermediate +/// object is set to `nil`). +/// - RACChannelTo(TARGET, KEYPATH) is the same as the above, but `NILVALUE` defaults to +/// `nil`. +/// +/// Examples +/// +/// RACChannelTerminal *integerChannel = RACChannelTo(self, integerProperty, @42); +/// +/// // Sets self.integerProperty to 5. +/// [integerChannel sendNext:@5]; +/// +/// // Logs the current value of self.integerProperty, and all future changes. +/// [integerChannel subscribeNext:^(id value) { +/// NSLog(@"value: %@", value); +/// }]; +/// +/// // Binds properties to each other, taking the initial value from the right +/// side. +/// RACChannelTo(view, objectProperty) = RACChannelTo(model, objectProperty); +/// RACChannelTo(view, integerProperty, @2) = RACChannelTo(model, integerProperty, @10); +#define RACChannelTo(TARGET, ...) \ + metamacro_if_eq(1, metamacro_argcount(__VA_ARGS__)) \ + (RACChannelTo_(TARGET, __VA_ARGS__, nil)) \ + (RACChannelTo_(TARGET, __VA_ARGS__)) + +/// Do not use this directly. Use the RACChannelTo macro above. +#define RACChannelTo_(TARGET, KEYPATH, NILVALUE) \ + [[RACKVOChannel alloc] initWithTarget:(TARGET) keyPath:@keypath(TARGET, KEYPATH) nilValue:(NILVALUE)][@keypath(RACKVOChannel.new, followingTerminal)] + +/// A RACChannel that observes a KVO-compliant key path for changes. +@interface RACKVOChannel : RACChannel + +/// Initializes a channel that will observe the given object and key path. +/// +/// The current value of the key path, and future KVO notifications for the given +/// key path, will be sent to subscribers of the channel's `followingTerminal`. +/// Values sent to the `followingTerminal` will be set at the given key path using +/// key-value coding. +/// +/// When the target object deallocates, the channel will complete. Signal errors +/// are considered undefined behavior. +/// +/// This is the designated initializer for this class. +/// +/// target - The object to bind to. +/// keyPath - The key path to observe and set the value of. +/// nilValue - The value to set at the key path whenever a `nil` value is +/// received. This may be nil when connecting to object properties, but +/// an NSValue should be used for primitive properties, to avoid an +/// exception if `nil` is received (which might occur if an intermediate +/// object is set to `nil`). +- (id)initWithTarget:(NSObject *)target keyPath:(NSString *)keyPath nilValue:(id)nilValue; + +- (id)init __attribute__((unavailable("Use -initWithTarget:keyPath:nilValue: instead"))); + +@end + +/// Methods needed for the convenience macro. Do not call explicitly. +@interface RACKVOChannel (RACChannelTo) + +- (RACChannelTerminal *)objectForKeyedSubscript:(NSString *)key; +- (void)setObject:(RACChannelTerminal *)otherTerminal forKeyedSubscript:(NSString *)key; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACKVOChannel.m b/ReactiveCocoaFramework/ReactiveCocoa/RACKVOChannel.m new file mode 100644 index 0000000..7292a74 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACKVOChannel.m
@@ -0,0 +1,206 @@ +// +// RACKVOChannel.m +// ReactiveCocoa +// +// Created by Uri Baghin on 27/12/2012. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACKVOChannel.h" +#import "EXTScope.h" +#import "NSObject+RACDeallocating.h" +#import "NSObject+RACDescription.h" +#import "NSObject+RACKVOWrapper.h" +#import "NSObject+RACPropertySubscribing.h" +#import "NSString+RACKeyPathUtilities.h" +#import "RACChannel.h" +#import "RACCompoundDisposable.h" +#import "RACDisposable.h" +#import "RACReplaySubject.h" +#import "RACSignal+Operations.h" +#import "RACSubscriber+Private.h" +#import "RACSubject.h" + +// Key for the array of RACKVOChannel's additional thread local +// data in the thread dictionary. +static NSString * const RACKVOChannelDataDictionaryKey = @"RACKVOChannelKey"; + +// Wrapper class for additional thread local data. +@interface RACKVOChannelData : NSObject + +// The flag used to ignore updates the channel itself has triggered. +@property (nonatomic, assign) BOOL ignoreNextUpdate; + +// A pointer to the owner of the data. Only use this for pointer comparison, +// never as an object reference. +@property (nonatomic, assign) void *owner; + ++ (instancetype)dataForChannel:(RACKVOChannel *)channel; + +@end + +@interface RACKVOChannel () + +// The object whose key path the channel is wrapping. +@property (atomic, unsafe_unretained) NSObject *target; + +// The key path the channel is wrapping. +@property (nonatomic, copy, readonly) NSString *keyPath; + +// Returns the existing thread local data container or nil if none exists. +@property (nonatomic, strong, readonly) RACKVOChannelData *currentThreadData; + +// Creates the thread local data container for the channel. +- (void)createCurrentThreadData; + +// Destroy the thread local data container for the channel. +- (void)destroyCurrentThreadData; + +@end + +@implementation RACKVOChannel + +#pragma mark Properties + +- (RACKVOChannelData *)currentThreadData { + NSMutableArray *dataArray = NSThread.currentThread.threadDictionary[RACKVOChannelDataDictionaryKey]; + + for (RACKVOChannelData *data in dataArray) { + if (data.owner == (__bridge void *)self) return data; + } + + return nil; +} + +#pragma mark Lifecycle + +- (id)initWithTarget:(NSObject *)target keyPath:(NSString *)keyPath nilValue:(id)nilValue { + NSCParameterAssert(keyPath.rac_keyPathComponents.count > 0); + + self = [super init]; + if (self == nil) return nil; + + _target = target; + _keyPath = [keyPath copy]; + + [self.leadingTerminal setNameWithFormat:@"[-initWithTarget: %@ keyPath: %@ nilValue: %@] -leadingTerminal", target, keyPath, nilValue]; + [self.followingTerminal setNameWithFormat:@"[-initWithTarget: %@ keyPath: %@ nilValue: %@] -followingTerminal", target, keyPath, nilValue]; + + // Observe the key path on target for changes and forward the changes to the + // terminal. + // + // Intentionally capturing `self` strongly in the blocks below, so the + // channel object stays alive while observing. + RACDisposable *observationDisposable = [target rac_observeKeyPath:keyPath options:NSKeyValueObservingOptionInitial observer:nil block:^(id value, NSDictionary *change) { + // If the change wasn't triggered by deallocation, only affects the last + // path component, and ignoreNextUpdate is set, then it was triggered by + // this channel and should not be forwarded. + if (![change[RACKeyValueChangeCausedByDeallocationKey] boolValue] && [change[RACKeyValueChangeAffectedOnlyLastComponentKey] boolValue] && self.currentThreadData.ignoreNextUpdate) { + [self destroyCurrentThreadData]; + return; + } + + [self.leadingTerminal sendNext:value]; + }]; + + NSString *keyPathByDeletingLastKeyPathComponent = keyPath.rac_keyPathByDeletingLastKeyPathComponent; + NSArray *keyPathComponents = keyPath.rac_keyPathComponents; + NSUInteger keyPathComponentsCount = keyPathComponents.count; + NSString *lastKeyPathComponent = keyPathComponents.lastObject; + + // Update the value of the property with the values received. + [[self.leadingTerminal + finally:^{ + [observationDisposable dispose]; + }] + subscribeNext:^(id x) { + // Check the value of the second to last key path component. Since the + // channel can only update the value of a property on an object, and not + // update intermediate objects, it can only update the value of the whole + // key path if this object is not nil. + NSObject *object = (keyPathComponentsCount > 1 ? [self.target valueForKeyPath:keyPathByDeletingLastKeyPathComponent] : self.target); + if (object == nil) return; + + // Set the ignoreNextUpdate flag before setting the value so this channel + // ignores the value in the subsequent -didChangeValueForKey: callback. + [self createCurrentThreadData]; + self.currentThreadData.ignoreNextUpdate = YES; + + [object setValue:x ?: nilValue forKey:lastKeyPathComponent]; + } error:^(NSError *error) { + NSCAssert(NO, @"Received error in %@: %@", self, error); + + // Log the error if we're running with assertions disabled. + NSLog(@"Received error in %@: %@", self, error); + }]; + + // Capture `self` weakly for the target's deallocation disposable, so we can + // freely deallocate if we complete before then. + @weakify(self); + + [target.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + @strongify(self); + [self.leadingTerminal sendCompleted]; + self.target = nil; + }]]; + + return self; +} + +- (void)createCurrentThreadData { + NSMutableArray *dataArray = NSThread.currentThread.threadDictionary[RACKVOChannelDataDictionaryKey]; + if (dataArray == nil) { + dataArray = [NSMutableArray array]; + NSThread.currentThread.threadDictionary[RACKVOChannelDataDictionaryKey] = dataArray; + [dataArray addObject:[RACKVOChannelData dataForChannel:self]]; + return; + } + + for (RACKVOChannelData *data in dataArray) { + if (data.owner == (__bridge void *)self) return; + } + + [dataArray addObject:[RACKVOChannelData dataForChannel:self]]; +} + +- (void)destroyCurrentThreadData { + NSMutableArray *dataArray = NSThread.currentThread.threadDictionary[RACKVOChannelDataDictionaryKey]; + NSUInteger index = [dataArray indexOfObjectPassingTest:^ BOOL (RACKVOChannelData *data, NSUInteger idx, BOOL *stop) { + return data.owner == (__bridge void *)self; + }]; + + if (index != NSNotFound) [dataArray removeObjectAtIndex:index]; +} + +@end + +@implementation RACKVOChannel (RACChannelTo) + +- (RACChannelTerminal *)objectForKeyedSubscript:(NSString *)key { + NSCParameterAssert(key != nil); + + RACChannelTerminal *terminal = [self valueForKey:key]; + NSCAssert([terminal isKindOfClass:RACChannelTerminal.class], @"Key \"%@\" does not identify a channel terminal", key); + + return terminal; +} + +- (void)setObject:(RACChannelTerminal *)otherTerminal forKeyedSubscript:(NSString *)key { + NSCParameterAssert(otherTerminal != nil); + + RACChannelTerminal *selfTerminal = [self objectForKeyedSubscript:key]; + [otherTerminal subscribe:selfTerminal]; + [[selfTerminal skip:1] subscribe:otherTerminal]; +} + +@end + +@implementation RACKVOChannelData + ++ (instancetype)dataForChannel:(RACKVOChannel *)channel { + RACKVOChannelData *data = [[self alloc] init]; + data->_owner = (__bridge void *)channel; + return data; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACKVOTrampoline.h b/ReactiveCocoaFramework/ReactiveCocoa/RACKVOTrampoline.h new file mode 100644 index 0000000..5701486 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACKVOTrampoline.h
@@ -0,0 +1,31 @@ +// +// RACKVOTrampoline.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 1/15/13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import <Foundation/Foundation.h> +#import "NSObject+RACKVOWrapper.h" +#import "RACDisposable.h" + +// A private trampoline object that represents a KVO observation. +// +// Disposing of the trampoline will stop observation. +@interface RACKVOTrampoline : RACDisposable + +// Initializes the receiver with the given parameters. +// +// target - The object whose key path should be observed. Cannot be nil. +// observer - The object that gets notified when the value at the key path +// changes. Can be nil. +// keyPath - The key path on `target` to observe. Cannot be nil. +// options - Any key value observing options to use in the observation. +// block - The block to call when the value at the observed key path changes. +// Cannot be nil. +// +// Returns the initialized object. +- (id)initWithTarget:(NSObject *)target observer:(NSObject *)observer keyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options block:(RACKVOBlock)block; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACKVOTrampoline.m b/ReactiveCocoaFramework/ReactiveCocoa/RACKVOTrampoline.m new file mode 100644 index 0000000..1e4feae --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACKVOTrampoline.m
@@ -0,0 +1,100 @@ +// +// RACKVOTrampoline.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 1/15/13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACKVOTrampoline.h" +#import "NSObject+RACDeallocating.h" +#import "RACCompoundDisposable.h" + +static void *RACKVOWrapperContext = &RACKVOWrapperContext; + +@interface RACKVOTrampoline () + +// The keypath which the trampoline is observing. +@property (nonatomic, readonly, copy) NSString *keyPath; + +// These properties should only be manipulated while synchronized on the +// receiver. +@property (nonatomic, readonly, copy) RACKVOBlock block; +@property (nonatomic, readonly, unsafe_unretained) NSObject *target; +@property (nonatomic, readonly, unsafe_unretained) NSObject *observer; + +@end + +@implementation RACKVOTrampoline + +#pragma mark Lifecycle + +- (id)initWithTarget:(NSObject *)target observer:(NSObject *)observer keyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options block:(RACKVOBlock)block { + NSCParameterAssert(target != nil); + NSCParameterAssert(keyPath != nil); + NSCParameterAssert(block != nil); + + self = [super init]; + if (self == nil) return nil; + + _keyPath = [keyPath copy]; + + _block = [block copy]; + _target = target; + _observer = observer; + + [self.target addObserver:self forKeyPath:self.keyPath options:options context:&RACKVOWrapperContext]; + [self.target.rac_deallocDisposable addDisposable:self]; + [self.observer.rac_deallocDisposable addDisposable:self]; + + return self; +} + +- (void)dealloc { + [self dispose]; +} + +#pragma mark Observation + +- (void)dispose { + NSObject *target; + NSObject *observer; + + @synchronized (self) { + _block = nil; + + target = self.target; + observer = self.observer; + + _target = nil; + _observer = nil; + } + + [target.rac_deallocDisposable removeDisposable:self]; + [observer.rac_deallocDisposable removeDisposable:self]; + + [target removeObserver:self forKeyPath:self.keyPath context:&RACKVOWrapperContext]; +} + +- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context { + if (context != &RACKVOWrapperContext) { + [super observeValueForKeyPath:keyPath ofObject:object change:change context:context]; + return; + } + + RACKVOBlock block; + id observer; + id target; + + @synchronized (self) { + block = self.block; + observer = self.observer; + target = self.target; + } + + if (block == nil) return; + + block(target, observer, change); +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACMulticastConnection+Private.h b/ReactiveCocoaFramework/ReactiveCocoa/RACMulticastConnection+Private.h new file mode 100644 index 0000000..43931f8 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACMulticastConnection+Private.h
@@ -0,0 +1,17 @@ +// +// RACMulticastConnection+Private.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 4/11/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACMulticastConnection.h" + +@class RACSubject; + +@interface RACMulticastConnection () + +- (id)initWithSourceSignal:(RACSignal *)source subject:(RACSubject *)subject; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACMulticastConnection.h b/ReactiveCocoaFramework/ReactiveCocoa/RACMulticastConnection.h new file mode 100644 index 0000000..5361f5d --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACMulticastConnection.h
@@ -0,0 +1,46 @@ +// +// RACMulticastConnection.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 4/11/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +@class RACSignal; +@class RACDisposable; + +/// A multicast connection encapsulates the idea of sharing one subscription to a +/// signal to many subscribers. This is most often needed if the subscription to +/// the underlying signal involves side-effects or shouldn't be called more than +/// once. +/// +/// The multicasted signal is only subscribed to when +/// -[RACMulticastConnection connect] is called. Until that happens, no values +/// will be sent on `signal`. See -[RACMulticastConnection autoconnect] for how +/// -[RACMulticastConnection connect] can be called automatically. +/// +/// Note that you shouldn't create RACMulticastConnection manually. Instead use +/// -[RACSignal publish] or -[RACSignal multicast:]. +@interface RACMulticastConnection : NSObject + +/// The multicasted signal. +@property (nonatomic, strong, readonly) RACSignal *signal; + +/// Connect to the underlying signal by subscribing to it. Calling this multiple +/// times does nothing but return the existing connection's disposable. +/// +/// Returns the disposable for the subscription to the multicasted signal. +- (RACDisposable *)connect; + +/// Connects to the underlying signal when the returned signal is first +/// subscribed to, and disposes of the subscription to the multicasted signal +/// when the returned signal has no subscribers. +/// +/// If new subscribers show up after being disposed, they'll subscribe and then +/// be immediately disposed of. The returned signal will never re-connect to the +/// multicasted signal. +/// +/// Returns the autoconnecting signal. +- (RACSignal *)autoconnect; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACMulticastConnection.m b/ReactiveCocoaFramework/ReactiveCocoa/RACMulticastConnection.m new file mode 100644 index 0000000..1534d96 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACMulticastConnection.m
@@ -0,0 +1,85 @@ +// +// RACMulticastConnection.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 4/11/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACMulticastConnection.h" +#import "RACMulticastConnection+Private.h" +#import "RACDisposable.h" +#import "RACSerialDisposable.h" +#import "RACSubject.h" +#import <libkern/OSAtomic.h> + +@interface RACMulticastConnection () { + RACSubject *_signal; + + // When connecting, a caller should attempt to atomically swap the value of this + // from `0` to `1`. + // + // If the swap is successful the caller is resposible for subscribing `_signal` + // to `sourceSignal` and storing the returned disposable in `serialDisposable`. + // + // If the swap is unsuccessful it means that `_sourceSignal` has already been + // connected and the caller has no action to take. + int32_t volatile _hasConnected; +} + +@property (nonatomic, readonly, strong) RACSignal *sourceSignal; +@property (strong) RACSerialDisposable *serialDisposable; +@end + +@implementation RACMulticastConnection + +#pragma mark Lifecycle + +- (id)initWithSourceSignal:(RACSignal *)source subject:(RACSubject *)subject { + NSCParameterAssert(source != nil); + NSCParameterAssert(subject != nil); + + self = [super init]; + if (self == nil) return nil; + + _sourceSignal = source; + _serialDisposable = [[RACSerialDisposable alloc] init]; + _signal = subject; + + return self; +} + +#pragma mark Connecting + +- (RACDisposable *)connect { + BOOL shouldConnect = OSAtomicCompareAndSwap32Barrier(0, 1, &_hasConnected); + + if (shouldConnect) { + self.serialDisposable.disposable = [self.sourceSignal subscribe:_signal]; + } + + return self.serialDisposable; +} + +- (RACSignal *)autoconnect { + __block volatile int32_t subscriberCount = 0; + + return [[RACSignal + createSignal:^(id<RACSubscriber> subscriber) { + OSAtomicIncrement32Barrier(&subscriberCount); + + RACDisposable *subscriptionDisposable = [self.signal subscribe:subscriber]; + RACDisposable *connectionDisposable = [self connect]; + + return [RACDisposable disposableWithBlock:^{ + [subscriptionDisposable dispose]; + + if (OSAtomicDecrement32Barrier(&subscriberCount) == 0) { + [connectionDisposable dispose]; + } + }]; + }] + setNameWithFormat:@"[%@] -autoconnect", self.signal.name]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACObjCRuntime.h b/ReactiveCocoaFramework/ReactiveCocoa/RACObjCRuntime.h new file mode 100644 index 0000000..fbec61c --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACObjCRuntime.h
@@ -0,0 +1,17 @@ +// +// RACObjCRuntime.h +// ReactiveCocoa +// +// Created by Cody Krieger on 5/19/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import <Foundation/Foundation.h> + +// A private class containing wrappers to runtime functions. +@interface RACObjCRuntime : NSObject + +// Invokes objc_allocateClassPair(). Can be called from ARC code. ++ (Class)createClass:(const char *)className inheritingFromClass:(Class)superclass; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACObjCRuntime.m b/ReactiveCocoaFramework/ReactiveCocoa/RACObjCRuntime.m new file mode 100644 index 0000000..43cfc19 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACObjCRuntime.m
@@ -0,0 +1,22 @@ +// +// RACObjCRuntime.m +// ReactiveCocoa +// +// Created by Cody Krieger on 5/19/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACObjCRuntime.h" +#import <objc/runtime.h> + +#if __has_feature(objc_arc) +#error "This file must be compiled without ARC." +#endif + +@implementation RACObjCRuntime + ++ (Class)createClass:(const char *)className inheritingFromClass:(Class)superclass { + return objc_allocateClassPair(superclass, className, 0); +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACPassthroughSubscriber.h b/ReactiveCocoaFramework/ReactiveCocoa/RACPassthroughSubscriber.h new file mode 100644 index 0000000..9ae547b --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACPassthroughSubscriber.h
@@ -0,0 +1,29 @@ +// +// RACPassthroughSubscriber.h +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-06-13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import <Foundation/Foundation.h> +#import "RACSubscriber.h" + +@class RACCompoundDisposable; +@class RACSignal; + +// A private subscriber that passes through all events to another subscriber +// while not disposed. +@interface RACPassthroughSubscriber : NSObject <RACSubscriber> + +// Initializes the receiver to pass through events until disposed. +// +// subscriber - The subscriber to forward events to. This must not be nil. +// signal - The signal that will be sending events to the receiver. +// disposable - When this disposable is disposed, no more events will be +// forwarded. This must not be nil. +// +// Returns an initialized passthrough subscriber. +- (instancetype)initWithSubscriber:(id<RACSubscriber>)subscriber signal:(RACSignal *)signal disposable:(RACCompoundDisposable *)disposable; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACPassthroughSubscriber.m b/ReactiveCocoaFramework/ReactiveCocoa/RACPassthroughSubscriber.m new file mode 100644 index 0000000..614d7d5 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACPassthroughSubscriber.m
@@ -0,0 +1,103 @@ +// +// RACPassthroughSubscriber.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-06-13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACPassthroughSubscriber.h" +#import "RACCompoundDisposable.h" +#import "RACSignal.h" +#import "RACSignalProvider.h" + +static const char *cleanedDTraceString(NSString *original) { + return [original stringByReplacingOccurrencesOfString:@"\\s+" withString:@" " options:NSRegularExpressionSearch range:NSMakeRange(0, original.length)].UTF8String; +} + +static const char *cleanedSignalDescription(RACSignal *signal) { + NSString *desc = signal.description; + + NSRange range = [desc rangeOfString:@" name:"]; + if (range.location != NSNotFound) { + desc = [desc stringByReplacingCharactersInRange:range withString:@""]; + } + + return cleanedDTraceString(desc); +} + +@interface RACPassthroughSubscriber () + +// The subscriber to which events should be forwarded. +@property (nonatomic, strong, readonly) id<RACSubscriber> innerSubscriber; + +// The signal sending events to this subscriber. +// +// This property isn't `weak` because it's only used for DTrace probes, so +// a zeroing weak reference would incur an unnecessary performance penalty in +// normal usage. +@property (nonatomic, unsafe_unretained, readonly) RACSignal *signal; + +// A disposable representing the subscription. When disposed, no further events +// should be sent to the `innerSubscriber`. +@property (nonatomic, strong, readonly) RACCompoundDisposable *disposable; + +@end + +@implementation RACPassthroughSubscriber + +#pragma mark Lifecycle + +- (instancetype)initWithSubscriber:(id<RACSubscriber>)subscriber signal:(RACSignal *)signal disposable:(RACCompoundDisposable *)disposable { + NSCParameterAssert(subscriber != nil); + + self = [super init]; + if (self == nil) return nil; + + _innerSubscriber = subscriber; + _signal = signal; + _disposable = disposable; + + [self.innerSubscriber didSubscribeWithDisposable:self.disposable]; + return self; +} + +#pragma mark RACSubscriber + +- (void)sendNext:(id)value { + if (self.disposable.disposed) return; + + if (RACSIGNAL_NEXT_ENABLED()) { + RACSIGNAL_NEXT(cleanedSignalDescription(self.signal), cleanedDTraceString(self.innerSubscriber.description), cleanedDTraceString([value description])); + } + + [self.innerSubscriber sendNext:value]; +} + +- (void)sendError:(NSError *)error { + if (self.disposable.disposed) return; + + if (RACSIGNAL_ERROR_ENABLED()) { + RACSIGNAL_ERROR(cleanedSignalDescription(self.signal), cleanedDTraceString(self.innerSubscriber.description), cleanedDTraceString(error.description)); + } + + [self.innerSubscriber sendError:error]; +} + +- (void)sendCompleted { + if (self.disposable.disposed) return; + + if (RACSIGNAL_COMPLETED_ENABLED()) { + RACSIGNAL_COMPLETED(cleanedSignalDescription(self.signal), cleanedDTraceString(self.innerSubscriber.description)); + } + + [self.innerSubscriber sendCompleted]; +} + +- (void)didSubscribeWithDisposable:(RACCompoundDisposable *)disposable { + if (disposable != self.disposable) { + [self.disposable addDisposable:disposable]; + } +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACQueueScheduler+Subclass.h b/ReactiveCocoaFramework/ReactiveCocoa/RACQueueScheduler+Subclass.h new file mode 100644 index 0000000..48ef636 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACQueueScheduler+Subclass.h
@@ -0,0 +1,46 @@ +// +// RACQueueScheduler+Subclass.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 6/6/13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACQueueScheduler.h" + +/// An interface for use by subclasses. +/// +/// Subclasses should use `-performAsCurrentScheduler:` to do the actual block +/// invocation so that +[RACScheduler currentScheduler] behaves as expected. +/// +/// **Note that RACSchedulers are expected to be serial**. Subclasses must honor +/// that contract. See `RACTargetQueueScheduler` for a queue-based scheduler +/// which will enforce the serialization guarantee. +@interface RACQueueScheduler () + +/// The queue on which blocks are enqueued. +@property (nonatomic, readonly) dispatch_queue_t queue; + +/// Initializes the receiver with the name of the scheduler and the queue which +/// the scheduler should use. +/// +/// name - The name of the scheduler. If nil, a default name will be used. +/// queue - The queue upon which the receiver should enqueue scheduled blocks. +/// This argument must not be NULL. +/// +/// Returns the initialized object. +- (id)initWithName:(NSString *)name queue:(dispatch_queue_t)queue; + +/// Performs the given block with the receiver as the current scheduler for +/// `queue`. This should only be called by subclasses to perform scheduled blocks +/// on their queue. +/// +/// block - The block to execute. Cannot be NULL. +- (void)performAsCurrentScheduler:(void (^)(void))block; + +/// Converts a date into a GCD time using dispatch_walltime(). +/// +/// date - The date to convert. This must not be nil. ++ (dispatch_time_t)wallTimeWithDate:(NSDate *)date; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACQueueScheduler.h b/ReactiveCocoaFramework/ReactiveCocoa/RACQueueScheduler.h new file mode 100644 index 0000000..ef42512 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACQueueScheduler.h
@@ -0,0 +1,18 @@ +// +// RACQueueScheduler.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 11/30/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACScheduler.h" + +/// An abstract scheduler which asynchronously enqueues all its work to a Grand +/// Central Dispatch queue. +/// +/// Because RACQueueScheduler is abstract, it should not be instantiated +/// directly. Create a subclass using the `RACQueueScheduler+Subclass.h` +/// interface and use that instead. +@interface RACQueueScheduler : RACScheduler +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACQueueScheduler.m b/ReactiveCocoaFramework/ReactiveCocoa/RACQueueScheduler.m new file mode 100644 index 0000000..7ae8202 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACQueueScheduler.m
@@ -0,0 +1,120 @@ +// +// RACQueueScheduler.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 11/30/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACQueueScheduler.h" +#import "RACBacktrace.h" +#import "RACDisposable.h" +#import "RACQueueScheduler+Subclass.h" +#import "RACScheduler+Private.h" + +@implementation RACQueueScheduler + +#pragma mark Lifecycle + +- (void)dealloc { + dispatch_release(_queue); +} + +- (id)initWithName:(NSString *)name queue:(dispatch_queue_t)queue { + NSCParameterAssert(queue != NULL); + + self = [super initWithName:name]; + if (self == nil) return nil; + + dispatch_retain(queue); + _queue = queue; + + return self; +} + +#pragma mark Date Conversions + ++ (dispatch_time_t)wallTimeWithDate:(NSDate *)date { + NSCParameterAssert(date != nil); + + double seconds = 0; + double frac = modf(date.timeIntervalSince1970, &seconds); + + struct timespec walltime = { + .tv_sec = (time_t)fmin(fmax(seconds, LONG_MIN), LONG_MAX), + .tv_nsec = (long)fmin(fmax(frac * NSEC_PER_SEC, LONG_MIN), LONG_MAX) + }; + + return dispatch_walltime(&walltime, 0); +} + +#pragma mark RACScheduler + +- (RACDisposable *)schedule:(void (^)(void))block { + NSCParameterAssert(block != NULL); + + RACDisposable *disposable = [[RACDisposable alloc] init]; + + dispatch_async(self.queue, ^{ + if (disposable.disposed) return; + [self performAsCurrentScheduler:block]; + }); + + return disposable; +} + +- (RACDisposable *)after:(NSDate *)date schedule:(void (^)(void))block { + NSCParameterAssert(date != nil); + NSCParameterAssert(block != NULL); + + RACDisposable *disposable = [[RACDisposable alloc] init]; + + dispatch_after([self.class wallTimeWithDate:date], self.queue, ^{ + if (disposable.disposed) return; + [self performAsCurrentScheduler:block]; + }); + + return disposable; +} + +- (RACDisposable *)after:(NSDate *)date repeatingEvery:(NSTimeInterval)interval withLeeway:(NSTimeInterval)leeway schedule:(void (^)(void))block { + NSCParameterAssert(date != nil); + NSCParameterAssert(interval > 0.0 && interval < INT64_MAX / NSEC_PER_SEC); + NSCParameterAssert(leeway >= 0.0 && leeway < INT64_MAX / NSEC_PER_SEC); + NSCParameterAssert(block != NULL); + + uint64_t intervalInNanoSecs = (uint64_t)(interval * NSEC_PER_SEC); + uint64_t leewayInNanoSecs = (uint64_t)(leeway * NSEC_PER_SEC); + + dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, self.queue); + dispatch_source_set_timer(timer, [self.class wallTimeWithDate:date], intervalInNanoSecs, leewayInNanoSecs); + dispatch_source_set_event_handler(timer, block); + dispatch_resume(timer); + + return [RACDisposable disposableWithBlock:^{ + dispatch_source_cancel(timer); + dispatch_release(timer); + }]; +} + +- (void)performAsCurrentScheduler:(void (^)(void))block { + NSCParameterAssert(block != NULL); + + // If we're using a concurrent queue, we could end up in here concurrently, + // in which case we *don't* want to clear the current scheduler immediately + // after our block is done executing, but only *after* all our concurrent + // invocations are done. + + RACScheduler *previousScheduler = RACScheduler.currentScheduler; + NSThread.currentThread.threadDictionary[RACSchedulerCurrentSchedulerKey] = self; + + block(); + + if (previousScheduler != nil) { + NSThread.currentThread.threadDictionary[RACSchedulerCurrentSchedulerKey] = previousScheduler; + } else { + [NSThread.currentThread.threadDictionary removeObjectForKey:RACSchedulerCurrentSchedulerKey]; + } +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACReplaySubject.h b/ReactiveCocoaFramework/ReactiveCocoa/RACReplaySubject.h new file mode 100644 index 0000000..cd6f2ec --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACReplaySubject.h
@@ -0,0 +1,23 @@ +// +// RACReplaySubject.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 3/14/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACSubject.h" + +extern const NSUInteger RACReplaySubjectUnlimitedCapacity; + + +/// A replay subject saves the values it is sent (up to its defined capacity) +/// and resends those to new subscribers. It will also replay an error or +/// completion. +@interface RACReplaySubject : RACSubject + +/// Creates a new replay subject with the given capacity. A capacity of +/// RACReplaySubjectUnlimitedCapacity means values are never trimmed. ++ (instancetype)replaySubjectWithCapacity:(NSUInteger)capacity; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACReplaySubject.m b/ReactiveCocoaFramework/ReactiveCocoa/RACReplaySubject.m new file mode 100644 index 0000000..bca008e --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACReplaySubject.m
@@ -0,0 +1,112 @@ +// +// RACReplaySubject.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 3/14/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACReplaySubject.h" +#import "RACDisposable.h" +#import "RACScheduler+Private.h" +#import "RACSubscriber.h" +#import "RACTuple.h" +#import "RACCompoundDisposable.h" + +const NSUInteger RACReplaySubjectUnlimitedCapacity = NSUIntegerMax; + +@interface RACReplaySubject () + +@property (nonatomic, assign, readonly) NSUInteger capacity; + +// These properties should only be modified while synchronized on self. +@property (nonatomic, strong, readonly) NSMutableArray *valuesReceived; +@property (nonatomic, assign) BOOL hasCompleted; +@property (nonatomic, assign) BOOL hasError; +@property (nonatomic, strong) NSError *error; + +@end + + +@implementation RACReplaySubject + +#pragma mark Lifecycle + ++ (instancetype)replaySubjectWithCapacity:(NSUInteger)capacity { + return [[self alloc] initWithCapacity:capacity]; +} + +- (instancetype)init { + return [self initWithCapacity:RACReplaySubjectUnlimitedCapacity]; +} + +- (instancetype)initWithCapacity:(NSUInteger)capacity { + self = [super init]; + if (self == nil) return nil; + + _capacity = capacity; + _valuesReceived = (capacity == RACReplaySubjectUnlimitedCapacity ? [NSMutableArray array] : [NSMutableArray arrayWithCapacity:capacity]); + + return self; +} + +#pragma mark RACSignal + +- (RACDisposable *)subscribe:(id<RACSubscriber>)subscriber { + RACCompoundDisposable *compoundDisposable = [RACCompoundDisposable compoundDisposable]; + + RACDisposable *schedulingDisposable = [RACScheduler.subscriptionScheduler schedule:^{ + @synchronized (self) { + for (id value in self.valuesReceived) { + if (compoundDisposable.disposed) return; + + [subscriber sendNext:([value isKindOfClass:RACTupleNil.class] ? nil : value)]; + } + + if (compoundDisposable.disposed) return; + + if (self.hasCompleted) { + [subscriber sendCompleted]; + } else if (self.hasError) { + [subscriber sendError:self.error]; + } else { + RACDisposable *subscriptionDisposable = [super subscribe:subscriber]; + [compoundDisposable addDisposable:subscriptionDisposable]; + } + } + }]; + + [compoundDisposable addDisposable:schedulingDisposable]; + + return compoundDisposable; +} + +#pragma mark RACSubscriber + +- (void)sendNext:(id)value { + @synchronized (self) { + [self.valuesReceived addObject:value ?: RACTupleNil.tupleNil]; + [super sendNext:value]; + + if (self.capacity != RACReplaySubjectUnlimitedCapacity && self.valuesReceived.count > self.capacity) { + [self.valuesReceived removeObjectsInRange:NSMakeRange(0, self.valuesReceived.count - self.capacity)]; + } + } +} + +- (void)sendCompleted { + @synchronized (self) { + self.hasCompleted = YES; + [super sendCompleted]; + } +} + +- (void)sendError:(NSError *)e { + @synchronized (self) { + self.hasError = YES; + self.error = e; + [super sendError:e]; + } +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACReturnSignal.h b/ReactiveCocoaFramework/ReactiveCocoa/RACReturnSignal.h new file mode 100644 index 0000000..73e5674 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACReturnSignal.h
@@ -0,0 +1,17 @@ +// +// RACReturnSignal.h +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-10-10. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACSignal.h" + +// A private `RACSignal` subclasses that synchronously sends a value to any +// subscribers, then completes. +@interface RACReturnSignal : RACSignal + ++ (RACSignal *)return:(id)value; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACReturnSignal.m b/ReactiveCocoaFramework/ReactiveCocoa/RACReturnSignal.m new file mode 100644 index 0000000..3006634 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACReturnSignal.m
@@ -0,0 +1,90 @@ +// +// RACReturnSignal.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-10-10. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACReturnSignal.h" +#import "RACScheduler+Private.h" +#import "RACSubscriber.h" +#import "RACUnit.h" + +@interface RACReturnSignal () + +// The value to send upon subscription. +@property (nonatomic, strong, readonly) id value; + +@end + +@implementation RACReturnSignal + +#pragma mark Properties + +// Only allow this signal's name to be customized in DEBUG, since it's +// potentially a singleton in release builds (see +return:). +- (void)setName:(NSString *)name { +#ifdef DEBUG + [super setName:name]; +#endif +} + +- (NSString *)name { +#ifdef DEBUG + return super.name; +#else + return @"+return:"; +#endif +} + +#pragma mark Lifecycle + ++ (RACSignal *)return:(id)value { +#ifndef DEBUG + // In release builds, use singletons for two very common cases. + if (value == RACUnit.defaultUnit) { + static RACReturnSignal *unitSingleton; + static dispatch_once_t unitPred; + + dispatch_once(&unitPred, ^{ + unitSingleton = [[self alloc] init]; + unitSingleton->_value = RACUnit.defaultUnit; + }); + + return unitSingleton; + } else if (value == nil) { + static RACReturnSignal *nilSingleton; + static dispatch_once_t nilPred; + + dispatch_once(&nilPred, ^{ + nilSingleton = [[self alloc] init]; + nilSingleton->_value = nil; + }); + + return nilSingleton; + } +#endif + + RACReturnSignal *signal = [[self alloc] init]; + signal->_value = value; + +#ifdef DEBUG + [signal setNameWithFormat:@"+return: %@", value]; +#endif + + return signal; +} + +#pragma mark Subscription + +- (RACDisposable *)subscribe:(id<RACSubscriber>)subscriber { + NSCParameterAssert(subscriber != nil); + + return [RACScheduler.subscriptionScheduler schedule:^{ + [subscriber sendNext:self.value]; + [subscriber sendCompleted]; + }]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACScheduler+Private.h b/ReactiveCocoaFramework/ReactiveCocoa/RACScheduler+Private.h new file mode 100644 index 0000000..2c91e66 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACScheduler+Private.h
@@ -0,0 +1,34 @@ +// +// RACScheduler+Private.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 11/29/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACScheduler.h" + +// The thread-specific current scheduler key. +extern NSString * const RACSchedulerCurrentSchedulerKey; + +// A private interface for internal RAC use only. +@interface RACScheduler () + +// A dedicated scheduler that fills two requirements: +// +// 1. By the time subscription happens, we need a valid +currentScheduler. +// 2. Subscription should happen as soon as possible. +// +// To fulfill those two, if we already have a valid +currentScheduler, it +// immediately executes scheduled blocks. If we don't, it will execute scheduled +// blocks with a private background scheduler. ++ (instancetype)subscriptionScheduler; + +// Initializes the receiver with the given name. +// +// name - The name of the scheduler. If nil, a default name will be used. +// +// Returns the initialized object. +- (id)initWithName:(NSString *)name; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACScheduler.h b/ReactiveCocoaFramework/ReactiveCocoa/RACScheduler.h new file mode 100644 index 0000000..ce1ee32 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACScheduler.h
@@ -0,0 +1,148 @@ +// +// RACScheduler.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 4/16/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import <Foundation/Foundation.h> + +/// The priority for the scheduler. +/// +/// RACSchedulerPriorityHigh - High priority. +/// RACSchedulerPriorityDefault - Default priority. +/// RACSchedulerPriorityLow - Low priority. +/// RACSchedulerPriorityBackground - Background priority. +typedef enum : long { + RACSchedulerPriorityHigh = DISPATCH_QUEUE_PRIORITY_HIGH, + RACSchedulerPriorityDefault = DISPATCH_QUEUE_PRIORITY_DEFAULT, + RACSchedulerPriorityLow = DISPATCH_QUEUE_PRIORITY_LOW, + RACSchedulerPriorityBackground = DISPATCH_QUEUE_PRIORITY_BACKGROUND, +} RACSchedulerPriority; + +/// Scheduled with -scheduleRecursiveBlock:, this type of block is passed a block +/// with which it can call itself recursively. +typedef void (^RACSchedulerRecursiveBlock)(void (^reschedule)(void)); + +@class RACDisposable; + +/// Schedulers are used to control when and where work is performed. +@interface RACScheduler : NSObject + +/// A singleton scheduler that immediately executes the blocks it is given. +/// +/// **Note:** Unlike most other schedulers, this does not set the current +/// scheduler. There may still be a valid +currentScheduler if this is used +/// within a block scheduled on a different scheduler. ++ (RACScheduler *)immediateScheduler; + +/// A singleton scheduler that executes blocks in the main thread. ++ (RACScheduler *)mainThreadScheduler; + +/// Creates and returns a new background scheduler with the given priority and +/// name. The name is for debug and instrumentation purposes only. +/// +/// Scheduler creation is cheap. It's unnecessary to save the result of this +/// method call unless you want to serialize some actions on the same background +/// scheduler. ++ (RACScheduler *)schedulerWithPriority:(RACSchedulerPriority)priority name:(NSString *)name; + +/// Invokes +schedulerWithPriority:name: with a default name. ++ (RACScheduler *)schedulerWithPriority:(RACSchedulerPriority)priority; + +/// Invokes +schedulerWithPriority: with RACSchedulerPriorityDefault. ++ (RACScheduler *)scheduler; + +/// The current scheduler. This will only be valid when used from within a +/// -[RACScheduler schedule:] block or when on the main thread. ++ (RACScheduler *)currentScheduler; + +/// Schedule the given block for execution on the scheduler. +/// +/// Scheduled blocks will be executed in the order in which they were scheduled. +/// +/// block - The block to schedule for execution. Cannot be nil. +/// +/// Returns a disposable which can be used to cancel the scheduled block before +/// it begins executing, or nil if cancellation is not supported. +- (RACDisposable *)schedule:(void (^)(void))block; + +/// Schedule the given block for execution on the scheduler at or after +/// a specific time. +/// +/// Note that blocks scheduled for a certain time will not preempt any other +/// scheduled work that is executing at the time. +/// +/// When invoked on the +immediateScheduler, the calling thread **will block** +/// until the specified time. +/// +/// date - The earliest time at which `block` should begin executing. The block +/// may not execute immediately at this time, whether due to system load +/// or another block on the scheduler currently being run. Cannot be nil. +/// block - The block to schedule for execution. Cannot be nil. +/// +/// Returns a disposable which can be used to cancel the scheduled block before +/// it begins executing, or nil if cancellation is not supported. +- (RACDisposable *)after:(NSDate *)date schedule:(void (^)(void))block; + +/// Schedule the given block for execution on the scheduler after the delay. +/// +/// Converts the delay into an NSDate, then invokes `-after:schedule:`. +- (RACDisposable *)afterDelay:(NSTimeInterval)delay schedule:(void (^)(void))block; + +/// Reschedule the given block at a particular interval, starting at a specific +/// time, and with a given leeway for deferral. +/// +/// Note that blocks scheduled for a certain time will not preempt any other +/// scheduled work that is executing at the time. +/// +/// Regardless of the value of `leeway`, the given block may not execute exactly +/// at `when` or exactly on successive intervals, whether due to system load or +/// because another block is currently being run on the scheduler. +/// +/// It is considered undefined behavior to invoke this method on the +/// +immediateScheduler. +/// +/// date - The earliest time at which `block` should begin executing. The +/// block may not execute immediately at this time, whether due to +/// system load or another block on the scheduler currently being +/// run. Cannot be nil. +/// interval - The interval at which the block should be rescheduled, starting +/// from `date`. This will use the system wall clock, to avoid +/// skew when the computer goes to sleep. +/// leeway - A hint to the system indicating the number of seconds that each +/// scheduling can be deferred. Note that this is just a hint, and +/// there may be some additional latency no matter what. +/// block - The block to repeatedly schedule for execution. Cannot be nil. +/// +/// Returns a disposable which can be used to cancel the automatic scheduling and +/// rescheduling, or nil if cancellation is not supported. +- (RACDisposable *)after:(NSDate *)date repeatingEvery:(NSTimeInterval)interval withLeeway:(NSTimeInterval)leeway schedule:(void (^)(void))block; + +/// Schedule the given recursive block for execution on the scheduler. The +/// scheduler will automatically flatten any recursive scheduling into iteration +/// instead, so this can be used without issue for blocks that may keep invoking +/// themselves forever. +/// +/// Scheduled blocks will be executed in the order in which they were scheduled. +/// +/// recursiveBlock - The block to schedule for execution. When invoked, the +/// recursive block will be passed a `void (^)(void)` block +/// which will reschedule the recursive block at the end of the +/// receiver's queue. This passed-in block will automatically +/// skip scheduling if the scheduling of the `recursiveBlock` +/// was disposed in the meantime. +/// +/// Returns a disposable which can be used to cancel the scheduled block before +/// it begins executing, or to stop it from rescheduling if it's already begun +/// execution. +- (RACDisposable *)scheduleRecursiveBlock:(RACSchedulerRecursiveBlock)recursiveBlock; + +@end + +@interface RACScheduler (Deprecated) + ++ (RACScheduler *)schedulerWithQueue:(dispatch_queue_t)queue name:(NSString *)name __attribute__((deprecated("Use -[RACScheduler initWithName:targetQueue:] instead."))); + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACScheduler.m b/ReactiveCocoaFramework/ReactiveCocoa/RACScheduler.m new file mode 100644 index 0000000..c829896 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACScheduler.m
@@ -0,0 +1,206 @@ +// +// RACScheduler.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 4/16/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACScheduler.h" +#import "RACBacktrace.h" +#import "RACCompoundDisposable.h" +#import "RACDisposable.h" +#import "RACImmediateScheduler.h" +#import "RACScheduler+Private.h" +#import "RACSubscriptionScheduler.h" +#import "RACTargetQueueScheduler.h" + +// The key for the thread-specific current scheduler. +NSString * const RACSchedulerCurrentSchedulerKey = @"RACSchedulerCurrentSchedulerKey"; + +@interface RACScheduler () +@property (nonatomic, readonly, copy) NSString *name; +@end + +@implementation RACScheduler + +#pragma mark NSObject + +- (NSString *)description { + return [NSString stringWithFormat:@"<%@: %p> %@", self.class, self, self.name]; +} + +#pragma mark Initializers + +- (id)initWithName:(NSString *)name { + self = [super init]; + if (self == nil) return nil; + + if (name == nil) { + _name = [NSString stringWithFormat:@"com.ReactiveCocoa.%@.anonymousScheduler", self.class]; + } else { + _name = [name copy]; + } + + return self; +} + +#pragma mark Schedulers + ++ (instancetype)immediateScheduler { + static dispatch_once_t onceToken; + static RACScheduler *immediateScheduler; + dispatch_once(&onceToken, ^{ + immediateScheduler = [[RACImmediateScheduler alloc] init]; + }); + + return immediateScheduler; +} + ++ (instancetype)mainThreadScheduler { + static dispatch_once_t onceToken; + static RACScheduler *mainThreadScheduler; + dispatch_once(&onceToken, ^{ + mainThreadScheduler = [[RACTargetQueueScheduler alloc] initWithName:@"com.ReactiveCocoa.RACScheduler.mainThreadScheduler" targetQueue:dispatch_get_main_queue()]; + }); + + return mainThreadScheduler; +} + ++ (instancetype)schedulerWithPriority:(RACSchedulerPriority)priority name:(NSString *)name { + return [[RACTargetQueueScheduler alloc] initWithName:name targetQueue:dispatch_get_global_queue(priority, 0)]; +} + ++ (instancetype)schedulerWithPriority:(RACSchedulerPriority)priority { + return [self schedulerWithPriority:priority name:@"com.ReactiveCocoa.RACScheduler.backgroundScheduler"]; +} + ++ (instancetype)scheduler { + return [self schedulerWithPriority:RACSchedulerPriorityDefault]; +} + ++ (instancetype)subscriptionScheduler { + static dispatch_once_t onceToken; + static RACScheduler *subscriptionScheduler; + dispatch_once(&onceToken, ^{ + subscriptionScheduler = [[RACSubscriptionScheduler alloc] init]; + }); + + return subscriptionScheduler; +} + ++ (BOOL)isOnMainThread { + return [NSOperationQueue.currentQueue isEqual:NSOperationQueue.mainQueue] || [NSThread isMainThread]; +} + ++ (instancetype)currentScheduler { + RACScheduler *scheduler = NSThread.currentThread.threadDictionary[RACSchedulerCurrentSchedulerKey]; + if (scheduler != nil) return scheduler; + if ([self.class isOnMainThread]) return RACScheduler.mainThreadScheduler; + + return nil; +} + +#pragma mark Scheduling + +- (RACDisposable *)schedule:(void (^)(void))block { + NSCAssert(NO, @"%@ must be implemented by subclasses.", NSStringFromSelector(_cmd)); + return nil; +} + +- (RACDisposable *)after:(NSDate *)date schedule:(void (^)(void))block { + NSCAssert(NO, @"%@ must be implemented by subclasses.", NSStringFromSelector(_cmd)); + return nil; +} + +- (RACDisposable *)afterDelay:(NSTimeInterval)delay schedule:(void (^)(void))block { + return [self after:[NSDate dateWithTimeIntervalSinceNow:delay] schedule:block]; +} + +- (RACDisposable *)after:(NSDate *)date repeatingEvery:(NSTimeInterval)interval withLeeway:(NSTimeInterval)leeway schedule:(void (^)(void))block { + NSCAssert(NO, @"%@ must be implemented by subclasses.", NSStringFromSelector(_cmd)); + return nil; +} + +- (RACDisposable *)scheduleRecursiveBlock:(RACSchedulerRecursiveBlock)recursiveBlock { + RACCompoundDisposable *disposable = [RACCompoundDisposable compoundDisposable]; + + [self scheduleRecursiveBlock:[recursiveBlock copy] addingToDisposable:disposable]; + return disposable; +} + +- (void)scheduleRecursiveBlock:(RACSchedulerRecursiveBlock)recursiveBlock addingToDisposable:(RACCompoundDisposable *)disposable { + @autoreleasepool { + RACCompoundDisposable *selfDisposable = [RACCompoundDisposable compoundDisposable]; + [disposable addDisposable:selfDisposable]; + + __weak RACDisposable *weakSelfDisposable = selfDisposable; + + RACDisposable *schedulingDisposable = [self schedule:^{ + @autoreleasepool { + // At this point, we've been invoked, so our disposable is now useless. + [disposable removeDisposable:weakSelfDisposable]; + } + + if (disposable.disposed) return; + + void (^reallyReschedule)(void) = ^{ + if (disposable.disposed) return; + [self scheduleRecursiveBlock:recursiveBlock addingToDisposable:disposable]; + }; + + // Protects the variables below. + // + // This doesn't actually need to be __block qualified, but Clang + // complains otherwise. :C + __block NSLock *lock = [[NSLock alloc] init]; + lock.name = [NSString stringWithFormat:@"%@ %s", self, sel_getName(_cmd)]; + + __block NSUInteger rescheduleCount = 0; + + // Set to YES once synchronous execution has finished. Further + // rescheduling should occur immediately (rather than being + // flattened). + __block BOOL rescheduleImmediately = NO; + + @autoreleasepool { + recursiveBlock(^{ + [lock lock]; + BOOL immediate = rescheduleImmediately; + if (!immediate) ++rescheduleCount; + [lock unlock]; + + if (immediate) reallyReschedule(); + }); + } + + [lock lock]; + NSUInteger synchronousCount = rescheduleCount; + rescheduleImmediately = YES; + [lock unlock]; + + for (NSUInteger i = 0; i < synchronousCount; i++) { + reallyReschedule(); + } + }]; + + [selfDisposable addDisposable:schedulingDisposable]; + } +} + +@end + +@implementation RACScheduler (Deprecated) + +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wdeprecated-implementations" + ++ (instancetype)schedulerWithQueue:(dispatch_queue_t)queue name:(NSString *)name { + NSCParameterAssert(queue != NULL); + + return [[RACTargetQueueScheduler alloc] initWithName:name targetQueue:queue]; +} + +#pragma clang diagnostic pop + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACScopedDisposable.h b/ReactiveCocoaFramework/ReactiveCocoa/RACScopedDisposable.h new file mode 100644 index 0000000..03da6a2 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACScopedDisposable.h
@@ -0,0 +1,19 @@ +// +// RACScopedDisposable.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 3/28/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACDisposable.h" + + +/// A disposable that calls its own -dispose when it is dealloc'd. +@interface RACScopedDisposable : RACDisposable + +/// Creates a new scoped disposable that will also dispose of the given +/// disposable when it is dealloc'd. ++ (instancetype)scopedDisposableWithDisposable:(RACDisposable *)disposable; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACScopedDisposable.m b/ReactiveCocoaFramework/ReactiveCocoa/RACScopedDisposable.m new file mode 100644 index 0000000..91115be --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACScopedDisposable.m
@@ -0,0 +1,32 @@ +// +// RACScopedDisposable.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 3/28/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACScopedDisposable.h" + +@implementation RACScopedDisposable + +#pragma mark Lifecycle + ++ (instancetype)scopedDisposableWithDisposable:(RACDisposable *)disposable { + return [self disposableWithBlock:^{ + [disposable dispose]; + }]; +} + +- (void)dealloc { + [self dispose]; +} + +#pragma mark RACDisposable + +- (RACScopedDisposable *)asScopedDisposable { + // totally already are + return self; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACSequence.h b/ReactiveCocoaFramework/ReactiveCocoa/RACSequence.h new file mode 100644 index 0000000..a39f840 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACSequence.h
@@ -0,0 +1,154 @@ +// +// RACSequence.h +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-10-29. +// Copyright (c) 2012 GitHub. All rights reserved. +// + +#import <Foundation/Foundation.h> +#import "RACStream.h" + +@class RACScheduler; +@class RACSignal; + +/// Represents an immutable sequence of values. Unless otherwise specified, the +/// sequences' values are evaluated lazily on demand. Like Cocoa collections, +/// sequences cannot contain nil. +/// +/// Most inherited RACStream methods that accept a block will execute the block +/// _at most_ once for each value that is evaluated in the returned sequence. +/// Side effects are subject to the behavior described in +/// +sequenceWithHeadBlock:tailBlock:. +/// +/// Implemented as a class cluster. A minimal implementation for a subclass +/// consists simply of -head and -tail. +@interface RACSequence : RACStream <NSCoding, NSCopying, NSFastEnumeration> + +/// The first object in the sequence, or nil if the sequence is empty. +/// +/// Subclasses must provide an implementation of this method. +@property (nonatomic, strong, readonly) id head; + +/// All but the first object in the sequence, or nil if the sequence is empty. +/// +/// Subclasses must provide an implementation of this method. +@property (nonatomic, strong, readonly) RACSequence *tail; + +/// Evaluates the full sequence to produce an equivalently-sized array. +@property (nonatomic, copy, readonly) NSArray *array; + +/// Returns an enumerator of all objects in the sequence. +@property (nonatomic, copy, readonly) NSEnumerator *objectEnumerator; + +/// Converts a sequence into an eager sequence. +/// +/// An eager sequence fully evaluates all of its values immediately. Sequences +/// derived from an eager sequence will also be eager. +/// +/// Returns a new eager sequence, or the receiver if the sequence is already +/// eager. +@property (nonatomic, copy, readonly) RACSequence *eagerSequence; + +/// Converts a sequence into a lazy sequence. +/// +/// A lazy sequence evaluates its values on demand, as they are accessed. +/// Sequences derived from a lazy sequence will also be lazy. +/// +/// Returns a new lazy sequence, or the receiver if the sequence is already lazy. +@property (nonatomic, copy, readonly) RACSequence *lazySequence; + +/// Invokes -signalWithScheduler: with a new RACScheduler. +- (RACSignal *)signal; + +/// Evaluates the full sequence on the given scheduler. +/// +/// Each item is evaluated in its own scheduled block, such that control of the +/// scheduler is yielded between each value. +/// +/// Returns a signal which sends the receiver's values on the given scheduler as +/// they're evaluated. +- (RACSignal *)signalWithScheduler:(RACScheduler *)scheduler; + +/// Applies a left fold to the sequence. +/// +/// This is the same as iterating the sequence along with a provided start value. +/// This uses a constant amount of memory. A left fold is left-associative so in +/// the sequence [1,2,3] the block would applied in the following order: +/// reduce(reduce(reduce(start, 1), 2), 3) +/// +/// start - The starting value for the fold. Used as `accumulator` for the +/// first fold. +/// reduce - The block used to combine the accumulated value and the next value. +/// Cannot be nil. +/// +/// Returns a reduced value. +- (id)foldLeftWithStart:(id)start reduce:(id (^)(id accumulator, id value))reduce; + +/// Applies a right fold to the sequence. +/// +/// A right fold is equivalent to recursion on the list. The block is evaluated +/// from the right to the left in list. It is right associative so it's applied +/// to the rightmost elements first. For example, in the sequence [1,2,3] the +/// block is applied in the order: +/// reduce(1, reduce(2, reduce(3, start))) +/// +/// start - The starting value for the fold. +/// reduce - The block used to combine the accumulated value and the next head. +/// The block is given the accumulated value and the value of the rest +/// of the computation (result of the recursion). This is computed when +/// you retrieve its value using `rest.head`. This allows you to +/// prevent unnecessary computation by not accessing `rest.head` if you +/// don't need to. +/// +/// Returns a reduced value. +- (id)foldRightWithStart:(id)start reduce:(id (^)(id first, RACSequence *rest))reduce; + +/// Check if any value in sequence passes the block. +/// +/// block - The block predicate used to check each item. Cannot be nil. +/// +/// Returns a boolean indiciating if any value in the sequence passed. +- (BOOL)any:(BOOL (^)(id value))block; + +/// Check if all values in the sequence pass the block. +/// +/// block - The block predicate used to check each item. Cannot be nil. +/// +/// Returns a boolean indicating if all values in the sequence passed. +- (BOOL)all:(BOOL (^)(id value))block; + +/// Returns the first object that passes the block. +/// +/// block - The block predicate used to check each item. Cannot be nil. +/// +/// Returns an object that passes the block or nil if no objects passed. +- (id)objectPassingTest:(BOOL (^)(id value))block; + +/// Creates a sequence that dynamically generates its values. +/// +/// headBlock - Invoked the first time -head is accessed. +/// tailBlock - Invoked the first time -tail is accessed. +/// +/// The results from each block are memoized, so each block will be invoked at +/// most once, no matter how many times the head and tail properties of the +/// sequence are accessed. +/// +/// Any side effects in `headBlock` or `tailBlock` should be thread-safe, since +/// the sequence may be evaluated at any time from any thread. Not only that, but +/// -tail may be accessed before -head, or both may be accessed simultaneously. +/// As noted above, side effects will only be triggered the _first_ time -head or +/// -tail is invoked. +/// +/// Returns a sequence that lazily invokes the given blocks to provide head and +/// tail. `headBlock` must not be nil. ++ (RACSequence *)sequenceWithHeadBlock:(id (^)(void))headBlock tailBlock:(RACSequence *(^)(void))tailBlock; + +@end + +@interface RACSequence (Deprecated) + +- (id)foldLeftWithStart:(id)start combine:(id (^)(id accumulator, id value))combine __attribute__((deprecated("Renamed to -foldLeftWithStart:reduce:"))); +- (id)foldRightWithStart:(id)start combine:(id (^)(id first, RACSequence *rest))combine __attribute__((deprecated("Renamed to -foldRightWithStart:reduce:"))); + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACSequence.m b/ReactiveCocoaFramework/ReactiveCocoa/RACSequence.m new file mode 100644 index 0000000..9567ea8 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACSequence.m
@@ -0,0 +1,384 @@ +// +// RACSequence.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-10-29. +// Copyright (c) 2012 GitHub. All rights reserved. +// + +#import "RACSequence.h" +#import "RACArraySequence.h" +#import "RACDynamicSequence.h" +#import "RACEagerSequence.h" +#import "RACEmptySequence.h" +#import "RACScheduler.h" +#import "RACSignal.h" +#import "RACSubscriber.h" +#import "RACTuple.h" +#import "RACUnarySequence.h" + +// An enumerator over sequences. +@interface RACSequenceEnumerator : NSEnumerator + +// The sequence the enumerator is enumerating. +// +// This will change as the enumerator is exhausted. This property should only be +// accessed while synchronized on self. +@property (nonatomic, strong) RACSequence *sequence; + +@end + +@interface RACSequence () + +// Performs one iteration of lazy binding, passing through values from `current` +// until the sequence is exhausted, then recursively binding the remaining +// values in the receiver. +// +// Returns a new sequence which contains `current`, followed by the combined +// result of all applications of `block` to the remaining values in the receiver. +- (instancetype)bind:(RACStreamBindBlock)block passingThroughValuesFromSequence:(RACSequence *)current; + +@end + +@implementation RACSequenceEnumerator + +- (id)nextObject { + id object = nil; + + @synchronized (self) { + object = self.sequence.head; + self.sequence = self.sequence.tail; + } + + return object; +} + +@end + +@implementation RACSequence + +#pragma mark Lifecycle + ++ (RACSequence *)sequenceWithHeadBlock:(id (^)(void))headBlock tailBlock:(RACSequence *(^)(void))tailBlock { + return [[RACDynamicSequence sequenceWithHeadBlock:headBlock tailBlock:tailBlock] setNameWithFormat:@"+sequenceWithHeadBlock:tailBlock:"]; +} + +#pragma mark Class cluster primitives + +- (id)head { + NSCAssert(NO, @"%s must be overridden by subclasses", __func__); + return nil; +} + +- (RACSequence *)tail { + NSCAssert(NO, @"%s must be overridden by subclasses", __func__); + return nil; +} + +#pragma mark RACStream + ++ (instancetype)empty { + return RACEmptySequence.empty; +} + ++ (instancetype)return:(id)value { + return [RACUnarySequence return:value]; +} + +- (instancetype)bind:(RACStreamBindBlock (^)(void))block { + RACStreamBindBlock bindBlock = block(); + return [[self bind:bindBlock passingThroughValuesFromSequence:nil] setNameWithFormat:@"[%@] -bind:", self.name]; +} + +- (instancetype)bind:(RACStreamBindBlock)bindBlock passingThroughValuesFromSequence:(RACSequence *)passthroughSequence { + // Store values calculated in the dependency here instead, avoiding any kind + // of temporary collection and boxing. + // + // This relies on the implementation of RACDynamicSequence synchronizing + // access to its head, tail, and dependency, and we're only doing it because + // we really need the performance. + __block RACSequence *valuesSeq = self; + __block RACSequence *current = passthroughSequence; + __block BOOL stop = NO; + + RACSequence *sequence = [RACDynamicSequence sequenceWithLazyDependency:^ id { + while (current.head == nil) { + if (stop) return nil; + + // We've exhausted the current sequence, create a sequence from the + // next value. + id value = valuesSeq.head; + + if (value == nil) { + // We've exhausted all the sequences. + stop = YES; + return nil; + } + + current = (id)bindBlock(value, &stop); + if (current == nil) { + stop = YES; + return nil; + } + + valuesSeq = valuesSeq.tail; + } + + NSCAssert([current isKindOfClass:RACSequence.class], @"-bind: block returned an object that is not a sequence: %@", current); + return nil; + } headBlock:^(id _) { + return current.head; + } tailBlock:^ id (id _) { + if (stop) return nil; + + return [valuesSeq bind:bindBlock passingThroughValuesFromSequence:current.tail]; + }]; + + sequence.name = self.name; + return sequence; +} + +- (instancetype)concat:(RACStream *)stream { + NSCParameterAssert(stream != nil); + + return [[[RACArraySequence sequenceWithArray:@[ self, stream ] offset:0] + flatten] + setNameWithFormat:@"[%@] -concat: %@", self.name, stream]; +} + +- (instancetype)zipWith:(RACSequence *)sequence { + NSCParameterAssert(sequence != nil); + + return [[RACSequence + sequenceWithHeadBlock:^ id { + if (self.head == nil || sequence.head == nil) return nil; + return RACTuplePack(self.head, sequence.head); + } tailBlock:^ id { + if (self.tail == nil || [[RACSequence empty] isEqual:self.tail]) return nil; + if (sequence.tail == nil || [[RACSequence empty] isEqual:sequence.tail]) return nil; + + return [self.tail zipWith:sequence.tail]; + }] + setNameWithFormat:@"[%@] -zipWith: %@", self.name, sequence]; +} + +#pragma mark Extended methods + +- (NSArray *)array { + NSMutableArray *array = [NSMutableArray array]; + for (id obj in self) { + [array addObject:obj]; + } + + return [array copy]; +} + +- (NSEnumerator *)objectEnumerator { + RACSequenceEnumerator *enumerator = [[RACSequenceEnumerator alloc] init]; + enumerator.sequence = self; + return enumerator; +} + +- (RACSignal *)signal { + return [[self signalWithScheduler:[RACScheduler scheduler]] setNameWithFormat:@"[%@] -signal", self.name]; +} + +- (RACSignal *)signalWithScheduler:(RACScheduler *)scheduler { + return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) { + __block RACSequence *sequence = self; + + return [scheduler scheduleRecursiveBlock:^(void (^reschedule)(void)) { + if (sequence.head == nil) { + [subscriber sendCompleted]; + return; + } + + [subscriber sendNext:sequence.head]; + + sequence = sequence.tail; + reschedule(); + }]; + }] setNameWithFormat:@"[%@] -signalWithScheduler:", self.name]; +} + +- (id)foldLeftWithStart:(id)start reduce:(id (^)(id, id))reduce { + NSCParameterAssert(reduce != NULL); + + if (self.head == nil) return start; + + for (id value in self) { + start = reduce(start, value); + } + + return start; +} + +- (id)foldRightWithStart:(id)start reduce:(id (^)(id, RACSequence *))reduce { + NSCParameterAssert(reduce != NULL); + + if (self.head == nil) return start; + + RACSequence *rest = [RACSequence sequenceWithHeadBlock:^{ + return [self.tail foldRightWithStart:start reduce:reduce]; + } tailBlock:nil]; + + return reduce(self.head, rest); +} + +- (BOOL)any:(BOOL (^)(id))block { + NSCParameterAssert(block != NULL); + + return [self objectPassingTest:block] != nil; +} + +- (BOOL)all:(BOOL (^)(id))block { + NSCParameterAssert(block != NULL); + + NSNumber *result = [self foldLeftWithStart:@YES reduce:^(NSNumber *accumulator, id value) { + return @(accumulator.boolValue && block(value)); + }]; + + return result.boolValue; +} + +- (id)objectPassingTest:(BOOL (^)(id))block { + NSCParameterAssert(block != NULL); + + return [self filter:block].head; +} + +- (RACSequence *)eagerSequence { + return [RACEagerSequence sequenceWithArray:self.array offset:0]; +} + +- (RACSequence *)lazySequence { + return self; +} + +#pragma mark NSCopying + +- (id)copyWithZone:(NSZone *)zone { + return self; +} + +#pragma mark NSCoding + +- (Class)classForCoder { + // Most sequences should be archived as RACArraySequences. + return RACArraySequence.class; +} + +- (id)initWithCoder:(NSCoder *)coder { + if (![self isKindOfClass:RACArraySequence.class]) return [[RACArraySequence alloc] initWithCoder:coder]; + + // Decoding is handled in RACArraySequence. + return [super init]; +} + +- (void)encodeWithCoder:(NSCoder *)coder { + [coder encodeObject:self.array forKey:@"array"]; +} + +#pragma mark NSFastEnumeration + +- (NSUInteger)countByEnumeratingWithState:(NSFastEnumerationState *)state objects:(__unsafe_unretained id *)stackbuf count:(NSUInteger)len { + if (state->state == ULONG_MAX) { + // Enumeration has completed. + return 0; + } + + // We need to traverse the sequence itself on repeated calls to this + // method, so use the 'state' field to track the current head. + RACSequence *(^getSequence)(void) = ^{ + return (__bridge RACSequence *)(void *)state->state; + }; + + void (^setSequence)(RACSequence *) = ^(RACSequence *sequence) { + // Release the old sequence and retain the new one. + CFBridgingRelease((void *)state->state); + + state->state = (unsigned long)CFBridgingRetain(sequence); + }; + + void (^complete)(void) = ^{ + // Release any stored sequence. + setSequence(nil); + state->state = ULONG_MAX; + }; + + if (state->state == 0) { + // Since a sequence doesn't mutate, this just needs to be set to + // something non-NULL. + state->mutationsPtr = state->extra; + + setSequence(self); + } + + state->itemsPtr = stackbuf; + + NSUInteger enumeratedCount = 0; + while (enumeratedCount < len) { + RACSequence *seq = getSequence(); + + // Because the objects in a sequence may be generated lazily, we want to + // prevent them from being released until the enumerator's used them. + __autoreleasing id obj = seq.head; + if (obj == nil) { + complete(); + break; + } + + stackbuf[enumeratedCount++] = obj; + + if (seq.tail == nil) { + complete(); + break; + } + + setSequence(seq.tail); + } + + return enumeratedCount; +} + +#pragma mark NSObject + +- (NSUInteger)hash { + return [self.head hash]; +} + +- (BOOL)isEqual:(RACSequence *)seq { + if (self == seq) return YES; + if (![seq isKindOfClass:RACSequence.class]) return NO; + + for (id<NSObject> selfObj in self) { + id<NSObject> seqObj = seq.head; + + // Handles the nil case too. + if (![seqObj isEqual:selfObj]) return NO; + + seq = seq.tail; + } + + // self is now depleted -- the argument should be too. + return (seq.head == nil); +} + +@end + +@implementation RACSequence (Deprecated) + +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wdeprecated-implementations" + +- (id)foldLeftWithStart:(id)start combine:(id (^)(id accumulator, id value))combine { + return [self foldLeftWithStart:start reduce:combine]; +} + +- (id)foldRightWithStart:(id)start combine:(id (^)(id first, RACSequence *rest))combine { + return [self foldRightWithStart:start reduce:combine]; +} + +#pragma clang diagnostic pop + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACSerialDisposable.h b/ReactiveCocoaFramework/ReactiveCocoa/RACSerialDisposable.h new file mode 100644 index 0000000..a3fc1d4 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACSerialDisposable.h
@@ -0,0 +1,43 @@ +// +// RACSerialDisposable.h +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-07-22. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACDisposable.h" + +/// A disposable that contains exactly one other disposable and allows it to be +/// swapped out atomically. +@interface RACSerialDisposable : RACDisposable + +/// The inner disposable managed by the serial disposable. +/// +/// This property is thread-safe for reading and writing. However, if you want to +/// read the current value _and_ write a new one atomically, use +/// -swapInDisposable: instead. +/// +/// Disposing of the receiver will also dispose of the current disposable set for +/// this property, then set the property to nil. If any new disposable is set +/// after the receiver is disposed, it will be disposed immediately and this +/// property will remain set to nil. +@property (atomic, strong) RACDisposable *disposable; + +/// Creates a serial disposable which will wrap the given disposable. +/// +/// disposable - The value to set for `disposable`. This may be nil. +/// +/// Returns a RACSerialDisposable, or nil if an error occurs. ++ (instancetype)serialDisposableWithDisposable:(RACDisposable *)disposable; + +/// Atomically swaps the receiver's `disposable` for `newDisposable`. +/// +/// newDisposable - The new value for `disposable`. If the receiver has already +/// been disposed, this disposable will be too, and `disposable` +/// will remain set to nil. This argument may be nil. +/// +/// Returns the previous value for the `disposable` property. +- (RACDisposable *)swapInDisposable:(RACDisposable *)newDisposable; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACSerialDisposable.m b/ReactiveCocoaFramework/ReactiveCocoa/RACSerialDisposable.m new file mode 100644 index 0000000..975afbf --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACSerialDisposable.m
@@ -0,0 +1,133 @@ +// +// RACSerialDisposable.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-07-22. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACSerialDisposable.h" +#import <libkern/OSAtomic.h> + +@interface RACSerialDisposable () { + // A reference to the receiver's `disposable`. This variable must only be + // modified atomically. + // + // If this is `self`, no `disposable` has been set, but the receiver has not + // been disposed of yet. `self` is never stored retained. + // + // If this is `nil`, the receiver has been disposed. + // + // Otherwise, this is a retained reference to the inner disposable and the + // receiver has not been disposed of yet. + void * volatile _disposablePtr; +} + +@end + +@implementation RACSerialDisposable + +#pragma mark Properties + +- (BOOL)isDisposed { + return _disposablePtr == nil; +} + +- (RACDisposable *)disposable { + RACDisposable *disposable = (__bridge id)_disposablePtr; + return (disposable == self ? nil : disposable); +} + +- (void)setDisposable:(RACDisposable *)disposable { + [self swapInDisposable:disposable]; +} + +#pragma mark Lifecycle + ++ (instancetype)serialDisposableWithDisposable:(RACDisposable *)disposable { + RACSerialDisposable *serialDisposable = [[self alloc] init]; + serialDisposable.disposable = disposable; + return serialDisposable; +} + +- (id)init { + self = [super init]; + if (self == nil) return nil; + + _disposablePtr = (__bridge void *)self; + OSMemoryBarrier(); + + return self; +} + +- (id)initWithBlock:(void (^)(void))block { + self = [self init]; + if (self == nil) return nil; + + self.disposable = [RACDisposable disposableWithBlock:block]; + + return self; +} + +- (void)dealloc { + self.disposable = nil; +} + +#pragma mark Inner Disposable + +- (RACDisposable *)swapInDisposable:(RACDisposable *)newDisposable { + void * const selfPtr = (__bridge void *)self; + + // Only retain the new disposable if it's not `self`. + // Take ownership before attempting the swap so that a subsequent swap + // receives an owned reference. + void *newDisposablePtr = selfPtr; + if (newDisposable != nil) { + newDisposablePtr = (void *)CFBridgingRetain(newDisposable); + } + + void *existingDisposablePtr; + // Keep trying while we're not disposed. + while ((existingDisposablePtr = _disposablePtr) != NULL) { + if (!OSAtomicCompareAndSwapPtrBarrier(existingDisposablePtr, newDisposablePtr, &_disposablePtr)) { + continue; + } + + // Return nil if _disposablePtr was set to self. Otherwise, release + // the old value and return it as an object. + if (existingDisposablePtr == selfPtr) { + return nil; + } else { + return CFBridgingRelease(existingDisposablePtr); + } + } + + // At this point, we've found out that we were already disposed. + [newDisposable dispose]; + + // Failed to swap, clean up the ownership we took prior to the swap. + if (newDisposable != nil) { + CFRelease(newDisposablePtr); + } + + return nil; +} + +#pragma mark Disposal + +- (void)dispose { + void *existingDisposablePtr; + + while ((existingDisposablePtr = _disposablePtr) != NULL) { + if (OSAtomicCompareAndSwapPtrBarrier(existingDisposablePtr, NULL, &_disposablePtr)) { + if (existingDisposablePtr != (__bridge void *)self) { + RACDisposable *existingDisposable = CFBridgingRelease(existingDisposablePtr); + [existingDisposable dispose]; + } + + break; + } + } +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACSignal+Operations.h b/ReactiveCocoaFramework/ReactiveCocoa/RACSignal+Operations.h new file mode 100644 index 0000000..53b10d6 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACSignal+Operations.h
@@ -0,0 +1,625 @@ +// +// RACSignal+Operations.h +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-09-06. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import <Foundation/Foundation.h> +#import "RACSignal.h" + +/// The domain for errors originating in RACSignal operations. +extern NSString * const RACSignalErrorDomain; + +/// The error code used with -timeout:. +extern const NSInteger RACSignalErrorTimedOut; + +/// The error code used when a value passed into +switch:cases:default: does not +/// match any of the cases, and no default was given. +extern const NSInteger RACSignalErrorNoMatchingCase; + +@class RACMulticastConnection; +@class RACDisposable; +@class RACScheduler; +@class RACSequence; +@class RACSubject; +@class RACTuple; +@class RACCommand; +@protocol RACSubscriber; + +@interface RACSignal (Operations) + +/// Do the given block on `next`. This should be used to inject side effects into +/// the signal. +- (RACSignal *)doNext:(void (^)(id x))block; + +/// Do the given block on `error`. This should be used to inject side effects +/// into the signal. +- (RACSignal *)doError:(void (^)(NSError *error))block; + +/// Do the given block on `completed`. This should be used to inject side effects +/// into the signal. +- (RACSignal *)doCompleted:(void (^)(void))block; + +/// Send `next`s only if we don't receive another `next` in `interval` seconds. +/// +/// If a `next` is received, and then another `next` is received before +/// `interval` seconds have passed, the first value is discarded. +/// +/// After `interval` seconds have passed since the most recent `next` was sent, +/// the most recent `next` is forwarded on the scheduler that the value was +/// originally received on. If +[RACScheduler currentScheduler] was nil at the +/// time, a private background scheduler is used. +/// +/// Returns a signal which sends throttled and delayed `next` events. Completion +/// and errors are always forwarded immediately. +- (RACSignal *)throttle:(NSTimeInterval)interval; + +/// Throttles `next`s for which `predicate` returns YES. +/// +/// When `predicate` returns YES for a `next`: +/// +/// 1. If another `next` is received before `interval` seconds have passed, the +/// prior value is discarded. This happens regardless of whether the new +/// value will be throttled. +/// 2. After `interval` seconds have passed since the value was originally +/// received, it will be forwarded on the scheduler that it was received +/// upon. If +[RACScheduler currentScheduler] was nil at the time, a private +/// background scheduler is used. +/// +/// When `predicate` returns NO for a `next`, it is forwarded immediately, +/// without any throttling. +/// +/// interval - The number of seconds for which to buffer the latest value that +/// passes `predicate`. +/// predicate - Passed each `next` from the receiver, this block returns +/// whether the given value should be throttled. This argument must +/// not be nil. +/// +/// Returns a signal which sends `next` events, throttled when `predicate` +/// returns YES. Completion and errors are always forwarded immediately. +- (RACSignal *)throttle:(NSTimeInterval)interval valuesPassingTest:(BOOL (^)(id next))predicate; + +/// Forwards `next` and `completed` events after delaying for `interval` seconds +/// on the current scheduler (on which the events were delivered). +/// +/// If +[RACScheduler currentScheduler] is nil when `next` or `completed` is +/// received, a private background scheduler is used. +/// +/// Returns a signal which sends delayed `next` and `completed` events. Errors +/// are always forwarded immediately. +- (RACSignal *)delay:(NSTimeInterval)interval; + +/// Resubscribes when the signal completes. +- (RACSignal *)repeat; + +/// Execute the given block each time a subscription is created. +/// +/// block - A block which defines the subscription side effects. Cannot be `nil`. +/// +/// Example: +/// +/// // Write new file, with backup. +/// [[[[fileManager +/// rac_createFileAtPath:path contents:data] +/// initially:^{ +/// // 2. Second, backup current file +/// [fileManager moveItemAtPath:path toPath:backupPath error:nil]; +/// }] +/// initially:^{ +/// // 1. First, acquire write lock. +/// [writeLock lock]; +/// }] +/// finally:^{ +/// [writeLock unlock]; +/// }]; +/// +/// Returns a signal that passes through all events of the receiver, plus +/// introduces side effects which occur prior to any subscription side effects +/// of the receiver. +- (RACSignal *)initially:(void (^)(void))block; + +/// Execute the given block when the signal completes or errors. +- (RACSignal *)finally:(void (^)(void))block; + +/// Divides the receiver's `next`s into buffers which deliver every `interval` +/// seconds. +/// +/// interval - The interval in which values are grouped into one buffer. +/// scheduler - The scheduler upon which the returned signal will deliver its +/// values. This must not be nil or +[RACScheduler +/// immediateScheduler]. +/// +/// Returns a signal which sends RACTuples of the buffered values at each +/// interval on `scheduler`. When the receiver completes, any currently-buffered +/// values will be sent immediately. +- (RACSignal *)bufferWithTime:(NSTimeInterval)interval onScheduler:(RACScheduler *)scheduler; + +/// Collect all receiver's `next`s into a NSArray. nil values will be converted +/// to NSNull. +/// +/// This corresponds to the `ToArray` method in Rx. +/// +/// Returns a signal which sends a single NSArray when the receiver completes +/// successfully. +- (RACSignal *)collect; + +/// Takes the last `count` `next`s after the receiving signal completes. +- (RACSignal *)takeLast:(NSUInteger)count; + +/// Combines the latest values from the receiver and the given signal into +/// RACTuples, once both have sent at least one `next`. +/// +/// Any additional `next`s will result in a new RACTuple with the latest values +/// from both signals. +/// +/// signal - The signal to combine with. This argument must not be nil. +/// +/// Returns a signal which sends RACTuples of the combined values, forwards any +/// `error` events, and completes when both input signals complete. +- (RACSignal *)combineLatestWith:(RACSignal *)signal; + +/// Combines the latest values from the given signals into RACTuples, once all +/// the signals have sent at least one `next`. +/// +/// Any additional `next`s will result in a new RACTuple with the latest values +/// from all signals. +/// +/// signals - The signals to combine. If this collection is empty, the returned +/// signal will immediately complete upon subscription. +/// +/// Returns a signal which sends RACTuples of the combined values, forwards any +/// `error` events, and completes when all input signals complete. ++ (RACSignal *)combineLatest:(id<NSFastEnumeration>)signals; + +/// Combines signals using +combineLatest:, then reduces the resulting tuples +/// into a single value using -reduceEach:. +/// +/// signals - The signals to combine. If this collection is empty, the +/// returned signal will immediately complete upon subscription. +/// reduceBlock - The block which reduces the latest values from all the +/// signals into one value. It must take as many arguments as the +/// number of signals given. Each argument will be an object +/// argument. The return value must be an object. This argument +/// must not be nil. +/// +/// Example: +/// +/// [RACSignal combineLatest:@[ stringSignal, intSignal ] reduce:^(NSString *string, NSNumber *number) { +/// return [NSString stringWithFormat:@"%@: %@", string, number]; +/// }]; +/// +/// Returns a signal which sends the results from each invocation of +/// `reduceBlock`. ++ (RACSignal *)combineLatest:(id<NSFastEnumeration>)signals reduce:(id (^)())reduceBlock; + +/// Merges the receiver and the given signal with `+merge:` and returns the +/// resulting signal. +- (RACSignal *)merge:(RACSignal *)signal; + +/// Sends the latest `next` from any of the signals. +/// +/// Returns a signal that passes through values from each of the given signals, +/// and sends `completed` when all of them complete. If any signal sends an error, +/// the returned signal sends `error` immediately. ++ (RACSignal *)merge:(id<NSFastEnumeration>)signals; + +/// Merges the signals sent by the receiver into a flattened signal, but only +/// subscribes to `maxConcurrent` number of signals at a time. New signals are +/// queued and subscribed to as other signals complete. +/// +/// If an error occurs on any of the signals, it is sent on the returned signal. +/// It completes only after the receiver and all sent signals have completed. +/// +/// This corresponds to `Merge<TSource>(IObservable<IObservable<TSource>>, Int32)` +/// in Rx. +/// +/// maxConcurrent - the maximum number of signals to subscribe to at a +/// time. If 0, it subscribes to an unlimited number of +/// signals. +- (RACSignal *)flatten:(NSUInteger)maxConcurrent; + +/// Ignores all `next`s from the receiver, waits for the receiver to complete, +/// then subscribes to a new signal. +/// +/// block - A block which will create or obtain a new signal to subscribe to, +/// executed only after the receiver completes. This block must not be +/// nil, and it must not return a nil signal. +/// +/// Returns a signal which will pass through the events of the signal created in +/// `block`. If the receiver errors out, the returned signal will error as well. +- (RACSignal *)then:(RACSignal * (^)(void))block; + +/// Concats the inner signals of a signal of signals. +- (RACSignal *)concat; + +/// Aggregate `next`s with the given start and combination. +- (RACSignal *)aggregateWithStart:(id)start reduce:(id (^)(id running, id next))reduceBlock; + +/// Aggregate `next`s with the given start and combination. The start factory +/// block is called to get a new start object for each subscription. +- (RACSignal *)aggregateWithStartFactory:(id (^)(void))startFactory reduce:(id (^)(id running, id next))reduceBlock; + +/// Invokes -setKeyPath:onObject:nilValue: with `nil` for the nil value. +/// +/// WARNING: Under certain conditions, this method is known to be thread-unsafe. +/// See the description in -setKeyPath:onObject:nilValue:. +- (RACDisposable *)setKeyPath:(NSString *)keyPath onObject:(NSObject *)object; + +/// Binds the receiver to an object, automatically setting the given key path on +/// every `next`. When the signal completes, the binding is automatically +/// disposed of. +/// +/// WARNING: Under certain conditions, this method is known to be thread-unsafe. +/// A crash can result if `object` is deallocated concurrently on +/// another thread within a window of time between a value being sent +/// on this signal and immediately prior to the invocation of +/// -setValue:forKeyPath:, which sets the property. To prevent this, +/// ensure `object` is deallocated on the same thread the receiver +/// sends on, or ensure that the returned disposable is disposed of +/// before `object` deallocates. +/// See https://github.com/ReactiveCocoa/ReactiveCocoa/pull/1184 +/// +/// Sending an error on the signal is considered undefined behavior, and will +/// generate an assertion failure in Debug builds. +/// +/// A given key on an object should only have one active signal bound to it at any +/// given time. Binding more than one signal to the same property is considered +/// undefined behavior. +/// +/// keyPath - The key path to update with `next`s from the receiver. +/// object - The object that `keyPath` is relative to. +/// nilValue - The value to set at the key path whenever `nil` is sent by the +/// receiver. This may be nil when binding to object properties, but +/// an NSValue should be used for primitive properties, to avoid an +/// exception if `nil` is sent (which might occur if an intermediate +/// object is set to `nil`). +/// +/// Returns a disposable which can be used to terminate the binding. +- (RACDisposable *)setKeyPath:(NSString *)keyPath onObject:(NSObject *)object nilValue:(id)nilValue; + +/// Sends NSDate.date every `interval` seconds. +/// +/// interval - The time interval in seconds at which the current time is sent. +/// scheduler - The scheduler upon which the current NSDate should be sent. This +/// must not be nil or +[RACScheduler immediateScheduler]. +/// +/// Returns a signal that sends the current date/time every `interval` on +/// `scheduler`. ++ (RACSignal *)interval:(NSTimeInterval)interval onScheduler:(RACScheduler *)scheduler; + +/// Sends NSDate.date at intervals of at least `interval` seconds, up to +/// approximately `interval` + `leeway` seconds. +/// +/// The created signal will defer sending each `next` for at least `interval` +/// seconds, and for an additional amount of time up to `leeway` seconds in the +/// interest of performance or power consumption. Note that some additional +/// latency is to be expected, even when specifying a `leeway` of 0. +/// +/// interval - The base interval between `next`s. +/// scheduler - The scheduler upon which the current NSDate should be sent. This +/// must not be nil or +[RACScheduler immediateScheduler]. +/// leeway - The maximum amount of additional time the `next` can be deferred. +/// +/// Returns a signal that sends the current date/time at intervals of at least +/// `interval seconds` up to approximately `interval` + `leeway` seconds on +/// `scheduler`. ++ (RACSignal *)interval:(NSTimeInterval)interval onScheduler:(RACScheduler *)scheduler withLeeway:(NSTimeInterval)leeway; + +/// Take `next`s until the `signalTrigger` sends `next` or `completed`. +/// +/// Returns a signal which passes through all events from the receiver until +/// `signalTrigger` sends `next` or `completed`, at which point the returned signal +/// will send `completed`. +- (RACSignal *)takeUntil:(RACSignal *)signalTrigger; + +/// Take `next`s until the `replacement` sends an event. +/// +/// replacement - The signal which replaces the receiver as soon as it sends an +/// event. +/// +/// Returns a signal which passes through `next`s and `error` from the receiver +/// until `replacement` sends an event, at which point the returned signal will +/// send that event and switch to passing through events from `replacement` +/// instead, regardless of whether the receiver has sent events already. +- (RACSignal *)takeUntilReplacement:(RACSignal *)replacement; + +/// Subscribe to the returned signal when an error occurs. +- (RACSignal *)catch:(RACSignal * (^)(NSError *error))catchBlock; + +/// Subscribe to the given signal when an error occurs. +- (RACSignal *)catchTo:(RACSignal *)signal; + +/// Runs `tryBlock` against each of the receiver's values, passing values +/// until `tryBlock` returns NO, or the receiver completes. +/// +/// tryBlock - An action to run against each of the receiver's values. +/// The block should return YES to indicate that the action was +/// successful. This block must not be nil. +/// +/// Example: +/// +/// // The returned signal will send an error if data values cannot be +/// // written to `someFileURL`. +/// [signal try:^(NSData *data, NSError **errorPtr) { +/// return [data writeToURL:someFileURL options:NSDataWritingAtomic error:errorPtr]; +/// }]; +/// +/// Returns a signal which passes through all the values of the receiver. If +/// `tryBlock` fails for any value, the returned signal will error using the +/// `NSError` passed out from the block. +- (RACSignal *)try:(BOOL (^)(id value, NSError **errorPtr))tryBlock; + +/// Runs `mapBlock` against each of the receiver's values, mapping values until +/// `mapBlock` returns nil, or the receiver completes. +/// +/// mapBlock - An action to map each of the receiver's values. The block should +/// return a non-nil value to indicate that the action was successful. +/// This block must not be nil. +/// +/// Example: +/// +/// // The returned signal will send an error if data cannot be read from +/// // `fileURL`. +/// [signal tryMap:^(NSURL *fileURL, NSError **errorPtr) { +/// return [NSData dataWithContentsOfURL:fileURL options:0 error:errorPtr]; +/// }]; +/// +/// Returns a signal which transforms all the values of the receiver. If +/// `mapBlock` returns nil for any value, the returned signal will error using +/// the `NSError` passed out from the block. +- (RACSignal *)tryMap:(id (^)(id value, NSError **errorPtr))mapBlock; + +/// Returns the first `next`. Note that this is a blocking call. +- (id)first; + +/// Returns the first `next` or `defaultValue` if the signal completes or errors +/// without sending a `next`. Note that this is a blocking call. +- (id)firstOrDefault:(id)defaultValue; + +/// Returns the first `next` or `defaultValue` if the signal completes or errors +/// without sending a `next`. If an error occurs success will be NO and error +/// will be populated. Note that this is a blocking call. +/// +/// Both success and error may be NULL. +- (id)firstOrDefault:(id)defaultValue success:(BOOL *)success error:(NSError **)error; + +/// Blocks the caller and waits for the signal to complete. +/// +/// error - If not NULL, set to any error that occurs. +/// +/// Returns whether the signal completed successfully. If NO, `error` will be set +/// to the error that occurred. +- (BOOL)waitUntilCompleted:(NSError **)error; + +/// Defer creation of a signal until the signal's actually subscribed to. +/// +/// This can be used to effectively turn a hot signal into a cold signal. ++ (RACSignal *)defer:(RACSignal * (^)(void))block; + +/// Every time the receiver sends a new RACSignal, subscribes and sends `next`s and +/// `error`s only for that signal. +/// +/// The receiver must be a signal of signals. +/// +/// Returns a signal which passes through `next`s and `error`s from the latest +/// signal sent by the receiver, and sends `completed` when both the receiver and +/// the last sent signal complete. +- (RACSignal *)switchToLatest; + +/// Switches between the signals in `cases` as well as `defaultSignal` based on +/// the latest value sent by `signal`. +/// +/// signal - A signal of objects used as keys in the `cases` dictionary. +/// This argument must not be nil. +/// cases - A dictionary that has signals as values. This argument must +/// not be nil. A RACTupleNil key in this dictionary will match +/// nil `next` events that are received on `signal`. +/// defaultSignal - The signal to pass through after `signal` sends a value for +/// which `cases` does not contain a signal. If nil, any +/// unmatched values will result in +/// a RACSignalErrorNoMatchingCase error. +/// +/// Returns a signal which passes through `next`s and `error`s from one of the +/// the signals in `cases` or `defaultSignal`, and sends `completed` when both +/// `signal` and the last used signal complete. If no `defaultSignal` is given, +/// an unmatched `next` will result in an error on the returned signal. ++ (RACSignal *)switch:(RACSignal *)signal cases:(NSDictionary *)cases default:(RACSignal *)defaultSignal; + +/// Switches between `trueSignal` and `falseSignal` based on the latest value +/// sent by `boolSignal`. +/// +/// boolSignal - A signal of BOOLs determining whether `trueSignal` or +/// `falseSignal` should be active. This argument must not be nil. +/// trueSignal - The signal to pass through after `boolSignal` has sent YES. +/// This argument must not be nil. +/// falseSignal - The signal to pass through after `boolSignal` has sent NO. This +/// argument must not be nil. +/// +/// Returns a signal which passes through `next`s and `error`s from `trueSignal` +/// and/or `falseSignal`, and sends `completed` when both `boolSignal` and the +/// last switched signal complete. ++ (RACSignal *)if:(RACSignal *)boolSignal then:(RACSignal *)trueSignal else:(RACSignal *)falseSignal; + +/// Add every `next` to an array. Nils are represented by NSNulls. Note that this +/// is a blocking call. +/// +/// **This is not the same as the `ToArray` method in Rx.** See -collect for +/// that behavior instead. +/// +/// Returns the array of `next` values, or nil if an error occurs. +- (NSArray *)toArray; + +/// Add every `next` to a sequence. Nils are represented by NSNulls. +/// +/// This corresponds to the `ToEnumerable` method in Rx. +/// +/// Returns a sequence which provides values from the signal as they're sent. +/// Trying to retrieve a value from the sequence which has not yet been sent will +/// block. +@property (nonatomic, strong, readonly) RACSequence *sequence; + +/// Creates and returns a multicast connection. This allows you to share a single +/// subscription to the underlying signal. +- (RACMulticastConnection *)publish; + +/// Creates and returns a multicast connection that pushes values into the given +/// subject. This allows you to share a single subscription to the underlying +/// signal. +- (RACMulticastConnection *)multicast:(RACSubject *)subject; + +/// Multicasts the signal to a RACReplaySubject of unlimited capacity, and +/// immediately connects to the resulting RACMulticastConnection. +/// +/// Returns the connected, multicasted signal. +- (RACSignal *)replay; + +/// Multicasts the signal to a RACReplaySubject of capacity 1, and immediately +/// connects to the resulting RACMulticastConnection. +/// +/// Returns the connected, multicasted signal. +- (RACSignal *)replayLast; + +/// Multicasts the signal to a RACReplaySubject of unlimited capacity, and +/// lazily connects to the resulting RACMulticastConnection. +/// +/// This means the returned signal will subscribe to the multicasted signal only +/// when the former receives its first subscription. +/// +/// Returns the lazily connected, multicasted signal. +- (RACSignal *)replayLazily; + +/// Sends an error after `interval` seconds if the source doesn't complete +/// before then. +/// +/// The error will be in the RACSignalErrorDomain and have a code of +/// RACSignalErrorTimedOut. +/// +/// interval - The number of seconds after which the signal should error out. +/// scheduler - The scheduler upon which any timeout error should be sent. This +/// must not be nil or +[RACScheduler immediateScheduler]. +/// +/// Returns a signal that passes through the receiver's events, until the stream +/// finishes or times out, at which point an error will be sent on `scheduler`. +- (RACSignal *)timeout:(NSTimeInterval)interval onScheduler:(RACScheduler *)scheduler; + +/// Creates and returns a signal that delivers its events on the given scheduler. +/// Any side effects of the receiver will still be performed on the original +/// thread. +/// +/// This is ideal when the signal already performs its work on the desired +/// thread, but you want to handle its events elsewhere. +/// +/// This corresponds to the `ObserveOn` method in Rx. +- (RACSignal *)deliverOn:(RACScheduler *)scheduler; + +/// Creates and returns a signal that executes its side effects and delivers its +/// events on the given scheduler. +/// +/// Use of this operator should be avoided whenever possible, because the +/// receiver's side effects may not be safe to run on another thread. If you just +/// want to receive the signal's events on `scheduler`, use -deliverOn: instead. +- (RACSignal *)subscribeOn:(RACScheduler *)scheduler; + +/// Groups each received object into a group, as determined by calling `keyBlock` +/// with that object. The object sent is transformed by calling `transformBlock` +/// with the object. If `transformBlock` is nil, it sends the original object. +/// +/// The returned signal is a signal of RACGroupedSignal. +- (RACSignal *)groupBy:(id<NSCopying> (^)(id object))keyBlock transform:(id (^)(id object))transformBlock; + +/// Calls -[RACSignal groupBy:keyBlock transform:nil]. +- (RACSignal *)groupBy:(id<NSCopying> (^)(id object))keyBlock; + +/// Sends an [NSNumber numberWithBool:YES] if the receiving signal sends any +/// objects. +- (RACSignal *)any; + +/// Sends an [NSNumber numberWithBool:YES] if the receiving signal sends any +/// objects that pass `predicateBlock`. +/// +/// predicateBlock - cannot be nil. +- (RACSignal *)any:(BOOL (^)(id object))predicateBlock; + +/// Sends an [NSNumber numberWithBool:YES] if all the objects the receiving +/// signal sends pass `predicateBlock`. +/// +/// predicateBlock - cannot be nil. +- (RACSignal *)all:(BOOL (^)(id object))predicateBlock; + +/// Resubscribes to the receiving signal if an error occurs, up until it has +/// retried the given number of times. +/// +/// retryCount - if 0, it keeps retrying until it completes. +- (RACSignal *)retry:(NSInteger)retryCount; + +/// Resubscribes to the receiving signal if an error occurs. +- (RACSignal *)retry; + +/// Sends the latest value from the receiver only when `sampler` sends a value. +/// The returned signal could repeat values if `sampler` fires more often than +/// the receiver. Values from `sampler` are ignored before the receiver sends +/// its first value. +/// +/// sampler - The signal that controls when the latest value from the receiver +/// is sent. Cannot be nil. +- (RACSignal *)sample:(RACSignal *)sampler; + +/// Ignores all `next`s from the receiver. +/// +/// Returns a signal which only passes through `error` or `completed` events from +/// the receiver. +- (RACSignal *)ignoreValues; + +/// Converts each of the receiver's events into a RACEvent object. +/// +/// Returns a signal which sends the receiver's events as RACEvents, and +/// completes after the receiver sends `completed` or `error`. +- (RACSignal *)materialize; + +/// Converts each RACEvent in the receiver back into "real" RACSignal events. +/// +/// Returns a signal which sends `next` for each value RACEvent, `error` for each +/// error RACEvent, and `completed` for each completed RACEvent. +- (RACSignal *)dematerialize; + +/// Inverts each NSNumber-wrapped BOOL sent by the receiver. It will assert if +/// the receiver sends anything other than NSNumbers. +/// +/// Returns a signal of inverted NSNumber-wrapped BOOLs. +- (RACSignal *)not; + +/// Performs a boolean AND on all of the RACTuple of NSNumbers in sent by the receiver. +/// +/// Asserts if the receiver sends anything other than a RACTuple of one or more NSNumbers. +/// +/// Returns a signal that applies AND to each NSNumber in the tuple. +- (RACSignal *)and; + +/// Performs a boolean OR on all of the RACTuple of NSNumbers in sent by the receiver. +/// +/// Asserts if the receiver sends anything other than a RACTuple of one or more NSNumbers. +/// +/// Returns a signal that applies OR to each NSNumber in the tuple. +- (RACSignal *)or; + +@end + +@interface RACSignal (OperationsDeprecated) + +- (RACSignal *)windowWithStart:(RACSignal *)openSignal close:(RACSignal * (^)(RACSignal *start))closeBlock __attribute__((deprecated("See https://github.com/ReactiveCocoa/ReactiveCocoa/issues/587"))); +- (RACSignal *)buffer:(NSUInteger)bufferCount __attribute__((deprecated("See https://github.com/ReactiveCocoa/ReactiveCocoa/issues/587"))); +- (RACSignal *)let:(RACSignal * (^)(RACSignal *sharedSignal))letBlock __attribute__((deprecated("Use -publish instead"))); ++ (RACSignal *)interval:(NSTimeInterval)interval __attribute__((deprecated("Use +interval:onScheduler: instead"))); ++ (RACSignal *)interval:(NSTimeInterval)interval withLeeway:(NSTimeInterval)leeway __attribute__((deprecated("Use +interval:onScheduler:withLeeway: instead"))); +- (RACSignal *)bufferWithTime:(NSTimeInterval)interval __attribute__((deprecated("Use -bufferWithTime:onScheduler: instead"))); +- (RACSignal *)timeout:(NSTimeInterval)interval __attribute__((deprecated("Use -timeout:onScheduler: instead"))); +- (RACDisposable *)toProperty:(NSString *)keyPath onObject:(NSObject *)object __attribute__((deprecated("Renamed to -setKeyPath:onObject:"))); +- (RACSignal *)ignoreElements __attribute__((deprecated("Renamed to -ignoreValues"))); +- (RACSignal *)sequenceNext:(RACSignal * (^)(void))block __attribute__((deprecated("Renamed to -then:"))); +- (RACSignal *)aggregateWithStart:(id)start combine:(id (^)(id running, id next))combineBlock __attribute__((deprecated("Renamed to -aggregateWithStart:reduce:"))); +- (RACSignal *)aggregateWithStartFactory:(id (^)(void))startFactory combine:(id (^)(id running, id next))combineBlock __attribute__((deprecated("Renamed to -aggregateWithStartFactory:reduce:"))); +- (RACDisposable *)executeCommand:(RACCommand *)command __attribute__((deprecated("Use -flattenMap: or -subscribeNext: instead"))); + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACSignal+Operations.m b/ReactiveCocoaFramework/ReactiveCocoa/RACSignal+Operations.m new file mode 100644 index 0000000..6e36dd6 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACSignal+Operations.m
@@ -0,0 +1,1436 @@ +// +// RACSignal+Operations.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-09-06. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACSignal+Operations.h" +#import "NSObject+RACDeallocating.h" +#import "NSObject+RACDescription.h" +#import "RACCommand.h" +#import "RACCompoundDisposable.h" +#import "RACDisposable.h" +#import "RACEvent.h" +#import "RACGroupedSignal.h" +#import "RACMulticastConnection+Private.h" +#import "RACReplaySubject.h" +#import "RACScheduler+Private.h" +#import "RACScheduler.h" +#import "RACSerialDisposable.h" +#import "RACSignalSequence.h" +#import "RACStream+Private.h" +#import "RACSubject.h" +#import "RACSubscriber+Private.h" +#import "RACSubscriber.h" +#import "RACTuple.h" +#import "RACUnit.h" +#import <libkern/OSAtomic.h> +#import <objc/runtime.h> + +NSString * const RACSignalErrorDomain = @"RACSignalErrorDomain"; + +const NSInteger RACSignalErrorTimedOut = 1; +const NSInteger RACSignalErrorNoMatchingCase = 2; + +// Subscribes to the given signal with the given blocks. +// +// If the signal errors or completes, the corresponding block is invoked. If the +// disposable passed to the block is _not_ disposed, then the signal is +// subscribed to again. +static RACDisposable *subscribeForever (RACSignal *signal, void (^next)(id), void (^error)(NSError *, RACDisposable *), void (^completed)(RACDisposable *)) { + next = [next copy]; + error = [error copy]; + completed = [completed copy]; + + RACCompoundDisposable *compoundDisposable = [RACCompoundDisposable compoundDisposable]; + + RACSchedulerRecursiveBlock recursiveBlock = ^(void (^recurse)(void)) { + RACCompoundDisposable *selfDisposable = [RACCompoundDisposable compoundDisposable]; + [compoundDisposable addDisposable:selfDisposable]; + + __weak RACDisposable *weakSelfDisposable = selfDisposable; + + RACDisposable *subscriptionDisposable = [signal subscribeNext:next error:^(NSError *e) { + @autoreleasepool { + error(e, compoundDisposable); + [compoundDisposable removeDisposable:weakSelfDisposable]; + } + + recurse(); + } completed:^{ + @autoreleasepool { + completed(compoundDisposable); + [compoundDisposable removeDisposable:weakSelfDisposable]; + } + + recurse(); + }]; + + [selfDisposable addDisposable:subscriptionDisposable]; + }; + + // Subscribe once immediately, and then use recursive scheduling for any + // further resubscriptions. + recursiveBlock(^{ + RACScheduler *recursiveScheduler = RACScheduler.currentScheduler ?: [RACScheduler scheduler]; + + RACDisposable *schedulingDisposable = [recursiveScheduler scheduleRecursiveBlock:recursiveBlock]; + [compoundDisposable addDisposable:schedulingDisposable]; + }); + + return compoundDisposable; +} + +@implementation RACSignal (Operations) + +- (RACSignal *)doNext:(void (^)(id x))block { + NSCParameterAssert(block != NULL); + + return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) { + return [self subscribeNext:^(id x) { + block(x); + [subscriber sendNext:x]; + } error:^(NSError *error) { + [subscriber sendError:error]; + } completed:^{ + [subscriber sendCompleted]; + }]; + }] setNameWithFormat:@"[%@] -doNext:", self.name]; +} + +- (RACSignal *)doError:(void (^)(NSError *error))block { + NSCParameterAssert(block != NULL); + + return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) { + return [self subscribeNext:^(id x) { + [subscriber sendNext:x]; + } error:^(NSError *error) { + block(error); + [subscriber sendError:error]; + } completed:^{ + [subscriber sendCompleted]; + }]; + }] setNameWithFormat:@"[%@] -doError:", self.name]; +} + +- (RACSignal *)doCompleted:(void (^)(void))block { + NSCParameterAssert(block != NULL); + + return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) { + return [self subscribeNext:^(id x) { + [subscriber sendNext:x]; + } error:^(NSError *error) { + [subscriber sendError:error]; + } completed:^{ + block(); + [subscriber sendCompleted]; + }]; + }] setNameWithFormat:@"[%@] -doCompleted:", self.name]; +} + +- (RACSignal *)throttle:(NSTimeInterval)interval { + return [[self throttle:interval valuesPassingTest:^(id _) { + return YES; + }] setNameWithFormat:@"[%@] -throttle: %f", self.name, (double)interval]; +} + +- (RACSignal *)throttle:(NSTimeInterval)interval valuesPassingTest:(BOOL (^)(id next))predicate { + NSCParameterAssert(interval >= 0); + NSCParameterAssert(predicate != nil); + + return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) { + RACCompoundDisposable *compoundDisposable = [RACCompoundDisposable compoundDisposable]; + + // We may never use this scheduler, but we need to set it up ahead of + // time so that our scheduled blocks are run serially if we do. + RACScheduler *scheduler = [RACScheduler scheduler]; + + // Information about any currently-buffered `next` event. + __block id nextValue = nil; + __block BOOL hasNextValue = NO; + RACSerialDisposable *nextDisposable = [[RACSerialDisposable alloc] init]; + + void (^flushNext)(BOOL send) = ^(BOOL send) { + @synchronized (compoundDisposable) { + [nextDisposable.disposable dispose]; + + if (!hasNextValue) return; + if (send) [subscriber sendNext:nextValue]; + + nextValue = nil; + hasNextValue = NO; + } + }; + + RACDisposable *subscriptionDisposable = [self subscribeNext:^(id x) { + RACScheduler *delayScheduler = RACScheduler.currentScheduler ?: scheduler; + BOOL shouldThrottle = predicate(x); + + @synchronized (compoundDisposable) { + flushNext(NO); + if (!shouldThrottle) { + [subscriber sendNext:x]; + return; + } + + nextValue = x; + hasNextValue = YES; + nextDisposable.disposable = [delayScheduler afterDelay:interval schedule:^{ + flushNext(YES); + }]; + } + } error:^(NSError *error) { + [compoundDisposable dispose]; + [subscriber sendError:error]; + } completed:^{ + flushNext(YES); + [subscriber sendCompleted]; + }]; + + [compoundDisposable addDisposable:subscriptionDisposable]; + return compoundDisposable; + }] setNameWithFormat:@"[%@] -throttle: %f valuesPassingTest:", self.name, (double)interval]; +} + +- (RACSignal *)delay:(NSTimeInterval)interval { + return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) { + RACCompoundDisposable *disposable = [RACCompoundDisposable compoundDisposable]; + + // We may never use this scheduler, but we need to set it up ahead of + // time so that our scheduled blocks are run serially if we do. + RACScheduler *scheduler = [RACScheduler scheduler]; + + void (^schedule)(dispatch_block_t) = ^(dispatch_block_t block) { + RACScheduler *delayScheduler = RACScheduler.currentScheduler ?: scheduler; + RACDisposable *schedulerDisposable = [delayScheduler afterDelay:interval schedule:block]; + [disposable addDisposable:schedulerDisposable]; + }; + + RACDisposable *subscriptionDisposable = [self subscribeNext:^(id x) { + schedule(^{ + [subscriber sendNext:x]; + }); + } error:^(NSError *error) { + [subscriber sendError:error]; + } completed:^{ + schedule(^{ + [subscriber sendCompleted]; + }); + }]; + + [disposable addDisposable:subscriptionDisposable]; + return disposable; + }] setNameWithFormat:@"[%@] -delay: %f", self.name, (double)interval]; +} + +- (RACSignal *)repeat { + return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) { + return subscribeForever(self, + ^(id x) { + [subscriber sendNext:x]; + }, + ^(NSError *error, RACDisposable *disposable) { + [disposable dispose]; + [subscriber sendError:error]; + }, + ^(RACDisposable *disposable) { + // Resubscribe. + }); + }] setNameWithFormat:@"[%@] -repeat", self.name]; +} + +- (RACSignal *)catch:(RACSignal * (^)(NSError *error))catchBlock { + NSCParameterAssert(catchBlock != NULL); + + return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) { + RACSerialDisposable *catchDisposable = [[RACSerialDisposable alloc] init]; + + RACDisposable *subscriptionDisposable = [self subscribeNext:^(id x) { + [subscriber sendNext:x]; + } error:^(NSError *error) { + RACSignal *signal = catchBlock(error); + NSCAssert(signal != nil, @"Expected non-nil signal from catch block on %@", self); + catchDisposable.disposable = [signal subscribe:subscriber]; + } completed:^{ + [subscriber sendCompleted]; + }]; + + return [RACDisposable disposableWithBlock:^{ + [catchDisposable dispose]; + [subscriptionDisposable dispose]; + }]; + }] setNameWithFormat:@"[%@] -catch:", self.name]; +} + +- (RACSignal *)catchTo:(RACSignal *)signal { + return [[self catch:^(NSError *error) { + return signal; + }] setNameWithFormat:@"[%@] -catchTo: %@", self.name, signal]; +} + +- (RACSignal *)try:(BOOL (^)(id value, NSError **errorPtr))tryBlock { + NSCParameterAssert(tryBlock != NULL); + + return [[self flattenMap:^(id value) { + NSError *error = nil; + BOOL passed = tryBlock(value, &error); + return (passed ? [RACSignal return:value] : [RACSignal error:error]); + }] setNameWithFormat:@"[%@] -try:", self.name]; +} + +- (RACSignal *)tryMap:(id (^)(id value, NSError **errorPtr))mapBlock { + NSCParameterAssert(mapBlock != NULL); + + return [[self flattenMap:^(id value) { + NSError *error = nil; + id mappedValue = mapBlock(value, &error); + return (mappedValue == nil ? [RACSignal error:error] : [RACSignal return:mappedValue]); + }] setNameWithFormat:@"[%@] -tryMap:", self.name]; +} + +- (RACSignal *)initially:(void (^)(void))block { + NSCParameterAssert(block != NULL); + + return [[RACSignal defer:^{ + block(); + return self; + }] setNameWithFormat:@"[%@] -initially:", self.name]; +} + +- (RACSignal *)finally:(void (^)(void))block { + NSCParameterAssert(block != NULL); + + return [[[self + doError:^(NSError *error) { + block(); + }] + doCompleted:^{ + block(); + }] + setNameWithFormat:@"[%@] -finally:", self.name]; +} + +- (RACSignal *)bufferWithTime:(NSTimeInterval)interval onScheduler:(RACScheduler *)scheduler { + NSCParameterAssert(scheduler != nil); + NSCParameterAssert(scheduler != RACScheduler.immediateScheduler); + + return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) { + RACSerialDisposable *timerDisposable = [[RACSerialDisposable alloc] init]; + NSMutableArray *values = [NSMutableArray array]; + + void (^flushValues)() = ^{ + @synchronized (values) { + [timerDisposable.disposable dispose]; + + if (values.count == 0) return; + + RACTuple *tuple = [RACTuple tupleWithObjectsFromArray:values convertNullsToNils:NO]; + [values removeAllObjects]; + [subscriber sendNext:tuple]; + } + }; + + RACDisposable *selfDisposable = [self subscribeNext:^(id x) { + @synchronized (values) { + if (values.count == 0) { + timerDisposable.disposable = [scheduler afterDelay:interval schedule:flushValues]; + } + + [values addObject:x ?: RACTupleNil.tupleNil]; + } + } error:^(NSError *error) { + [subscriber sendError:error]; + } completed:^{ + flushValues(); + [subscriber sendCompleted]; + }]; + + return [RACDisposable disposableWithBlock:^{ + [selfDisposable dispose]; + [timerDisposable dispose]; + }]; + }] setNameWithFormat:@"[%@] -bufferWithTime: %f", self.name, (double)interval]; +} + +- (RACSignal *)collect { + return [[self aggregateWithStartFactory:^{ + return [[NSMutableArray alloc] init]; + } reduce:^(NSMutableArray *collectedValues, id x) { + [collectedValues addObject:(x ?: NSNull.null)]; + return collectedValues; + }] setNameWithFormat:@"[%@] -collect", self.name]; +} + +- (RACSignal *)takeLast:(NSUInteger)count { + return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) { + NSMutableArray *valuesTaken = [NSMutableArray arrayWithCapacity:count]; + return [self subscribeNext:^(id x) { + [valuesTaken addObject:x ? : [RACTupleNil tupleNil]]; + + while(valuesTaken.count > count) { + [valuesTaken removeObjectAtIndex:0]; + } + } error:^(NSError *error) { + [subscriber sendError:error]; + } completed:^{ + for(id value in valuesTaken) { + [subscriber sendNext:[value isKindOfClass:[RACTupleNil class]] ? nil : value]; + } + + [subscriber sendCompleted]; + }]; + }] setNameWithFormat:@"[%@] -takeLast: %lu", self.name, (unsigned long)count]; +} + +- (RACSignal *)combineLatestWith:(RACSignal *)signal { + NSCParameterAssert(signal != nil); + + return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) { + RACCompoundDisposable *disposable = [RACCompoundDisposable compoundDisposable]; + + __block id lastSelfValue = nil; + __block BOOL selfCompleted = NO; + + __block id lastOtherValue = nil; + __block BOOL otherCompleted = NO; + + void (^sendNext)(void) = ^{ + @synchronized (disposable) { + if (lastSelfValue == nil || lastOtherValue == nil) return; + [subscriber sendNext:[RACTuple tupleWithObjects:lastSelfValue, lastOtherValue, nil]]; + } + }; + + RACDisposable *selfDisposable = [self subscribeNext:^(id x) { + @synchronized (disposable) { + lastSelfValue = x ?: RACTupleNil.tupleNil; + sendNext(); + } + } error:^(NSError *error) { + [subscriber sendError:error]; + } completed:^{ + @synchronized (disposable) { + selfCompleted = YES; + if (otherCompleted) [subscriber sendCompleted]; + } + }]; + + [disposable addDisposable:selfDisposable]; + + RACDisposable *otherDisposable = [signal subscribeNext:^(id x) { + @synchronized (disposable) { + lastOtherValue = x ?: RACTupleNil.tupleNil; + sendNext(); + } + } error:^(NSError *error) { + [subscriber sendError:error]; + } completed:^{ + @synchronized (disposable) { + otherCompleted = YES; + if (selfCompleted) [subscriber sendCompleted]; + } + }]; + + [disposable addDisposable:otherDisposable]; + + return disposable; + }] setNameWithFormat:@"[%@] -combineLatestWith: %@", self.name, signal]; +} + ++ (RACSignal *)combineLatest:(id<NSFastEnumeration>)signals { + return [[self join:signals block:^(RACSignal *left, RACSignal *right) { + return [left combineLatestWith:right]; + }] setNameWithFormat:@"+combineLatest: %@", signals]; +} + ++ (RACSignal *)combineLatest:(id<NSFastEnumeration>)signals reduce:(id (^)())reduceBlock { + NSCParameterAssert(reduceBlock != nil); + + RACSignal *result = [self combineLatest:signals]; + + // Although we assert this condition above, older versions of this method + // supported this argument being nil. Avoid crashing Release builds of + // apps that depended on that. + if (reduceBlock != nil) result = [result reduceEach:reduceBlock]; + + return [result setNameWithFormat:@"+combineLatest: %@ reduce:", signals]; +} + +- (RACSignal *)merge:(RACSignal *)signal { + return [[RACSignal + merge:@[ self, signal ]] + setNameWithFormat:@"[%@] -merge: %@", self.name, signal]; +} + ++ (RACSignal *)merge:(id<NSFastEnumeration>)signals { + NSMutableArray *copiedSignals = [[NSMutableArray alloc] init]; + for (RACSignal *signal in signals) { + [copiedSignals addObject:signal]; + } + + return [[[RACSignal + createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) { + for (RACSignal *signal in copiedSignals) { + [subscriber sendNext:signal]; + } + + [subscriber sendCompleted]; + return nil; + }] + flatten] + setNameWithFormat:@"+merge: %@", copiedSignals]; +} + +- (RACSignal *)flatten:(NSUInteger)maxConcurrent { + return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) { + RACCompoundDisposable *compoundDisposable = [[RACCompoundDisposable alloc] init]; + + // Contains disposables for the currently active subscriptions. + // + // This should only be used while synchronized on `subscriber`. + NSMutableArray *activeDisposables = [[NSMutableArray alloc] initWithCapacity:maxConcurrent]; + + // Whether the signal-of-signals has completed yet. + // + // This should only be used while synchronized on `subscriber`. + __block BOOL selfCompleted = NO; + + // Subscribes to the given signal. + // + // This will be set to nil once all signals have completed (to break + // a retain cycle in the recursive block). + __block void (^subscribeToSignal)(RACSignal *); + + // Sends completed to the subscriber if all signals are finished. + // + // This should only be used while synchronized on `subscriber`. + void (^completeIfAllowed)(void) = ^{ + if (selfCompleted && activeDisposables.count == 0) { + [subscriber sendCompleted]; + subscribeToSignal = nil; + } + }; + + // The signals waiting to be started. + // + // This array should only be used while synchronized on `subscriber`. + NSMutableArray *queuedSignals = [NSMutableArray array]; + + subscribeToSignal = ^(RACSignal *signal) { + RACSerialDisposable *serialDisposable = [[RACSerialDisposable alloc] init]; + + @synchronized (subscriber) { + [compoundDisposable addDisposable:serialDisposable]; + [activeDisposables addObject:serialDisposable]; + } + + serialDisposable.disposable = [signal subscribeNext:^(id x) { + [subscriber sendNext:x]; + } error:^(NSError *error) { + [subscriber sendError:error]; + } completed:^{ + RACSignal *nextSignal; + + @synchronized (subscriber) { + [compoundDisposable removeDisposable:serialDisposable]; + [activeDisposables removeObjectIdenticalTo:serialDisposable]; + + if (queuedSignals.count == 0) { + completeIfAllowed(); + return; + } + + nextSignal = queuedSignals[0]; + [queuedSignals removeObjectAtIndex:0]; + } + + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Warc-retain-cycles" + // This retain cycle is broken in `completeIfAllowed`. + subscribeToSignal(nextSignal); + #pragma clang diagnostic pop + }]; + }; + + [compoundDisposable addDisposable:[self subscribeNext:^(RACSignal *signal) { + if (signal == nil) return; + + NSCAssert([signal isKindOfClass:RACSignal.class], @"Expected a RACSignal, got %@", signal); + + @synchronized (subscriber) { + if (maxConcurrent > 0 && activeDisposables.count >= maxConcurrent) { + [queuedSignals addObject:signal]; + + // If we need to wait, skip subscribing to this + // signal. + return; + } + } + + subscribeToSignal(signal); + } error:^(NSError *error) { + [subscriber sendError:error]; + } completed:^{ + @synchronized (subscriber) { + selfCompleted = YES; + completeIfAllowed(); + } + }]]; + + return compoundDisposable; + }] setNameWithFormat:@"[%@] -flatten: %lu", self.name, (unsigned long)maxConcurrent]; +} + +- (RACSignal *)then:(RACSignal * (^)(void))block { + NSCParameterAssert(block != nil); + + return [[[self + ignoreValues] + concat:[RACSignal defer:block]] + setNameWithFormat:@"[%@] -then:", self.name]; +} + +- (RACSignal *)concat { + return [[self flatten:1] setNameWithFormat:@"[%@] -concat", self.name]; +} + +- (RACSignal *)aggregateWithStartFactory:(id (^)(void))startFactory reduce:(id (^)(id running, id next))reduceBlock { + NSCParameterAssert(startFactory != NULL); + NSCParameterAssert(reduceBlock != NULL); + + return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) { + __block id runningValue = startFactory(); + return [self subscribeNext:^(id x) { + runningValue = reduceBlock(runningValue, x); + } error:^(NSError *error) { + [subscriber sendError:error]; + } completed:^{ + [subscriber sendNext:runningValue]; + [subscriber sendCompleted]; + }]; + }] setNameWithFormat:@"[%@] -aggregateWithStartFactory:reduce:", self.name]; +} + +- (RACSignal *)aggregateWithStart:(id)start reduce:(id (^)(id running, id next))reduceBlock { + RACSignal *signal = [self aggregateWithStartFactory:^{ + return start; + } reduce:reduceBlock]; + + return [signal setNameWithFormat:@"[%@] -aggregateWithStart: %@ reduce:", self.name, [start rac_description]]; +} + +- (RACDisposable *)setKeyPath:(NSString *)keyPath onObject:(NSObject *)object { + return [self setKeyPath:keyPath onObject:object nilValue:nil]; +} + +- (RACDisposable *)setKeyPath:(NSString *)keyPath onObject:(NSObject *)object nilValue:(id)nilValue { + NSCParameterAssert(keyPath != nil); + NSCParameterAssert(object != nil); + + keyPath = [keyPath copy]; + + RACCompoundDisposable *disposable = [RACCompoundDisposable compoundDisposable]; + + // Purposely not retaining 'object', since we want to tear down the binding + // when it deallocates normally. + __block void * volatile objectPtr = (__bridge void *)object; + + RACDisposable *subscriptionDisposable = [self subscribeNext:^(id x) { + // Possibly spec, possibly compiler bug, but this __bridge cast does not + // result in a retain here, effectively an invisible __unsafe_unretained + // qualifier. Using objc_precise_lifetime gives the __strong reference + // desired. The explicit use of __strong is strictly defensive. + __strong NSObject *object __attribute__((objc_precise_lifetime)) = (__bridge __strong id)objectPtr; + [object setValue:x ?: nilValue forKeyPath:keyPath]; + } error:^(NSError *error) { + __strong NSObject *object __attribute__((objc_precise_lifetime)) = (__bridge __strong id)objectPtr; + + NSCAssert(NO, @"Received error from %@ in binding for key path \"%@\" on %@: %@", self, keyPath, object, error); + + // Log the error if we're running with assertions disabled. + NSLog(@"Received error from %@ in binding for key path \"%@\" on %@: %@", self, keyPath, object, error); + + [disposable dispose]; + } completed:^{ + [disposable dispose]; + }]; + + [disposable addDisposable:subscriptionDisposable]; + + #if DEBUG + static void *bindingsKey = &bindingsKey; + NSMutableDictionary *bindings; + + @synchronized (object) { + bindings = objc_getAssociatedObject(object, bindingsKey); + if (bindings == nil) { + bindings = [NSMutableDictionary dictionary]; + objc_setAssociatedObject(object, bindingsKey, bindings, OBJC_ASSOCIATION_RETAIN_NONATOMIC); + } + } + + @synchronized (bindings) { + NSCAssert(bindings[keyPath] == nil, @"Signal %@ is already bound to key path \"%@\" on object %@, adding signal %@ is undefined behavior", [bindings[keyPath] nonretainedObjectValue], keyPath, object, self); + + bindings[keyPath] = [NSValue valueWithNonretainedObject:self]; + } + #endif + + RACDisposable *clearPointerDisposable = [RACDisposable disposableWithBlock:^{ + #if DEBUG + @synchronized (bindings) { + [bindings removeObjectForKey:keyPath]; + } + #endif + + while (YES) { + void *ptr = objectPtr; + if (OSAtomicCompareAndSwapPtrBarrier(ptr, NULL, &objectPtr)) { + break; + } + } + }]; + + [disposable addDisposable:clearPointerDisposable]; + + [object.rac_deallocDisposable addDisposable:disposable]; + + RACCompoundDisposable *objectDisposable = object.rac_deallocDisposable; + return [RACDisposable disposableWithBlock:^{ + [objectDisposable removeDisposable:disposable]; + [disposable dispose]; + }]; +} + ++ (RACSignal *)interval:(NSTimeInterval)interval onScheduler:(RACScheduler *)scheduler { + return [[RACSignal interval:interval onScheduler:scheduler withLeeway:0.0] setNameWithFormat:@"+interval: %f onScheduler: %@", (double)interval, scheduler]; +} + ++ (RACSignal *)interval:(NSTimeInterval)interval onScheduler:(RACScheduler *)scheduler withLeeway:(NSTimeInterval)leeway { + NSCParameterAssert(scheduler != nil); + NSCParameterAssert(scheduler != RACScheduler.immediateScheduler); + + return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) { + return [scheduler after:[NSDate dateWithTimeIntervalSinceNow:interval] repeatingEvery:interval withLeeway:leeway schedule:^{ + [subscriber sendNext:[NSDate date]]; + }]; + }] setNameWithFormat:@"+interval: %f onScheduler: %@ withLeeway: %f", (double)interval, scheduler, (double)leeway]; +} + +- (RACSignal *)takeUntil:(RACSignal *)signalTrigger { + return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) { + RACCompoundDisposable *disposable = [RACCompoundDisposable compoundDisposable]; + void (^triggerCompletion)(void) = ^{ + [disposable dispose]; + [subscriber sendCompleted]; + }; + + RACDisposable *triggerDisposable = [signalTrigger subscribeNext:^(id _) { + triggerCompletion(); + } completed:^{ + triggerCompletion(); + }]; + + [disposable addDisposable:triggerDisposable]; + + if (!disposable.disposed) { + RACDisposable *selfDisposable = [self subscribeNext:^(id x) { + [subscriber sendNext:x]; + } error:^(NSError *error) { + [subscriber sendError:error]; + } completed:^{ + [disposable dispose]; + [subscriber sendCompleted]; + }]; + + [disposable addDisposable:selfDisposable]; + } + + return disposable; + }] setNameWithFormat:@"[%@] -takeUntil: %@", self.name, signalTrigger]; +} + +- (RACSignal *)takeUntilReplacement:(RACSignal *)replacement { + return [RACSignal createSignal:^(id<RACSubscriber> subscriber) { + RACSerialDisposable *selfDisposable = [[RACSerialDisposable alloc] init]; + + RACDisposable *replacementDisposable = [replacement subscribeNext:^(id x) { + [selfDisposable dispose]; + [subscriber sendNext:x]; + } error:^(NSError *error) { + [selfDisposable dispose]; + [subscriber sendError:error]; + } completed:^{ + [selfDisposable dispose]; + [subscriber sendCompleted]; + }]; + + if (!selfDisposable.disposed) { + selfDisposable.disposable = [[self + concat:[RACSignal never]] + subscribe:subscriber]; + } + + return [RACDisposable disposableWithBlock:^{ + [selfDisposable dispose]; + [replacementDisposable dispose]; + }]; + }]; +} + +- (RACSignal *)switchToLatest { + return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) { + RACMulticastConnection *connection = [self publish]; + + RACDisposable *subscriptionDisposable = [[connection.signal + flattenMap:^(RACSignal *x) { + NSCAssert(x == nil || [x isKindOfClass:RACSignal.class], @"-switchToLatest requires that the source signal (%@) send signals. Instead we got: %@", self, x); + + // -concat:[RACSignal never] prevents completion of the receiver from + // prematurely terminating the inner signal. + return [x takeUntil:[connection.signal concat:[RACSignal never]]]; + }] + subscribe:subscriber]; + + RACDisposable *connectionDisposable = [connection connect]; + return [RACDisposable disposableWithBlock:^{ + [subscriptionDisposable dispose]; + [connectionDisposable dispose]; + }]; + }] setNameWithFormat:@"[%@] -switchToLatest", self.name]; +} + ++ (RACSignal *)switch:(RACSignal *)signal cases:(NSDictionary *)cases default:(RACSignal *)defaultSignal { + NSCParameterAssert(signal != nil); + NSCParameterAssert(cases != nil); + + for (id key in cases) { + id value __attribute__((unused)) = cases[key]; + NSCAssert([value isKindOfClass:RACSignal.class], @"Expected all cases to be RACSignals, %@ isn't", value); + } + + NSDictionary *copy = [cases copy]; + + return [[[signal + map:^(id key) { + if (key == nil) key = RACTupleNil.tupleNil; + + RACSignal *signal = copy[key] ?: defaultSignal; + if (signal == nil) { + NSString *description = [NSString stringWithFormat:NSLocalizedString(@"No matching signal found for value %@", @""), key]; + return [RACSignal error:[NSError errorWithDomain:RACSignalErrorDomain code:RACSignalErrorNoMatchingCase userInfo:@{ NSLocalizedDescriptionKey: description }]]; + } + + return signal; + }] + switchToLatest] + setNameWithFormat:@"+switch: %@ cases: %@ default: %@", signal, cases, defaultSignal]; +} + ++ (RACSignal *)if:(RACSignal *)boolSignal then:(RACSignal *)trueSignal else:(RACSignal *)falseSignal { + NSCParameterAssert(boolSignal != nil); + NSCParameterAssert(trueSignal != nil); + NSCParameterAssert(falseSignal != nil); + + return [[[boolSignal + map:^(NSNumber *value) { + NSCAssert([value isKindOfClass:NSNumber.class], @"Expected %@ to send BOOLs, not %@", boolSignal, value); + + return (value.boolValue ? trueSignal : falseSignal); + }] + switchToLatest] + setNameWithFormat:@"+if: %@ then: %@ else: %@", boolSignal, trueSignal, falseSignal]; +} + +- (id)first { + return [self firstOrDefault:nil]; +} + +- (id)firstOrDefault:(id)defaultValue { + return [self firstOrDefault:defaultValue success:NULL error:NULL]; +} + +- (id)firstOrDefault:(id)defaultValue success:(BOOL *)success error:(NSError **)error { + NSCondition *condition = [[NSCondition alloc] init]; + condition.name = [NSString stringWithFormat:@"[%@] -firstOrDefault: %@ success:error:", self.name, defaultValue]; + + __block id value = defaultValue; + __block BOOL done = NO; + + // Ensures that we don't pass values across thread boundaries by reference. + __block NSError *localError; + __block BOOL localSuccess; + + [[self take:1] subscribeNext:^(id x) { + [condition lock]; + + value = x; + localSuccess = YES; + + done = YES; + [condition broadcast]; + [condition unlock]; + } error:^(NSError *e) { + [condition lock]; + + if (!done) { + localSuccess = NO; + localError = e; + + done = YES; + [condition broadcast]; + } + + [condition unlock]; + } completed:^{ + [condition lock]; + + localSuccess = YES; + + done = YES; + [condition broadcast]; + [condition unlock]; + }]; + + [condition lock]; + while (!done) { + [condition wait]; + } + + if (success != NULL) *success = localSuccess; + if (error != NULL) *error = localError; + + [condition unlock]; + return value; +} + +- (BOOL)waitUntilCompleted:(NSError **)error { + BOOL success = NO; + + [[[self + ignoreValues] + setNameWithFormat:@"[%@] -waitUntilCompleted:", self.name] + firstOrDefault:nil success:&success error:error]; + + return success; +} + ++ (RACSignal *)defer:(RACSignal * (^)(void))block { + NSCParameterAssert(block != NULL); + + return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) { + return [block() subscribe:subscriber]; + }] setNameWithFormat:@"+defer:"]; +} + +- (NSArray *)toArray { + return [[[self collect] first] copy]; +} + +- (RACSequence *)sequence { + return [[RACSignalSequence sequenceWithSignal:self] setNameWithFormat:@"[%@] -sequence", self.name]; +} + +- (RACMulticastConnection *)publish { + RACSubject *subject = [[RACSubject subject] setNameWithFormat:@"[%@] -publish", self.name]; + RACMulticastConnection *connection = [self multicast:subject]; + return connection; +} + +- (RACMulticastConnection *)multicast:(RACSubject *)subject { + [subject setNameWithFormat:@"[%@] -multicast: %@", self.name, subject.name]; + RACMulticastConnection *connection = [[RACMulticastConnection alloc] initWithSourceSignal:self subject:subject]; + return connection; +} + +- (RACSignal *)replay { + RACReplaySubject *subject = [[RACReplaySubject subject] setNameWithFormat:@"[%@] -replay", self.name]; + + RACMulticastConnection *connection = [self multicast:subject]; + [connection connect]; + + return connection.signal; +} + +- (RACSignal *)replayLast { + RACReplaySubject *subject = [[RACReplaySubject replaySubjectWithCapacity:1] setNameWithFormat:@"[%@] -replayLast", self.name]; + + RACMulticastConnection *connection = [self multicast:subject]; + [connection connect]; + + return connection.signal; +} + +- (RACSignal *)replayLazily { + RACMulticastConnection *connection = [self multicast:[RACReplaySubject subject]]; + return [[RACSignal + defer:^{ + [connection connect]; + return connection.signal; + }] + setNameWithFormat:@"[%@] -replayLazily", self.name]; +} + +- (RACSignal *)timeout:(NSTimeInterval)interval onScheduler:(RACScheduler *)scheduler { + NSCParameterAssert(scheduler != nil); + NSCParameterAssert(scheduler != RACScheduler.immediateScheduler); + + return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) { + RACCompoundDisposable *disposable = [RACCompoundDisposable compoundDisposable]; + + RACDisposable *timeoutDisposable = [scheduler afterDelay:interval schedule:^{ + [disposable dispose]; + [subscriber sendError:[NSError errorWithDomain:RACSignalErrorDomain code:RACSignalErrorTimedOut userInfo:nil]]; + }]; + + [disposable addDisposable:timeoutDisposable]; + + RACDisposable *subscriptionDisposable = [self subscribeNext:^(id x) { + [subscriber sendNext:x]; + } error:^(NSError *error) { + [disposable dispose]; + [subscriber sendError:error]; + } completed:^{ + [disposable dispose]; + [subscriber sendCompleted]; + }]; + + [disposable addDisposable:subscriptionDisposable]; + return disposable; + }] setNameWithFormat:@"[%@] -timeout: %f", self.name, (double)interval]; +} + +- (RACSignal *)deliverOn:(RACScheduler *)scheduler { + return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) { + return [self subscribeNext:^(id x) { + [scheduler schedule:^{ + [subscriber sendNext:x]; + }]; + } error:^(NSError *error) { + [scheduler schedule:^{ + [subscriber sendError:error]; + }]; + } completed:^{ + [scheduler schedule:^{ + [subscriber sendCompleted]; + }]; + }]; + }] setNameWithFormat:@"[%@] -deliverOn: %@", self.name, scheduler]; +} + +- (RACSignal *)subscribeOn:(RACScheduler *)scheduler { + return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) { + RACCompoundDisposable *disposable = [RACCompoundDisposable compoundDisposable]; + + RACDisposable *schedulingDisposable = [scheduler schedule:^{ + RACDisposable *subscriptionDisposable = [self subscribeNext:^(id x) { + [subscriber sendNext:x]; + } error:^(NSError *error) { + [subscriber sendError:error]; + } completed:^{ + [subscriber sendCompleted]; + }]; + + [disposable addDisposable:subscriptionDisposable]; + }]; + + [disposable addDisposable:schedulingDisposable]; + return disposable; + }] setNameWithFormat:@"[%@] -subscribeOn: %@", self.name, scheduler]; +} + +- (RACSignal *)groupBy:(id<NSCopying> (^)(id object))keyBlock transform:(id (^)(id object))transformBlock { + NSCParameterAssert(keyBlock != NULL); + + return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) { + NSMutableDictionary *groups = [NSMutableDictionary dictionary]; + + return [self subscribeNext:^(id x) { + id<NSCopying> key = keyBlock(x); + RACGroupedSignal *groupSubject = nil; + @synchronized(groups) { + groupSubject = [groups objectForKey:key]; + if(groupSubject == nil) { + groupSubject = [RACGroupedSignal signalWithKey:key]; + [groups setObject:groupSubject forKey:key]; + [subscriber sendNext:groupSubject]; + } + } + + [groupSubject sendNext:transformBlock != NULL ? transformBlock(x) : x]; + } error:^(NSError *error) { + [subscriber sendError:error]; + + [groups.allValues makeObjectsPerformSelector:@selector(sendError:) withObject:error]; + } completed:^{ + [subscriber sendCompleted]; + + [groups.allValues makeObjectsPerformSelector:@selector(sendCompleted)]; + }]; + }] setNameWithFormat:@"[%@] -groupBy:transform:", self.name]; +} + +- (RACSignal *)groupBy:(id<NSCopying> (^)(id object))keyBlock { + return [[self groupBy:keyBlock transform:nil] setNameWithFormat:@"[%@] -groupBy:", self.name]; +} + +- (RACSignal *)any { + return [[self any:^(id x) { + return YES; + }] setNameWithFormat:@"[%@] -any", self.name]; +} + +- (RACSignal *)any:(BOOL (^)(id object))predicateBlock { + NSCParameterAssert(predicateBlock != NULL); + + return [[[self materialize] bind:^{ + return ^(RACEvent *event, BOOL *stop) { + if (event.finished) { + *stop = YES; + return [RACSignal return:@NO]; + } + + if (predicateBlock(event.value)) { + *stop = YES; + return [RACSignal return:@YES]; + } + + return [RACSignal empty]; + }; + }] setNameWithFormat:@"[%@] -any:", self.name]; +} + +- (RACSignal *)all:(BOOL (^)(id object))predicateBlock { + NSCParameterAssert(predicateBlock != NULL); + + return [[[self materialize] bind:^{ + return ^(RACEvent *event, BOOL *stop) { + if (event.eventType == RACEventTypeCompleted) { + *stop = YES; + return [RACSignal return:@YES]; + } + + if (event.eventType == RACEventTypeError || !predicateBlock(event.value)) { + *stop = YES; + return [RACSignal return:@NO]; + } + + return [RACSignal empty]; + }; + }] setNameWithFormat:@"[%@] -all:", self.name]; +} + +- (RACSignal *)retry:(NSInteger)retryCount { + return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) { + __block NSInteger currentRetryCount = 0; + return subscribeForever(self, + ^(id x) { + [subscriber sendNext:x]; + }, + ^(NSError *error, RACDisposable *disposable) { + if (retryCount == 0 || currentRetryCount < retryCount) { + // Resubscribe. + currentRetryCount++; + return; + } + + [disposable dispose]; + [subscriber sendError:error]; + }, + ^(RACDisposable *disposable) { + [disposable dispose]; + [subscriber sendCompleted]; + }); + }] setNameWithFormat:@"[%@] -retry: %lu", self.name, (unsigned long)retryCount]; +} + +- (RACSignal *)retry { + return [[self retry:0] setNameWithFormat:@"[%@] -retry", self.name]; +} + +- (RACSignal *)sample:(RACSignal *)sampler { + NSCParameterAssert(sampler != nil); + + return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) { + NSLock *lock = [[NSLock alloc] init]; + __block id lastValue; + __block BOOL hasValue = NO; + + RACSerialDisposable *samplerDisposable = [[RACSerialDisposable alloc] init]; + RACDisposable *sourceDisposable = [self subscribeNext:^(id x) { + [lock lock]; + hasValue = YES; + lastValue = x; + [lock unlock]; + } error:^(NSError *error) { + [samplerDisposable dispose]; + [subscriber sendError:error]; + } completed:^{ + [samplerDisposable dispose]; + [subscriber sendCompleted]; + }]; + + samplerDisposable.disposable = [sampler subscribeNext:^(id _) { + BOOL shouldSend = NO; + id value; + [lock lock]; + shouldSend = hasValue; + value = lastValue; + [lock unlock]; + + if (shouldSend) { + [subscriber sendNext:value]; + } + } error:^(NSError *error) { + [sourceDisposable dispose]; + [subscriber sendError:error]; + } completed:^{ + [sourceDisposable dispose]; + [subscriber sendCompleted]; + }]; + + return [RACDisposable disposableWithBlock:^{ + [samplerDisposable dispose]; + [sourceDisposable dispose]; + }]; + }] setNameWithFormat:@"[%@] -sample: %@", self.name, sampler]; +} + +- (RACSignal *)ignoreValues { + return [[self filter:^(id _) { + return NO; + }] setNameWithFormat:@"[%@] -ignoreValues", self.name]; +} + +- (RACSignal *)materialize { + return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) { + return [self subscribeNext:^(id x) { + [subscriber sendNext:[RACEvent eventWithValue:x]]; + } error:^(NSError *error) { + [subscriber sendNext:[RACEvent eventWithError:error]]; + [subscriber sendCompleted]; + } completed:^{ + [subscriber sendNext:RACEvent.completedEvent]; + [subscriber sendCompleted]; + }]; + }] setNameWithFormat:@"[%@] -materialize", self.name]; +} + +- (RACSignal *)dematerialize { + return [[self bind:^{ + return ^(RACEvent *event, BOOL *stop) { + switch (event.eventType) { + case RACEventTypeCompleted: + *stop = YES; + return [RACSignal empty]; + + case RACEventTypeError: + *stop = YES; + return [RACSignal error:event.error]; + + case RACEventTypeNext: + return [RACSignal return:event.value]; + } + }; + }] setNameWithFormat:@"[%@] -dematerialize", self.name]; +} + +- (RACSignal *)not { + return [[self map:^(NSNumber *value) { + NSCAssert([value isKindOfClass:NSNumber.class], @"-not must only be used on a signal of NSNumbers. Instead, got: %@", value); + + return @(!value.boolValue); + }] setNameWithFormat:@"[%@] -not", self.name]; +} + +- (RACSignal *)and { + return [[self map:^(RACTuple *tuple) { + NSCAssert([tuple isKindOfClass:RACTuple.class], @"-and must only be used on a signal of RACTuples of NSNumbers. Instead, received: %@", tuple); + NSCAssert(tuple.count > 0, @"-and must only be used on a signal of RACTuples of NSNumbers, with at least 1 value in the tuple"); + + return @([tuple.rac_sequence all:^(NSNumber *number) { + NSCAssert([number isKindOfClass:NSNumber.class], @"-and must only be used on a signal of RACTuples of NSNumbers. Instead, tuple contains a non-NSNumber value: %@", tuple); + + return number.boolValue; + }]); + }] setNameWithFormat:@"[%@] -and", self.name]; +} + +- (RACSignal *)or { + return [[self map:^(RACTuple *tuple) { + NSCAssert([tuple isKindOfClass:RACTuple.class], @"-or must only be used on a signal of RACTuples of NSNumbers. Instead, received: %@", tuple); + NSCAssert(tuple.count > 0, @"-or must only be used on a signal of RACTuples of NSNumbers, with at least 1 value in the tuple"); + + return @([tuple.rac_sequence any:^(NSNumber *number) { + NSCAssert([number isKindOfClass:NSNumber.class], @"-or must only be used on a signal of RACTuples of NSNumbers. Instead, tuple contains a non-NSNumber value: %@", tuple); + + return number.boolValue; + }]); + }] setNameWithFormat:@"[%@] -or", self.name]; +} + +@end + +@implementation RACSignal (OperationsDeprecated) + +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wdeprecated-implementations" + +- (RACSignal *)windowWithStart:(RACSignal *)openSignal close:(RACSignal * (^)(RACSignal *start))closeBlock { + NSCParameterAssert(openSignal != nil); + NSCParameterAssert(closeBlock != NULL); + + return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) { + __block RACSubject *currentWindow = nil; + __block RACSignal *currentCloseWindow = nil; + __block RACDisposable *closeObserverDisposable = NULL; + + void (^closeCurrentWindow)(void) = ^{ + [currentWindow sendCompleted]; + currentWindow = nil; + currentCloseWindow = nil; + [closeObserverDisposable dispose], closeObserverDisposable = nil; + }; + + RACDisposable *openObserverDisposable = [openSignal subscribe:[RACSubscriber subscriberWithNext:^(id x) { + if(currentWindow == nil) { + currentWindow = [RACSubject subject]; + [subscriber sendNext:currentWindow]; + + currentCloseWindow = closeBlock(currentWindow); + closeObserverDisposable = [currentCloseWindow subscribe:[RACSubscriber subscriberWithNext:^(id x) { + closeCurrentWindow(); + } error:^(NSError *error) { + closeCurrentWindow(); + } completed:^{ + closeCurrentWindow(); + }]]; + } + } error:^(NSError *error) { + + } completed:^{ + + }]]; + + RACDisposable *selfObserverDisposable = [self subscribeNext:^(id x) { + [currentWindow sendNext:x]; + } error:^(NSError *error) { + [subscriber sendError:error]; + } completed:^{ + [subscriber sendCompleted]; + }]; + + return [RACDisposable disposableWithBlock:^{ + [closeObserverDisposable dispose]; + [openObserverDisposable dispose]; + [selfObserverDisposable dispose]; + }]; + }] setNameWithFormat:@"[%@] -windowWithStart: %@ close:", self.name, openSignal]; +} + +- (RACSignal *)buffer:(NSUInteger)bufferCount { + NSCParameterAssert(bufferCount > 0); + return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) { + NSMutableArray *values = [NSMutableArray arrayWithCapacity:bufferCount]; + RACSubject *windowCloseSubject = [RACSubject subject]; + + RACDisposable *closeDisposable = [windowCloseSubject subscribeNext:^(id x) { + [subscriber sendNext:[RACTuple tupleWithObjectsFromArray:values convertNullsToNils:NO]]; + [values removeAllObjects]; + }]; + + __block RACDisposable *innerDisposable = nil; + RACDisposable *outerDisposable = [[self windowWithStart:self close:^(RACSignal *start) { + return windowCloseSubject; + }] subscribeNext:^(id x) { + innerDisposable = [x subscribeNext:^(id x) { + [values addObject:x ? : [RACTupleNil tupleNil]]; + if(values.count % bufferCount == 0) { + [windowCloseSubject sendNext:[RACUnit defaultUnit]]; + } + }]; + } error:^(NSError *error) { + [subscriber sendError:error]; + } completed:^{ + [subscriber sendCompleted]; + }]; + + return [RACDisposable disposableWithBlock:^{ + [innerDisposable dispose]; + [outerDisposable dispose]; + [closeDisposable dispose]; + }]; + }] setNameWithFormat:@"[%@] -buffer: %lu", self.name, (unsigned long)bufferCount]; +} + +- (RACSignal *)let:(RACSignal * (^)(RACSignal *sharedSignal))letBlock { + NSCParameterAssert(letBlock != NULL); + + return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) { + RACMulticastConnection *connection = [self publish]; + RACDisposable *finalDisposable = [letBlock(connection.signal) subscribeNext:^(id x) { + [subscriber sendNext:x]; + } error:^(NSError *error) { + [subscriber sendError:error]; + } completed:^{ + [subscriber sendCompleted]; + }]; + + RACDisposable *connectionDisposable = [connection connect]; + + return [RACDisposable disposableWithBlock:^{ + [connectionDisposable dispose]; + [finalDisposable dispose]; + }]; + }] setNameWithFormat:@"[%@] -let:", self.name]; +} + ++ (RACSignal *)interval:(NSTimeInterval)interval { + return [RACSignal interval:interval onScheduler:[RACScheduler schedulerWithPriority:RACSchedulerPriorityHigh]]; +} + ++ (RACSignal *)interval:(NSTimeInterval)interval withLeeway:(NSTimeInterval)leeway { + return [RACSignal interval:interval onScheduler:[RACScheduler schedulerWithPriority:RACSchedulerPriorityHigh] withLeeway:leeway]; +} + +- (RACSignal *)timeout:(NSTimeInterval)interval { + return [self timeout:interval onScheduler:[RACScheduler schedulerWithPriority:RACSchedulerPriorityHigh]]; +} + +- (RACSignal *)bufferWithTime:(NSTimeInterval)interval { + return [self bufferWithTime:interval onScheduler:[RACScheduler schedulerWithPriority:RACSchedulerPriorityHigh]]; +} + +- (RACDisposable *)toProperty:(NSString *)keyPath onObject:(NSObject *)object { + return [self setKeyPath:keyPath onObject:object]; +} + +- (RACSignal *)ignoreElements { + return [self ignoreValues]; +} + +- (RACSignal *)sequenceNext:(RACSignal * (^)(void))block { + return [self then:block]; +} + +- (RACSignal *)aggregateWithStart:(id)start combine:(id (^)(id running, id next))combineBlock { + return [self aggregateWithStart:start reduce:combineBlock]; +} + +- (RACSignal *)aggregateWithStartFactory:(id (^)(void))startFactory combine:(id (^)(id running, id next))combineBlock { + return [self aggregateWithStartFactory:startFactory reduce:combineBlock]; +} + +- (RACDisposable *)executeCommand:(RACCommand *)command { + NSCParameterAssert(command != nil); + + return [self subscribeNext:^(id x) { + [command execute:x]; + }]; +} + +#pragma clang diagnostic pop + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACSignal.h b/ReactiveCocoaFramework/ReactiveCocoa/RACSignal.h new file mode 100644 index 0000000..ed644cf --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACSignal.h
@@ -0,0 +1,219 @@ +// +// RACSignal.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 3/1/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import <Foundation/Foundation.h> +#import "RACStream.h" + +@class RACDisposable; +@class RACScheduler; +@class RACSubject; +@protocol RACSubscriber; + +@interface RACSignal : RACStream + +/// Creates a new signal. This is the preferred way to create a new signal +/// operation or behavior. +/// +/// Events can be sent to new subscribers immediately in the `didSubscribe` +/// block, but the subscriber will not be able to dispose of the signal until +/// a RACDisposable is returned from `didSubscribe`. In the case of infinite +/// signals, this won't _ever_ happen if events are sent immediately. +/// +/// To ensure that the signal is disposable, events can be scheduled on the +/// +[RACScheduler currentScheduler] (so that they're deferred, not sent +/// immediately), or they can be sent in the background. The RACDisposable +/// returned by the `didSubscribe` block should cancel any such scheduling or +/// asynchronous work. +/// +/// didSubscribe - Called when the signal is subscribed to. The new subscriber is +/// passed in. You can then manually control the <RACSubscriber> by +/// sending it -sendNext:, -sendError:, and -sendCompleted, +/// as defined by the operation you're implementing. This block +/// should return a RACDisposable which cancels any ongoing work +/// triggered by the subscription, and cleans up any resources or +/// disposables created as part of it. When the disposable is +/// disposed of, the signal must not send any more events to the +/// `subscriber`. If no cleanup is necessary, return nil. +/// +/// **Note:** The `didSubscribe` block is called every time a new subscriber +/// subscribes. Any side effects within the block will thus execute once for each +/// subscription, not necessarily on one thread, and possibly even +/// simultaneously! ++ (RACSignal *)createSignal:(RACDisposable * (^)(id<RACSubscriber> subscriber))didSubscribe; + +/// Returns a signal that immediately sends the given error. ++ (RACSignal *)error:(NSError *)error; + +/// Returns a signal that never completes. ++ (RACSignal *)never; + +/// Immediately schedules the given block on the given scheduler. The block is +/// given a subscriber to which it can send events. +/// +/// scheduler - The scheduler on which `block` will be scheduled and results +/// delivered. Cannot be nil. +/// block - The block to invoke. Cannot be NULL. +/// +/// Returns a signal which will send all events sent on the subscriber given to +/// `block`. All events will be sent on `scheduler` and it will replay any missed +/// events to new subscribers. ++ (RACSignal *)startEagerlyWithScheduler:(RACScheduler *)scheduler block:(void (^)(id<RACSubscriber> subscriber))block; + +/// Invokes the given block only on the first subscription. The block is given a +/// subscriber to which it can send events. +/// +/// Note that disposing of the subscription to the returned signal will *not* +/// dispose of the underlying subscription. If you need that behavior, see +/// -[RACMulticastConnection autoconnect]. The underlying subscription will never +/// be disposed of. Because of this, `block` should never return an infinite +/// signal since there would be no way of ending it. +/// +/// scheduler - The scheduler on which the block should be scheduled. Note that +/// if given +[RACScheduler immediateScheduler], the block will be +/// invoked synchronously on the first subscription. Cannot be nil. +/// block - The block to invoke on the first subscription. Cannot be NULL. +/// +/// Returns a signal which will pass through the events sent to the subscriber +/// given to `block` and replay any missed events to new subscribers. ++ (RACSignal *)startLazilyWithScheduler:(RACScheduler *)scheduler block:(void (^)(id<RACSubscriber> subscriber))block; + +@end + +@interface RACSignal (RACStream) + +/// Returns a signal that immediately sends the given value and then completes. ++ (RACSignal *)return:(id)value; + +/// Returns a signal that immediately completes. ++ (RACSignal *)empty; + +/// Subscribes to `signal` when the source signal completes. +- (RACSignal *)concat:(RACSignal *)signal; + +/// Zips the values in the receiver with those of the given signal to create +/// RACTuples. +/// +/// The first `next` of each stream will be combined, then the second `next`, and +/// so forth, until either signal completes or errors. +/// +/// signal - The signal to zip with. This must not be `nil`. +/// +/// Returns a new signal of RACTuples, representing the combined values of the +/// two signals. Any error from one of the original signals will be forwarded on +/// the returned signal. +- (RACSignal *)zipWith:(RACSignal *)signal; + +@end + +@interface RACSignal (Subscription) + +/// Subscribes `subscriber` to changes on the receiver. The receiver defines which +/// events it actually sends and in what situations the events are sent. +/// +/// Subscription will always happen on a valid RACScheduler. If the +/// +[RACScheduler currentScheduler] cannot be determined at the time of +/// subscription (e.g., because the calling code is running on a GCD queue or +/// NSOperationQueue), subscription will occur on a private background scheduler. +/// On the main thread, subscriptions will always occur immediately, with a +/// +[RACScheduler currentScheduler] of +[RACScheduler mainThreadScheduler]. +/// +/// This method must be overridden by any subclasses. +/// +/// Returns nil or a disposable. You can call -[RACDisposable dispose] if you +/// need to end your subscription before it would "naturally" end, either by +/// completing or erroring. Once the disposable has been disposed, the subscriber +/// won't receive any more events from the subscription. +- (RACDisposable *)subscribe:(id<RACSubscriber>)subscriber; + +/// Convenience method to subscribe to the `next` event. +/// +/// This corresponds to `IObserver<T>.OnNext` in Rx. +- (RACDisposable *)subscribeNext:(void (^)(id x))nextBlock; + +/// Convenience method to subscribe to the `next` and `completed` events. +- (RACDisposable *)subscribeNext:(void (^)(id x))nextBlock completed:(void (^)(void))completedBlock; + +/// Convenience method to subscribe to the `next`, `completed`, and `error` events. +- (RACDisposable *)subscribeNext:(void (^)(id x))nextBlock error:(void (^)(NSError *error))errorBlock completed:(void (^)(void))completedBlock; + +/// Convenience method to subscribe to `error` events. +/// +/// This corresponds to the `IObserver<T>.OnError` in Rx. +- (RACDisposable *)subscribeError:(void (^)(NSError *error))errorBlock; + +/// Convenience method to subscribe to `completed` events. +/// +/// This corresponds to the `IObserver<T>.OnCompleted` in Rx. +- (RACDisposable *)subscribeCompleted:(void (^)(void))completedBlock; + +/// Convenience method to subscribe to `next` and `error` events. +- (RACDisposable *)subscribeNext:(void (^)(id x))nextBlock error:(void (^)(NSError *error))errorBlock; + +/// Convenience method to subscribe to `error` and `completed` events. +- (RACDisposable *)subscribeError:(void (^)(NSError *error))errorBlock completed:(void (^)(void))completedBlock; + +@end + +/// Additional methods to assist with debugging. +@interface RACSignal (Debugging) + +/// Logs all events that the receiver sends. +- (RACSignal *)logAll; + +/// Logs each `next` that the receiver sends. +- (RACSignal *)logNext; + +/// Logs any error that the receiver sends. +- (RACSignal *)logError; + +/// Logs any `completed` event that the receiver sends. +- (RACSignal *)logCompleted; + +@end + +/// Additional methods to assist with unit testing. +/// +/// **These methods should never ship in production code.** +@interface RACSignal (Testing) + +/// Spins the main run loop for a short while, waiting for the receiver to send a `next`. +/// +/// **Because this method executes the run loop recursively, it should only be used +/// on the main thread, and only from a unit test.** +/// +/// defaultValue - Returned if the receiver completes or errors before sending +/// a `next`, or if the method times out. This argument may be +/// nil. +/// success - If not NULL, set to whether the receiver completed +/// successfully. +/// error - If not NULL, set to any error that occurred. +/// +/// Returns the first value received, or `defaultValue` if no value is received +/// before the signal finishes or the method times out. +- (id)asynchronousFirstOrDefault:(id)defaultValue success:(BOOL *)success error:(NSError **)error; + +/// Spins the main run loop for a short while, waiting for the receiver to complete. +/// +/// **Because this method executes the run loop recursively, it should only be used +/// on the main thread, and only from a unit test.** +/// +/// error - If not NULL, set to any error that occurs. +/// +/// Returns whether the signal completed successfully before timing out. If NO, +/// `error` will be set to any error that occurred. +- (BOOL)asynchronouslyWaitUntilCompleted:(NSError **)error; + +@end + +@interface RACSignal (Deprecated) + ++ (RACSignal *)start:(id (^)(BOOL *success, NSError **error))block __attribute__((deprecated("Use +startEagerlyWithScheduler:block: instead"))); ++ (RACSignal *)startWithScheduler:(RACScheduler *)scheduler subjectBlock:(void (^)(RACSubject *subject))block __attribute__((deprecated("Use +startEagerlyWithScheduler:block: instead"))); ++ (RACSignal *)startWithScheduler:(RACScheduler *)scheduler block:(id (^)(BOOL *success, NSError **error))block __attribute__((deprecated("Use +startEagerlyWithScheduler:block: instead"))); + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACSignal.m b/ReactiveCocoaFramework/ReactiveCocoa/RACSignal.m new file mode 100644 index 0000000..69d9700 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACSignal.m
@@ -0,0 +1,447 @@ +// +// RACSignal.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 3/15/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACSignal.h" +#import "RACCompoundDisposable.h" +#import "RACDisposable.h" +#import "RACDynamicSignal.h" +#import "RACEmptySignal.h" +#import "RACErrorSignal.h" +#import "RACMulticastConnection.h" +#import "RACReplaySubject.h" +#import "RACReturnSignal.h" +#import "RACScheduler.h" +#import "RACSerialDisposable.h" +#import "RACSignal+Operations.h" +#import "RACSubject.h" +#import "RACSubscriber+Private.h" +#import "RACTuple.h" + +@implementation RACSignal + +#pragma mark Lifecycle + ++ (RACSignal *)createSignal:(RACDisposable * (^)(id<RACSubscriber> subscriber))didSubscribe { + return [RACDynamicSignal createSignal:didSubscribe]; +} + ++ (RACSignal *)error:(NSError *)error { + return [RACErrorSignal error:error]; +} + ++ (RACSignal *)never { + return [[self createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) { + return nil; + }] setNameWithFormat:@"+never"]; +} + ++ (RACSignal *)startEagerlyWithScheduler:(RACScheduler *)scheduler block:(void (^)(id<RACSubscriber> subscriber))block { + NSCParameterAssert(scheduler != nil); + NSCParameterAssert(block != NULL); + + RACSignal *signal = [self startLazilyWithScheduler:scheduler block:block]; + // Subscribe to force the lazy signal to call its block. + [[signal publish] connect]; + return [signal setNameWithFormat:@"+startEagerlyWithScheduler:%@ block:", scheduler]; +} + ++ (RACSignal *)startLazilyWithScheduler:(RACScheduler *)scheduler block:(void (^)(id<RACSubscriber> subscriber))block { + NSCParameterAssert(scheduler != nil); + NSCParameterAssert(block != NULL); + + RACMulticastConnection *connection = [[RACSignal + createSignal:^ id (id<RACSubscriber> subscriber) { + block(subscriber); + return nil; + }] + multicast:[RACReplaySubject subject]]; + + return [[[RACSignal + createSignal:^ id (id<RACSubscriber> subscriber) { + [connection.signal subscribe:subscriber]; + [connection connect]; + return nil; + }] + subscribeOn:scheduler] + setNameWithFormat:@"+startLazilyWithScheduler:%@ block:", scheduler]; +} + +#pragma mark NSObject + +- (NSString *)description { + return [NSString stringWithFormat:@"<%@: %p> name: %@", self.class, self, self.name]; +} + +@end + +@implementation RACSignal (RACStream) + ++ (RACSignal *)empty { + return [RACEmptySignal empty]; +} + ++ (RACSignal *)return:(id)value { + return [RACReturnSignal return:value]; +} + +- (RACSignal *)bind:(RACStreamBindBlock (^)(void))block { + NSCParameterAssert(block != NULL); + + /* + * -bind: should: + * + * 1. Subscribe to the original signal of values. + * 2. Any time the original signal sends a value, transform it using the binding block. + * 3. If the binding block returns a signal, subscribe to it, and pass all of its values through to the subscriber as they're received. + * 4. If the binding block asks the bind to terminate, complete the _original_ signal. + * 5. When _all_ signals complete, send completed to the subscriber. + * + * If any signal sends an error at any point, send that to the subscriber. + */ + + return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) { + RACStreamBindBlock bindingBlock = block(); + + NSMutableArray *signals = [NSMutableArray arrayWithObject:self]; + + RACCompoundDisposable *compoundDisposable = [RACCompoundDisposable compoundDisposable]; + + void (^completeSignal)(RACSignal *, RACDisposable *) = ^(RACSignal *signal, RACDisposable *finishedDisposable) { + BOOL removeDisposable = NO; + + @synchronized (signals) { + [signals removeObject:signal]; + + if (signals.count == 0) { + [subscriber sendCompleted]; + [compoundDisposable dispose]; + } else { + removeDisposable = YES; + } + } + + if (removeDisposable) [compoundDisposable removeDisposable:finishedDisposable]; + }; + + void (^addSignal)(RACSignal *) = ^(RACSignal *signal) { + @synchronized (signals) { + [signals addObject:signal]; + } + + RACSerialDisposable *selfDisposable = [[RACSerialDisposable alloc] init]; + [compoundDisposable addDisposable:selfDisposable]; + + RACDisposable *disposable = [signal subscribeNext:^(id x) { + [subscriber sendNext:x]; + } error:^(NSError *error) { + [compoundDisposable dispose]; + [subscriber sendError:error]; + } completed:^{ + @autoreleasepool { + completeSignal(signal, selfDisposable); + } + }]; + + selfDisposable.disposable = disposable; + }; + + @autoreleasepool { + RACSerialDisposable *selfDisposable = [[RACSerialDisposable alloc] init]; + [compoundDisposable addDisposable:selfDisposable]; + + RACDisposable *bindingDisposable = [self subscribeNext:^(id x) { + BOOL stop = NO; + id signal = bindingBlock(x, &stop); + + @autoreleasepool { + if (signal != nil) addSignal(signal); + if (signal == nil || stop) { + [selfDisposable dispose]; + completeSignal(self, selfDisposable); + } + } + } error:^(NSError *error) { + [compoundDisposable dispose]; + [subscriber sendError:error]; + } completed:^{ + @autoreleasepool { + completeSignal(self, selfDisposable); + } + }]; + + selfDisposable.disposable = bindingDisposable; + } + + return compoundDisposable; + }] setNameWithFormat:@"[%@] -bind:", self.name]; +} + +- (RACSignal *)concat:(RACSignal *)signal { + return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) { + RACSerialDisposable *serialDisposable = [[RACSerialDisposable alloc] init]; + + RACDisposable *sourceDisposable = [self subscribeNext:^(id x) { + [subscriber sendNext:x]; + } error:^(NSError *error) { + [subscriber sendError:error]; + } completed:^{ + RACDisposable *concattedDisposable = [signal subscribe:subscriber]; + serialDisposable.disposable = concattedDisposable; + }]; + + serialDisposable.disposable = sourceDisposable; + return serialDisposable; + }] setNameWithFormat:@"[%@] -concat: %@", self.name, signal]; +} + +- (RACSignal *)zipWith:(RACSignal *)signal { + NSCParameterAssert(signal != nil); + + return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) { + __block BOOL selfCompleted = NO; + NSMutableArray *selfValues = [NSMutableArray array]; + + __block BOOL otherCompleted = NO; + NSMutableArray *otherValues = [NSMutableArray array]; + + void (^sendCompletedIfNecessary)(void) = ^{ + @synchronized (selfValues) { + BOOL selfEmpty = (selfCompleted && selfValues.count == 0); + BOOL otherEmpty = (otherCompleted && otherValues.count == 0); + if (selfEmpty || otherEmpty) [subscriber sendCompleted]; + } + }; + + void (^sendNext)(void) = ^{ + @synchronized (selfValues) { + if (selfValues.count == 0) return; + if (otherValues.count == 0) return; + + RACTuple *tuple = [RACTuple tupleWithObjects:selfValues[0], otherValues[0], nil]; + [selfValues removeObjectAtIndex:0]; + [otherValues removeObjectAtIndex:0]; + + [subscriber sendNext:tuple]; + sendCompletedIfNecessary(); + } + }; + + RACDisposable *selfDisposable = [self subscribeNext:^(id x) { + @synchronized (selfValues) { + [selfValues addObject:x ?: RACTupleNil.tupleNil]; + sendNext(); + } + } error:^(NSError *error) { + [subscriber sendError:error]; + } completed:^{ + @synchronized (selfValues) { + selfCompleted = YES; + sendCompletedIfNecessary(); + } + }]; + + RACDisposable *otherDisposable = [signal subscribeNext:^(id x) { + @synchronized (selfValues) { + [otherValues addObject:x ?: RACTupleNil.tupleNil]; + sendNext(); + } + } error:^(NSError *error) { + [subscriber sendError:error]; + } completed:^{ + @synchronized (selfValues) { + otherCompleted = YES; + sendCompletedIfNecessary(); + } + }]; + + return [RACDisposable disposableWithBlock:^{ + [selfDisposable dispose]; + [otherDisposable dispose]; + }]; + }] setNameWithFormat:@"[%@] -zipWith: %@", self.name, signal]; +} + +@end + +@implementation RACSignal (Subscription) + +- (RACDisposable *)subscribe:(id<RACSubscriber>)subscriber { + NSCAssert(NO, @"This method must be overridden by subclasses"); + return nil; +} + +- (RACDisposable *)subscribeNext:(void (^)(id x))nextBlock { + NSCParameterAssert(nextBlock != NULL); + + RACSubscriber *o = [RACSubscriber subscriberWithNext:nextBlock error:NULL completed:NULL]; + return [self subscribe:o]; +} + +- (RACDisposable *)subscribeNext:(void (^)(id x))nextBlock completed:(void (^)(void))completedBlock { + NSCParameterAssert(nextBlock != NULL); + NSCParameterAssert(completedBlock != NULL); + + RACSubscriber *o = [RACSubscriber subscriberWithNext:nextBlock error:NULL completed:completedBlock]; + return [self subscribe:o]; +} + +- (RACDisposable *)subscribeNext:(void (^)(id x))nextBlock error:(void (^)(NSError *error))errorBlock completed:(void (^)(void))completedBlock { + NSCParameterAssert(nextBlock != NULL); + NSCParameterAssert(errorBlock != NULL); + NSCParameterAssert(completedBlock != NULL); + + RACSubscriber *o = [RACSubscriber subscriberWithNext:nextBlock error:errorBlock completed:completedBlock]; + return [self subscribe:o]; +} + +- (RACDisposable *)subscribeError:(void (^)(NSError *error))errorBlock { + NSCParameterAssert(errorBlock != NULL); + + RACSubscriber *o = [RACSubscriber subscriberWithNext:NULL error:errorBlock completed:NULL]; + return [self subscribe:o]; +} + +- (RACDisposable *)subscribeCompleted:(void (^)(void))completedBlock { + NSCParameterAssert(completedBlock != NULL); + + RACSubscriber *o = [RACSubscriber subscriberWithNext:NULL error:NULL completed:completedBlock]; + return [self subscribe:o]; +} + +- (RACDisposable *)subscribeNext:(void (^)(id x))nextBlock error:(void (^)(NSError *error))errorBlock { + NSCParameterAssert(nextBlock != NULL); + NSCParameterAssert(errorBlock != NULL); + + RACSubscriber *o = [RACSubscriber subscriberWithNext:nextBlock error:errorBlock completed:NULL]; + return [self subscribe:o]; +} + +- (RACDisposable *)subscribeError:(void (^)(NSError *))errorBlock completed:(void (^)(void))completedBlock { + NSCParameterAssert(completedBlock != NULL); + NSCParameterAssert(errorBlock != NULL); + + RACSubscriber *o = [RACSubscriber subscriberWithNext:NULL error:errorBlock completed:completedBlock]; + return [self subscribe:o]; +} + +@end + +@implementation RACSignal (Debugging) + +- (RACSignal *)logAll { + return [[[self logNext] logError] logCompleted]; +} + +- (RACSignal *)logNext { + return [[self doNext:^(id x) { + NSLog(@"%@ next: %@", self, x); + }] setNameWithFormat:@"%@", self.name]; +} + +- (RACSignal *)logError { + return [[self doError:^(NSError *error) { + NSLog(@"%@ error: %@", self, error); + }] setNameWithFormat:@"%@", self.name]; +} + +- (RACSignal *)logCompleted { + return [[self doCompleted:^{ + NSLog(@"%@ completed", self); + }] setNameWithFormat:@"%@", self.name]; +} + +@end + +@implementation RACSignal (Testing) + +static const NSTimeInterval RACSignalAsynchronousWaitTimeout = 10; + +- (id)asynchronousFirstOrDefault:(id)defaultValue success:(BOOL *)success error:(NSError **)error { + NSCAssert([NSThread isMainThread], @"%s should only be used from the main thread", __func__); + + __block id result = defaultValue; + __block BOOL done = NO; + + // Ensures that we don't pass values across thread boundaries by reference. + __block NSError *localError; + __block BOOL localSuccess = YES; + + [[[[self + take:1] + timeout:RACSignalAsynchronousWaitTimeout onScheduler:[RACScheduler scheduler]] + deliverOn:RACScheduler.mainThreadScheduler] + subscribeNext:^(id x) { + result = x; + done = YES; + } error:^(NSError *e) { + if (!done) { + localSuccess = NO; + localError = e; + done = YES; + } + } completed:^{ + done = YES; + }]; + + do { + [NSRunLoop.mainRunLoop runMode:NSDefaultRunLoopMode beforeDate:[NSDate dateWithTimeIntervalSinceNow:0.1]]; + } while (!done); + + if (success != NULL) *success = localSuccess; + if (error != NULL) *error = localError; + + return result; +} + +- (BOOL)asynchronouslyWaitUntilCompleted:(NSError **)error { + BOOL success = NO; + [[self ignoreValues] asynchronousFirstOrDefault:nil success:&success error:error]; + return success; +} + +@end + +@implementation RACSignal (Deprecated) + +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wdeprecated-implementations" + ++ (RACSignal *)startWithScheduler:(RACScheduler *)scheduler subjectBlock:(void (^)(RACSubject *subject))block { + NSCParameterAssert(block != NULL); + + RACReplaySubject *subject = [[RACReplaySubject subject] setNameWithFormat:@"+startWithScheduler:subjectBlock:"]; + + [scheduler schedule:^{ + block(subject); + }]; + + return subject; +} + ++ (RACSignal *)start:(id (^)(BOOL *success, NSError **error))block { + return [[self startWithScheduler:[RACScheduler scheduler] block:block] setNameWithFormat:@"+start:"]; +} + ++ (RACSignal *)startWithScheduler:(RACScheduler *)scheduler block:(id (^)(BOOL *success, NSError **error))block { + return [[self startWithScheduler:scheduler subjectBlock:^(id<RACSubscriber> subscriber) { + BOOL success = YES; + NSError *error = nil; + id returned = block(&success, &error); + + if (!success) { + [subscriber sendError:error]; + } else { + [subscriber sendNext:returned]; + [subscriber sendCompleted]; + } + }] setNameWithFormat:@"+startWithScheduler:block:"]; +} + +#pragma clang diagnostic pop + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACSignalProvider.d b/ReactiveCocoaFramework/ReactiveCocoa/RACSignalProvider.d new file mode 100644 index 0000000..8add9a1 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACSignalProvider.d
@@ -0,0 +1,5 @@ +provider RACSignal { + probe next(char *signal, char *subscriber, char *valueDescription); + probe completed(char *signal, char *subscriber); + probe error(char *signal, char *subscriber, char *errorDescription); +};
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACSignalSequence.h b/ReactiveCocoaFramework/ReactiveCocoa/RACSignalSequence.h new file mode 100644 index 0000000..e3ab77d --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACSignalSequence.h
@@ -0,0 +1,19 @@ +// +// RACSignalSequence.h +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-11-09. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACSequence.h" + +@class RACSignal; + +// Private class that adapts a RACSignal to the RACSequence interface. +@interface RACSignalSequence : RACSequence + +// Returns a sequence for enumerating over the given signal. ++ (RACSequence *)sequenceWithSignal:(RACSignal *)signal; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACSignalSequence.m b/ReactiveCocoaFramework/ReactiveCocoa/RACSignalSequence.m new file mode 100644 index 0000000..52ea1b9 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACSignalSequence.m
@@ -0,0 +1,79 @@ +// +// RACSignalSequence.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-11-09. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACSignalSequence.h" +#import "RACDisposable.h" +#import "RACReplaySubject.h" +#import "RACSignal+Operations.h" + +@interface RACSignalSequence () + +// Replays the signal given on initialization. +@property (nonatomic, strong, readonly) RACReplaySubject *subject; + +@end + +@implementation RACSignalSequence + +#pragma mark Lifecycle + ++ (RACSequence *)sequenceWithSignal:(RACSignal *)signal { + RACSignalSequence *seq = [[self alloc] init]; + + RACReplaySubject *subject = [RACReplaySubject subject]; + [signal subscribeNext:^(id value) { + [subject sendNext:value]; + } error:^(NSError *error) { + [subject sendError:error]; + } completed:^{ + [subject sendCompleted]; + }]; + + seq->_subject = subject; + return seq; +} + +#pragma mark RACSequence + +- (id)head { + id value = [self.subject firstOrDefault:self]; + + if (value == self) { + return nil; + } else { + return value ?: NSNull.null; + } +} + +- (RACSequence *)tail { + RACSequence *sequence = [self.class sequenceWithSignal:[self.subject skip:1]]; + sequence.name = self.name; + return sequence; +} + +- (NSArray *)array { + return self.subject.toArray; +} + +#pragma mark NSObject + +- (NSString *)description { + // Synchronously accumulate the values that have been sent so far. + NSMutableArray *values = [NSMutableArray array]; + RACDisposable *disposable = [self.subject subscribeNext:^(id value) { + @synchronized (values) { + [values addObject:value ?: NSNull.null]; + } + }]; + + [disposable dispose]; + + return [NSString stringWithFormat:@"<%@: %p>{ name = %@, values = %@ … }", self.class, self, self.name, values]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACStream+Private.h b/ReactiveCocoaFramework/ReactiveCocoa/RACStream+Private.h new file mode 100644 index 0000000..f6c0407 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACStream+Private.h
@@ -0,0 +1,23 @@ +// +// RACStream+Private.h +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-07-22. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACStream.h" + +@interface RACStream () + +// Combines a list of streams using the logic of the given block. +// +// streams - The streams to combine. +// block - An operator that combines two streams and returns a new one. The +// returned stream should contain 2-tuples of the streams' combined +// values. +// +// Returns a combined stream. ++ (instancetype)join:(id<NSFastEnumeration>)streams block:(RACStream * (^)(id, id))block; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACStream.h b/ReactiveCocoaFramework/ReactiveCocoa/RACStream.h new file mode 100644 index 0000000..8853ffe --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACStream.h
@@ -0,0 +1,321 @@ +// +// RACStream.h +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-10-31. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import <Foundation/Foundation.h> + +@class RACStream; + +/// A block which accepts a value from a RACStream and returns a new instance +/// of the same stream class. +/// +/// Setting `stop` to `YES` will cause the bind to terminate after the returned +/// value. Returning `nil` will result in immediate termination. +typedef RACStream * (^RACStreamBindBlock)(id value, BOOL *stop); + +/// An abstract class representing any stream of values. +/// +/// This class represents a monad, upon which many stream-based operations can +/// be built. +/// +/// When subclassing RACStream, only the methods in the main @interface body need +/// to be overridden. +@interface RACStream : NSObject + +/// Returns an empty stream. ++ (instancetype)empty; + +/// Lifts `value` into the stream monad. +/// +/// Returns a stream containing only the given value. ++ (instancetype)return:(id)value; + +/// Lazily binds a block to the values in the receiver. +/// +/// This should only be used if you need to terminate the bind early, or close +/// over some state. -flattenMap: is more appropriate for all other cases. +/// +/// block - A block returning a RACStreamBindBlock. This block will be invoked +/// each time the bound stream is re-evaluated. This block must not be +/// nil or return nil. +/// +/// Returns a new stream which represents the combined result of all lazy +/// applications of `block`. +- (instancetype)bind:(RACStreamBindBlock (^)(void))block; + +/// Appends the values of `stream` to the values in the receiver. +/// +/// stream - A stream to concatenate. This must be an instance of the same +/// concrete class as the receiver, and should not be `nil`. +/// +/// Returns a new stream representing the receiver followed by `stream`. +- (instancetype)concat:(RACStream *)stream; + +/// Zips the values in the receiver with those of the given stream to create +/// RACTuples. +/// +/// The first value of each stream will be combined, then the second value, and +/// so forth, until at least one of the streams is exhausted. +/// +/// stream - The stream to zip with. This must be an instance of the same +/// concrete class as the receiver, and should not be `nil`. +/// +/// Returns a new stream of RACTuples, representing the zipped values of the +/// two streams. +- (instancetype)zipWith:(RACStream *)stream; + +@end + +/// This extension contains functionality to support naming streams for +/// debugging. +/// +/// Subclasses do not need to override the methods here. +@interface RACStream () + +/// The name of the stream. This is for debugging/human purposes only. +@property (copy) NSString *name; + +/// Sets the name of the receiver to the given format string. +/// +/// This is for debugging purposes only, and won't do anything unless the +/// RAC_DEBUG_SIGNAL_NAMES environment variable is set. +/// +/// Returns the receiver, for easy method chaining. +- (instancetype)setNameWithFormat:(NSString *)format, ... NS_FORMAT_FUNCTION(1, 2); + +@end + +/// Operations built on the RACStream primitives. +/// +/// These methods do not need to be overridden, although subclasses may +/// occasionally gain better performance from doing so. +@interface RACStream (Operations) + +/// Maps `block` across the values in the receiver and flattens the result. +/// +/// Note that operators applied _after_ -flattenMap: behave differently from +/// operators _within_ -flattenMap:. See the Examples section below. +/// +/// This corresponds to the `SelectMany` method in Rx. +/// +/// block - A block which accepts the values in the receiver and returns a new +/// instance of the receiver's class. Returning `nil` from this block is +/// equivalent to returning an empty signal. +/// +/// Examples +/// +/// [signal flattenMap:^(id x) { +/// // Logs each time a returned signal completes. +/// return [[RACSignal return:x] logCompleted]; +/// }]; +/// +/// [[signal +/// flattenMap:^(id x) { +/// return [RACSignal return:x]; +/// }] +/// // Logs only once, when all of the signals complete. +/// logCompleted]; +/// +/// Returns a new stream which represents the combined streams resulting from +/// mapping `block`. +- (instancetype)flattenMap:(RACStream * (^)(id value))block; + +/// Flattens a stream of streams. +/// +/// This corresponds to the `Merge` method in Rx. +/// +/// Returns a stream consisting of the combined streams obtained from the +/// receiver. +- (instancetype)flatten; + +/// Maps `block` across the values in the receiver. +/// +/// This corresponds to the `Select` method in Rx. +/// +/// Returns a new stream with the mapped values. +- (instancetype)map:(id (^)(id value))block; + +/// Replace each value in the receiver with the given object. +/// +/// Returns a new stream which includes the given object once for each value in +/// the receiver. +- (instancetype)mapReplace:(id)object; + +/// Filters out values in the receiver that don't pass the given test. +/// +/// This corresponds to the `Where` method in Rx. +/// +/// Returns a new stream with only those values that passed. +- (instancetype)filter:(BOOL (^)(id value))block; + +/// Filters out values in the receiver that equal (via -isEqual:) the provided value. +/// +/// value - The value can be `nil`, in which case it ignores `nil` values. +/// +/// Returns a new stream containing only the values which did not compare equal +/// to `value`. +- (instancetype)ignore:(id)value; + +/// Unpacks each RACTuple in the receiver and maps the values to a new value. +/// +/// reduceBlock - The block which reduces each RACTuple's values into one value. +/// It must take as many arguments as the number of tuple elements +/// to process. Each argument will be an object argument. The +/// return value must be an object. This argument cannot be nil. +/// +/// Returns a new stream of reduced tuple values. +- (instancetype)reduceEach:(id (^)())reduceBlock; + +/// Returns a stream consisting of `value`, followed by the values in the +/// receiver. +- (instancetype)startWith:(id)value; + +/// Skips the first `skipCount` values in the receiver. +/// +/// Returns the receiver after skipping the first `skipCount` values. If +/// `skipCount` is greater than the number of values in the stream, an empty +/// stream is returned. +- (instancetype)skip:(NSUInteger)skipCount; + +/// Returns a stream of the first `count` values in the receiver. If `count` is +/// greater than or equal to the number of values in the stream, a stream +/// equivalent to the receiver is returned. +- (instancetype)take:(NSUInteger)count; + +/// Zips the values in the given streams to create RACTuples. +/// +/// The first value of each stream will be combined, then the second value, and +/// so forth, until at least one of the streams is exhausted. +/// +/// streams - The streams to combine. These must all be instances of the same +/// concrete class implementing the protocol. If this collection is +/// empty, the returned stream will be empty. +/// +/// Returns a new stream containing RACTuples of the zipped values from the +/// streams. ++ (instancetype)zip:(id<NSFastEnumeration>)streams; + +/// Zips streams using +zip:, then reduces the resulting tuples into a single +/// value using -reduceEach: +/// +/// streams - The streams to combine. These must all be instances of the +/// same concrete class implementing the protocol. If this +/// collection is empty, the returned stream will be empty. +/// reduceBlock - The block which reduces the values from all the streams +/// into one value. It must take as many arguments as the +/// number of streams given. Each argument will be an object +/// argument. The return value must be an object. This argument +/// must not be nil. +/// +/// Example: +/// +/// [RACStream zip:@[ stringSignal, intSignal ] reduce:^(NSString *string, NSNumber *number) { +/// return [NSString stringWithFormat:@"%@: %@", string, number]; +/// }]; +/// +/// Returns a new stream containing the results from each invocation of +/// `reduceBlock`. ++ (instancetype)zip:(id<NSFastEnumeration>)streams reduce:(id (^)())reduceBlock; + +/// Returns a stream obtained by concatenating `streams` in order. ++ (instancetype)concat:(id<NSFastEnumeration>)streams; + +/// Combines values in the receiver from left to right using the given block. +/// +/// The algorithm proceeds as follows: +/// +/// 1. `startingValue` is passed into the block as the `running` value, and the +/// first element of the receiver is passed into the block as the `next` value. +/// 2. The result of the invocation is added to the returned stream. +/// 3. The result of the invocation (`running`) and the next element of the +/// receiver (`next`) is passed into `block`. +/// 4. Steps 2 and 3 are repeated until all values have been processed. +/// +/// startingValue - The value to be combined with the first element of the +/// receiver. This value may be `nil`. +/// block - A block that describes how to combine values of the +/// receiver. If the receiver is empty, this block will never be +/// invoked. +/// +/// Examples +/// +/// RACSequence *numbers = @[ @1, @2, @3, @4 ].rac_sequence; +/// +/// // Contains 1, 3, 6, 10 +/// RACSequence *sums = [numbers scanWithStart:@0 reduce:^(NSNumber *sum, NSNumber *next) { +/// return @(sum.integerValue + next.integerValue); +/// }]; +/// +/// Returns a new stream that consists of each application of `block`. If the +/// receiver is empty, an empty stream is returned. +- (instancetype)scanWithStart:(id)startingValue reduce:(id (^)(id running, id next))block; + +/// Combines each previous and current value into one object. +/// +/// This method is similar to -scanWithStart:reduce:, but only ever operates on +/// the previous and current values (instead of the whole stream), and does not +/// pass the return value of `reduceBlock` into the next invocation of it. +/// +/// start - The value passed into `reduceBlock` as `previous` for the +/// first value. +/// reduceBlock - The block that combines the previous value and the current +/// value to create the reduced value. Cannot be nil. +/// +/// Examples +/// +/// RACSequence *numbers = @[ @1, @2, @3, @4 ].rac_sequence; +/// +/// // Contains 1, 3, 5, 7 +/// RACSequence *sums = [numbers combinePreviousWithStart:@0 reduce:^(NSNumber *previous, NSNumber *next) { +/// return @(previous.integerValue + next.integerValue); +/// }]; +/// +/// Returns a new stream consisting of the return values from each application of +/// `reduceBlock`. +- (instancetype)combinePreviousWithStart:(id)start reduce:(id (^)(id previous, id current))reduceBlock; + +/// Takes values until the given block returns `YES`. +/// +/// Returns a stream of the initial values in the receiver that fail `predicate`. +/// If `predicate` never returns `YES`, a stream equivalent to the receiver is +/// returned. +- (instancetype)takeUntilBlock:(BOOL (^)(id x))predicate; + +/// Takes values until the given block returns `NO`. +/// +/// Returns a stream of the initial values in the receiver that pass `predicate`. +/// If `predicate` never returns `NO`, a stream equivalent to the receiver is +/// returned. +- (instancetype)takeWhileBlock:(BOOL (^)(id x))predicate; + +/// Skips values until the given block returns `YES`. +/// +/// Returns a stream containing the values of the receiver that follow any +/// initial values failing `predicate`. If `predicate` never returns `YES`, +/// an empty stream is returned. +- (instancetype)skipUntilBlock:(BOOL (^)(id x))predicate; + +/// Skips values until the given block returns `NO`. +/// +/// Returns a stream containing the values of the receiver that follow any +/// initial values passing `predicate`. If `predicate` never returns `NO`, an +/// empty stream is returned. +- (instancetype)skipWhileBlock:(BOOL (^)(id x))predicate; + +/// Returns a stream of values for which -isEqual: returns NO when compared to the +/// previous value. +- (instancetype)distinctUntilChanged; + +@end + +@interface RACStream (Deprecated) + +- (instancetype)sequenceMany:(RACStream * (^)(void))block __attribute__((deprecated("Use -flattenMap: instead"))); +- (instancetype)scanWithStart:(id)startingValue combine:(id (^)(id running, id next))block __attribute__((deprecated("Renamed to -scanWithStart:reduce:"))); +- (instancetype)mapPreviousWithStart:(id)start reduce:(id (^)(id previous, id current))combineBlock __attribute__((deprecated("Renamed to -combinePreviousWithStart:reduce:"))); + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACStream.m b/ReactiveCocoaFramework/ReactiveCocoa/RACStream.m new file mode 100644 index 0000000..7c37c69 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACStream.m
@@ -0,0 +1,362 @@ +// +// RACStream.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-10-31. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACStream.h" +#import "NSObject+RACDescription.h" +#import "RACBlockTrampoline.h" +#import "RACTuple.h" + +@implementation RACStream + +#pragma mark Lifecycle + +- (id)init { + self = [super init]; + if (self == nil) return nil; + + self.name = @""; + return self; +} + +#pragma mark Abstract methods + ++ (instancetype)empty { + return nil; +} + +- (instancetype)bind:(RACStreamBindBlock (^)(void))block { + return nil; +} + ++ (instancetype)return:(id)value { + return nil; +} + +- (instancetype)concat:(RACStream *)stream { + return nil; +} + +- (instancetype)zipWith:(RACStream *)stream { + return nil; +} + +#pragma mark Naming + +- (instancetype)setNameWithFormat:(NSString *)format, ... { + if (getenv("RAC_DEBUG_SIGNAL_NAMES") == NULL) return self; + + NSCParameterAssert(format != nil); + + va_list args; + va_start(args, format); + + NSString *str = [[NSString alloc] initWithFormat:format arguments:args]; + va_end(args); + + self.name = str; + return self; +} + +@end + +@implementation RACStream (Operations) + +- (instancetype)flattenMap:(RACStream * (^)(id value))block { + Class class = self.class; + + return [[self bind:^{ + return ^(id value, BOOL *stop) { + id stream = block(value) ?: [class empty]; + NSCAssert([stream isKindOfClass:RACStream.class], @"Value returned from -flattenMap: is not a stream: %@", stream); + + return stream; + }; + }] setNameWithFormat:@"[%@] -flattenMap:", self.name]; +} + +- (instancetype)flatten { + __weak RACStream *stream __attribute__((unused)) = self; + return [[self flattenMap:^(id value) { + return value; + }] setNameWithFormat:@"[%@] -flatten", self.name]; +} + +- (instancetype)map:(id (^)(id value))block { + NSCParameterAssert(block != nil); + + Class class = self.class; + + return [[self flattenMap:^(id value) { + return [class return:block(value)]; + }] setNameWithFormat:@"[%@] -map:", self.name]; +} + +- (instancetype)mapReplace:(id)object { + return [[self map:^(id _) { + return object; + }] setNameWithFormat:@"[%@] -mapReplace: %@", self.name, [object rac_description]]; +} + +- (instancetype)combinePreviousWithStart:(id)start reduce:(id (^)(id previous, id next))reduceBlock { + NSCParameterAssert(reduceBlock != NULL); + return [[[self + scanWithStart:[RACTuple tupleWithObjects:start, nil] + reduce:^(RACTuple *previousTuple, id next) { + id value = reduceBlock(previousTuple[0], next); + return [RACTuple tupleWithObjects:next ?: RACTupleNil.tupleNil, value ?: RACTupleNil.tupleNil, nil]; + }] + map:^(RACTuple *tuple) { + return tuple[1]; + }] + setNameWithFormat:@"[%@] -combinePreviousWithStart: %@ reduce:", self.name, [start rac_description]]; +} + +- (instancetype)filter:(BOOL (^)(id value))block { + NSCParameterAssert(block != nil); + + Class class = self.class; + + return [[self flattenMap:^ id (id value) { + if (block(value)) { + return [class return:value]; + } else { + return class.empty; + } + }] setNameWithFormat:@"[%@] -filter:", self.name]; +} + +- (instancetype)ignore:(id)value { + return [[self filter:^ BOOL (id innerValue) { + return innerValue != value && ![innerValue isEqual:value]; + }] setNameWithFormat:@"[%@] -ignore: %@", self.name, [value rac_description]]; +} + +- (instancetype)reduceEach:(id (^)())reduceBlock { + NSCParameterAssert(reduceBlock != nil); + + __weak RACStream *stream __attribute__((unused)) = self; + return [[self map:^(RACTuple *t) { + NSCAssert([t isKindOfClass:RACTuple.class], @"Value from stream %@ is not a tuple: %@", stream, t); + return [RACBlockTrampoline invokeBlock:reduceBlock withArguments:t]; + }] setNameWithFormat:@"[%@] -reduceEach:", self.name]; +} + +- (instancetype)startWith:(id)value { + return [[[self.class return:value] + concat:self] + setNameWithFormat:@"[%@] -startWith: %@", self.name, [value rac_description]]; +} + +- (instancetype)skip:(NSUInteger)skipCount { + Class class = self.class; + + return [[self bind:^{ + __block NSUInteger skipped = 0; + + return ^(id value, BOOL *stop) { + if (skipped >= skipCount) return [class return:value]; + + skipped++; + return class.empty; + }; + }] setNameWithFormat:@"[%@] -skip: %lu", self.name, (unsigned long)skipCount]; +} + +- (instancetype)take:(NSUInteger)count { + Class class = self.class; + + return [[self bind:^{ + __block NSUInteger taken = 0; + + return ^ id (id value, BOOL *stop) { + RACStream *result = class.empty; + + if (taken < count) result = [class return:value]; + if (++taken >= count) *stop = YES; + + return result; + }; + }] setNameWithFormat:@"[%@] -take: %lu", self.name, (unsigned long)count]; +} + ++ (instancetype)join:(id<NSFastEnumeration>)streams block:(RACStream * (^)(id, id))block { + RACStream *current = nil; + + // Creates streams of successively larger tuples by combining the input + // streams one-by-one. + for (RACStream *stream in streams) { + // For the first stream, just wrap its values in a RACTuple. That way, + // if only one stream is given, the result is still a stream of tuples. + if (current == nil) { + current = [stream map:^(id x) { + return RACTuplePack(x); + }]; + + continue; + } + + current = block(current, stream); + } + + if (current == nil) return [self empty]; + + return [current map:^(RACTuple *xs) { + // Right now, each value is contained in its own tuple, sorta like: + // + // (((1), 2), 3) + // + // We need to unwrap all the layers and create a tuple out of the result. + NSMutableArray *values = [[NSMutableArray alloc] init]; + + while (xs != nil) { + [values insertObject:xs.last ?: RACTupleNil.tupleNil atIndex:0]; + xs = (xs.count > 1 ? xs.first : nil); + } + + return [RACTuple tupleWithObjectsFromArray:values]; + }]; +} + ++ (instancetype)zip:(id<NSFastEnumeration>)streams { + return [[self join:streams block:^(RACStream *left, RACStream *right) { + return [left zipWith:right]; + }] setNameWithFormat:@"+zip: %@", streams]; +} + ++ (instancetype)zip:(id<NSFastEnumeration>)streams reduce:(id (^)())reduceBlock { + NSCParameterAssert(reduceBlock != nil); + + RACStream *result = [self zip:streams]; + + // Although we assert this condition above, older versions of this method + // supported this argument being nil. Avoid crashing Release builds of + // apps that depended on that. + if (reduceBlock != nil) result = [result reduceEach:reduceBlock]; + + return [result setNameWithFormat:@"+zip: %@ reduce:", streams]; +} + ++ (instancetype)concat:(id<NSFastEnumeration>)streams { + RACStream *result = self.empty; + for (RACStream *stream in streams) { + result = [result concat:stream]; + } + + return [result setNameWithFormat:@"+concat: %@", streams]; +} + +- (instancetype)scanWithStart:(id)startingValue reduce:(id (^)(id running, id next))block { + NSCParameterAssert(block != nil); + + Class class = self.class; + + return [[self bind:^{ + __block id running = startingValue; + + return ^(id value, BOOL *stop) { + running = block(running, value); + return [class return:running]; + }; + }] setNameWithFormat:@"[%@] -scanWithStart: %@ reduce:", self.name, [startingValue rac_description]]; +} + +- (instancetype)takeUntilBlock:(BOOL (^)(id x))predicate { + NSCParameterAssert(predicate != nil); + + Class class = self.class; + + return [[self bind:^{ + return ^ id (id value, BOOL *stop) { + if (predicate(value)) return nil; + + return [class return:value]; + }; + }] setNameWithFormat:@"[%@] -takeUntilBlock:", self.name]; +} + +- (instancetype)takeWhileBlock:(BOOL (^)(id x))predicate { + NSCParameterAssert(predicate != nil); + + return [[self takeUntilBlock:^ BOOL (id x) { + return !predicate(x); + }] setNameWithFormat:@"[%@] -takeWhileBlock:", self.name]; +} + +- (instancetype)skipUntilBlock:(BOOL (^)(id x))predicate { + NSCParameterAssert(predicate != nil); + + Class class = self.class; + + return [[self bind:^{ + __block BOOL skipping = YES; + + return ^ id (id value, BOOL *stop) { + if (skipping) { + if (predicate(value)) { + skipping = NO; + } else { + return class.empty; + } + } + + return [class return:value]; + }; + }] setNameWithFormat:@"[%@] -skipUntilBlock:", self.name]; +} + +- (instancetype)skipWhileBlock:(BOOL (^)(id x))predicate { + NSCParameterAssert(predicate != nil); + + return [[self skipUntilBlock:^ BOOL (id x) { + return !predicate(x); + }] setNameWithFormat:@"[%@] -skipUntilBlock:", self.name]; +} + +- (instancetype)distinctUntilChanged { + Class class = self.class; + + return [[self bind:^{ + __block id lastValue = nil; + __block BOOL initial = YES; + + return ^(id x, BOOL *stop) { + if (!initial && (lastValue == x || [x isEqual:lastValue])) return [class empty]; + + initial = NO; + lastValue = x; + return [class return:x]; + }; + }] setNameWithFormat:@"[%@] -distinctUntilChanged", self.name]; +} + +@end + +@implementation RACStream (Deprecated) + +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wdeprecated-implementations" + +- (instancetype)sequenceMany:(RACStream * (^)(void))block { + NSCParameterAssert(block != NULL); + + return [[self flattenMap:^(id _) { + return block(); + }] setNameWithFormat:@"[%@] -sequenceMany:", self.name]; +} + +- (instancetype)scanWithStart:(id)startingValue combine:(id (^)(id running, id next))block { + return [self scanWithStart:startingValue reduce:block]; +} + +- (instancetype)mapPreviousWithStart:(id)start reduce:(id (^)(id previous, id current))combineBlock { + return [self combinePreviousWithStart:start reduce:combineBlock]; +} + +#pragma clang diagnostic pop + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACStringSequence.h b/ReactiveCocoaFramework/ReactiveCocoa/RACStringSequence.h new file mode 100644 index 0000000..b37ddea --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACStringSequence.h
@@ -0,0 +1,18 @@ +// +// RACStringSequence.h +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-10-29. +// Copyright (c) 2012 GitHub. All rights reserved. +// + +#import "RACSequence.h" + +// Private class that adapts a string to the RACSequence interface. +@interface RACStringSequence : RACSequence + +// Returns a sequence for enumerating over the given string, starting from the +// given character offset. The string will be copied to prevent mutation. ++ (RACSequence *)sequenceWithString:(NSString *)string offset:(NSUInteger)offset; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACStringSequence.m b/ReactiveCocoaFramework/ReactiveCocoa/RACStringSequence.m new file mode 100644 index 0000000..dd10f3c --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACStringSequence.m
@@ -0,0 +1,65 @@ +// +// RACStringSequence.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-10-29. +// Copyright (c) 2012 GitHub. All rights reserved. +// + +#import "RACStringSequence.h" + +@interface RACStringSequence () + +// The string being sequenced. +@property (nonatomic, copy, readonly) NSString *string; + +// The index in the string from which the sequence starts. +@property (nonatomic, assign, readonly) NSUInteger offset; + +@end + +@implementation RACStringSequence + +#pragma mark Lifecycle + ++ (RACSequence *)sequenceWithString:(NSString *)string offset:(NSUInteger)offset { + NSCParameterAssert(offset <= string.length); + + if (offset == string.length) return self.empty; + + RACStringSequence *seq = [[self alloc] init]; + seq->_string = [string copy]; + seq->_offset = offset; + return seq; +} + +#pragma mark RACSequence + +- (id)head { + return [self.string substringWithRange:NSMakeRange(self.offset, 1)]; +} + +- (RACSequence *)tail { + RACSequence *sequence = [self.class sequenceWithString:self.string offset:self.offset + 1]; + sequence.name = self.name; + return sequence; +} + +- (NSArray *)array { + NSUInteger substringLength = self.string.length - self.offset; + NSMutableArray *array = [NSMutableArray arrayWithCapacity:substringLength]; + + [self.string enumerateSubstringsInRange:NSMakeRange(self.offset, substringLength) options:NSStringEnumerationByComposedCharacterSequences usingBlock:^(NSString *substring, NSRange substringRange, NSRange enclosingRange, BOOL *stop) { + [array addObject:substring]; + }]; + + return [array copy]; +} + +#pragma mark NSObject + +- (NSString *)description { + return [NSString stringWithFormat:@"<%@: %p>{ name = %@, string = %@ }", self.class, self, self.name, [self.string substringFromIndex:self.offset]]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACSubject.h b/ReactiveCocoaFramework/ReactiveCocoa/RACSubject.h new file mode 100644 index 0000000..30c100b --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACSubject.h
@@ -0,0 +1,22 @@ +// +// RACSubject.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 3/9/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACSignal.h" +#import "RACSubscriber.h" + +/// A subject can be thought of as a signal that you can manually control by +/// sending next, completed, and error. +/// +/// They're most helpful in bridging the non-RAC world to RAC, since they let you +/// manually control the sending of events. +@interface RACSubject : RACSignal <RACSubscriber> + +/// Returns a new subject. ++ (instancetype)subject; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACSubject.m b/ReactiveCocoaFramework/ReactiveCocoa/RACSubject.m new file mode 100644 index 0000000..fa9ba7d --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACSubject.m
@@ -0,0 +1,124 @@ +// +// RACSubject.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 3/9/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACSubject.h" +#import "EXTScope.h" +#import "RACCompoundDisposable.h" +#import "RACPassthroughSubscriber.h" + +@interface RACSubject () + +// Contains all current subscribers to the receiver. +// +// This should only be used while synchronized on `self`. +@property (nonatomic, strong, readonly) NSMutableArray *subscribers; + +// Contains all of the receiver's subscriptions to other signals. +@property (nonatomic, strong, readonly) RACCompoundDisposable *disposable; + +// Enumerates over each of the receiver's `subscribers` and invokes `block` for +// each. +- (void)enumerateSubscribersUsingBlock:(void (^)(id<RACSubscriber> subscriber))block; + +@end + +@implementation RACSubject + +#pragma mark Lifecycle + ++ (instancetype)subject { + return [[self alloc] init]; +} + +- (id)init { + self = [super init]; + if (self == nil) return nil; + + _disposable = [RACCompoundDisposable compoundDisposable]; + _subscribers = [[NSMutableArray alloc] initWithCapacity:1]; + + return self; +} + +- (void)dealloc { + [self.disposable dispose]; +} + +#pragma mark Subscription + +- (RACDisposable *)subscribe:(id<RACSubscriber>)subscriber { + NSCParameterAssert(subscriber != nil); + + RACCompoundDisposable *disposable = [RACCompoundDisposable compoundDisposable]; + subscriber = [[RACPassthroughSubscriber alloc] initWithSubscriber:subscriber signal:self disposable:disposable]; + + NSMutableArray *subscribers = self.subscribers; + @synchronized (subscribers) { + [subscribers addObject:subscriber]; + } + + return [RACDisposable disposableWithBlock:^{ + @synchronized (subscribers) { + // Since newer subscribers are generally shorter-lived, search + // starting from the end of the list. + NSUInteger index = [subscribers indexOfObjectWithOptions:NSEnumerationReverse passingTest:^ BOOL (id<RACSubscriber> obj, NSUInteger index, BOOL *stop) { + return obj == subscriber; + }]; + + if (index != NSNotFound) [subscribers removeObjectAtIndex:index]; + } + }]; +} + +- (void)enumerateSubscribersUsingBlock:(void (^)(id<RACSubscriber> subscriber))block { + NSArray *subscribers; + @synchronized (self.subscribers) { + subscribers = [self.subscribers copy]; + } + + for (id<RACSubscriber> subscriber in subscribers) { + block(subscriber); + } +} + +#pragma mark RACSubscriber + +- (void)sendNext:(id)value { + [self enumerateSubscribersUsingBlock:^(id<RACSubscriber> subscriber) { + [subscriber sendNext:value]; + }]; +} + +- (void)sendError:(NSError *)error { + [self.disposable dispose]; + + [self enumerateSubscribersUsingBlock:^(id<RACSubscriber> subscriber) { + [subscriber sendError:error]; + }]; +} + +- (void)sendCompleted { + [self.disposable dispose]; + + [self enumerateSubscribersUsingBlock:^(id<RACSubscriber> subscriber) { + [subscriber sendCompleted]; + }]; +} + +- (void)didSubscribeWithDisposable:(RACCompoundDisposable *)d { + if (d.disposed) return; + [self.disposable addDisposable:d]; + + @weakify(self, d); + [d addDisposable:[RACDisposable disposableWithBlock:^{ + @strongify(self, d); + [self.disposable removeDisposable:d]; + }]]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriber+Private.h b/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriber+Private.h new file mode 100644 index 0000000..0ad81d2 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriber+Private.h
@@ -0,0 +1,17 @@ +// +// RACSubscriber+Private.h +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-06-13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACSubscriber.h" + +// A simple block-based subscriber. +@interface RACSubscriber : NSObject <RACSubscriber> + +// Creates a new subscriber with the given blocks. ++ (instancetype)subscriberWithNext:(void (^)(id x))next error:(void (^)(NSError *error))error completed:(void (^)(void))completed; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriber.h b/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriber.h new file mode 100644 index 0000000..173e6dc --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriber.h
@@ -0,0 +1,51 @@ +// +// RACSubscriber.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 3/1/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import <Foundation/Foundation.h> + +@class RACCompoundDisposable; + +/// Represents any object which can directly receive values from a RACSignal. +/// +/// You generally shouldn't need to implement this protocol. +[RACSignal +/// createSignal:], RACSignal's subscription methods, or RACSubject should work +/// for most uses. +/// +/// Implementors of this protocol may receive messages and values from multiple +/// threads simultaneously, and so should be thread-safe. Subscribers will also +/// be weakly referenced so implementations must allow that. +@protocol RACSubscriber <NSObject> +@required + +/// Send the next value to subscribers. +/// +/// value - The value to send. This can be `nil`. +- (void)sendNext:(id)value; + +/// Send the error to subscribers. +/// +/// error - The error to send. This can be `nil`. +/// +/// This terminates the subscription, and invalidates the subscriber (such that +/// it cannot subscribe to anything else in the future). +- (void)sendError:(NSError *)error; + +/// Send completed to subscribers. +/// +/// This terminates the subscription, and invalidates the subscriber (such that +/// it cannot subscribe to anything else in the future). +- (void)sendCompleted; + +/// Sends the subscriber a disposable that represents one of its subscriptions. +/// +/// A subscriber may receive multiple disposables if it gets subscribed to +/// multiple signals; however, any error or completed events must terminate _all_ +/// subscriptions. +- (void)didSubscribeWithDisposable:(RACCompoundDisposable *)disposable; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriber.m b/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriber.m new file mode 100644 index 0000000..b9e83f0 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriber.m
@@ -0,0 +1,108 @@ +// +// RACSubscriber.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 3/1/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACSubscriber.h" +#import "RACSubscriber+Private.h" +#import "EXTScope.h" +#import "RACCompoundDisposable.h" + +@interface RACSubscriber () + +// These callbacks should only be accessed while synchronized on self. +@property (nonatomic, copy) void (^next)(id value); +@property (nonatomic, copy) void (^error)(NSError *error); +@property (nonatomic, copy) void (^completed)(void); + +@property (nonatomic, strong, readonly) RACCompoundDisposable *disposable; + +@end + +@implementation RACSubscriber + +#pragma mark Lifecycle + ++ (instancetype)subscriberWithNext:(void (^)(id x))next error:(void (^)(NSError *error))error completed:(void (^)(void))completed { + RACSubscriber *subscriber = [[self alloc] init]; + + subscriber->_next = [next copy]; + subscriber->_error = [error copy]; + subscriber->_completed = [completed copy]; + + return subscriber; +} + +- (id)init { + self = [super init]; + if (self == nil) return nil; + + @weakify(self); + + RACDisposable *selfDisposable = [RACDisposable disposableWithBlock:^{ + @strongify(self); + if (self == nil) return; + + @synchronized (self) { + self.next = nil; + self.error = nil; + self.completed = nil; + } + }]; + + _disposable = [RACCompoundDisposable compoundDisposable]; + [_disposable addDisposable:selfDisposable]; + + return self; +} + +- (void)dealloc { + [self.disposable dispose]; +} + +#pragma mark RACSubscriber + +- (void)sendNext:(id)value { + @synchronized (self) { + void (^nextBlock)(id) = [self.next copy]; + if (nextBlock == nil) return; + + nextBlock(value); + } +} + +- (void)sendError:(NSError *)e { + @synchronized (self) { + void (^errorBlock)(NSError *) = [self.error copy]; + [self.disposable dispose]; + + if (errorBlock == nil) return; + errorBlock(e); + } +} + +- (void)sendCompleted { + @synchronized (self) { + void (^completedBlock)(void) = [self.completed copy]; + [self.disposable dispose]; + + if (completedBlock == nil) return; + completedBlock(); + } +} + +- (void)didSubscribeWithDisposable:(RACCompoundDisposable *)d { + if (d.disposed) return; + [self.disposable addDisposable:d]; + + @weakify(self, d); + [d addDisposable:[RACDisposable disposableWithBlock:^{ + @strongify(self, d); + [self.disposable removeDisposable:d]; + }]]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriptingAssignmentTrampoline.h b/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriptingAssignmentTrampoline.h new file mode 100644 index 0000000..8987731 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriptingAssignmentTrampoline.h
@@ -0,0 +1,54 @@ +// +// RACSubscriptingAssignmentTrampoline.h +// iOSDemo +// +// Created by Josh Abernathy on 9/24/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import <Foundation/Foundation.h> +#import "EXTKeyPathCoding.h" + +@class RACSignal; + +/// Assigns a signal to an object property, automatically setting the given key +/// path on every `next`. When the signal completes, the binding is automatically +/// disposed of. +/// +/// There are two different versions of this macro: +/// +/// - RAC(TARGET, KEYPATH, NILVALUE) will bind the `KEYPATH` of `TARGET` to the +/// given signal. If the signal ever sends a `nil` value, the property will be +/// set to `NILVALUE` instead. `NILVALUE` may itself be `nil` for object +/// properties, but an NSValue should be used for primitive properties, to +/// avoid an exception if `nil` is sent (which might occur if an intermediate +/// object is set to `nil`). +/// - RAC(TARGET, KEYPATH) is the same as the above, but `NILVALUE` defaults to +/// `nil`. +/// +/// See -[RACSignal setKeyPath:onObject:nilValue:] for more information about the +/// binding's semantics. +/// +/// Examples +/// +/// RAC(self, objectProperty) = objectSignal; +/// RAC(self, stringProperty, @"foobar") = stringSignal; +/// RAC(self, integerProperty, @42) = integerSignal; +/// +/// WARNING: Under certain conditions, use of this macro can be thread-unsafe. +/// See the documentation of -setKeyPath:onObject:nilValue:. +#define RAC(TARGET, ...) \ + metamacro_if_eq(1, metamacro_argcount(__VA_ARGS__)) \ + (RAC_(TARGET, __VA_ARGS__, nil)) \ + (RAC_(TARGET, __VA_ARGS__)) + +/// Do not use this directly. Use the RAC macro above. +#define RAC_(TARGET, KEYPATH, NILVALUE) \ + [[RACSubscriptingAssignmentTrampoline alloc] initWithTarget:(TARGET) nilValue:(NILVALUE)][@keypath(TARGET, KEYPATH)] + +@interface RACSubscriptingAssignmentTrampoline : NSObject + +- (id)initWithTarget:(id)target nilValue:(id)nilValue; +- (void)setObject:(RACSignal *)signal forKeyedSubscript:(NSString *)keyPath; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriptingAssignmentTrampoline.m b/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriptingAssignmentTrampoline.m new file mode 100644 index 0000000..2ab8cd3 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriptingAssignmentTrampoline.m
@@ -0,0 +1,42 @@ +// +// RACSubscriptingAssignmentTrampoline.m +// iOSDemo +// +// Created by Josh Abernathy on 9/24/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACSubscriptingAssignmentTrampoline.h" +#import "RACSignal+Operations.h" + +@interface RACSubscriptingAssignmentTrampoline () + +// The object to bind to. +@property (nonatomic, strong, readonly) id target; + +// A value to use when `nil` is sent on the bound signal. +@property (nonatomic, strong, readonly) id nilValue; + +@end + +@implementation RACSubscriptingAssignmentTrampoline + +- (id)initWithTarget:(id)target nilValue:(id)nilValue { + // This is often a programmer error, but this prevents crashes if the target + // object has unexpectedly deallocated. + if (target == nil) return nil; + + self = [super init]; + if (self == nil) return nil; + + _target = target; + _nilValue = nilValue; + + return self; +} + +- (void)setObject:(RACSignal *)signal forKeyedSubscript:(NSString *)keyPath { + [signal setKeyPath:keyPath onObject:self.target nilValue:self.nilValue]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriptionScheduler.h b/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriptionScheduler.h new file mode 100644 index 0000000..34f5dc5 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriptionScheduler.h
@@ -0,0 +1,15 @@ +// +// RACSubscriptionScheduler.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 11/30/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACScheduler.h" + +// A private scheduler used only for subscriptions. See the private +// +[RACScheduler subscriptionScheduler] method for more information. +@interface RACSubscriptionScheduler : RACScheduler + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriptionScheduler.m b/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriptionScheduler.m new file mode 100644 index 0000000..2aab9c3 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACSubscriptionScheduler.m
@@ -0,0 +1,54 @@ +// +// RACSubscriptionScheduler.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 11/30/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACSubscriptionScheduler.h" +#import "RACScheduler+Private.h" + +@interface RACSubscriptionScheduler () + +// A private background scheduler on which to subscribe if the +currentScheduler +// is unknown. +@property (nonatomic, strong, readonly) RACScheduler *backgroundScheduler; + +@end + +@implementation RACSubscriptionScheduler + +#pragma mark Lifecycle + +- (id)init { + self = [super initWithName:@"com.ReactiveCocoa.RACScheduler.subscriptionScheduler"]; + if (self == nil) return nil; + + _backgroundScheduler = [RACScheduler scheduler]; + + return self; +} + +#pragma mark RACScheduler + +- (RACDisposable *)schedule:(void (^)(void))block { + NSCParameterAssert(block != NULL); + + if (RACScheduler.currentScheduler == nil) return [self.backgroundScheduler schedule:block]; + + block(); + return nil; +} + +- (RACDisposable *)after:(NSDate *)date schedule:(void (^)(void))block { + RACScheduler *scheduler = RACScheduler.currentScheduler ?: self.backgroundScheduler; + return [scheduler after:date schedule:block]; +} + +- (RACDisposable *)after:(NSDate *)date repeatingEvery:(NSTimeInterval)interval withLeeway:(NSTimeInterval)leeway schedule:(void (^)(void))block { + RACScheduler *scheduler = RACScheduler.currentScheduler ?: self.backgroundScheduler; + return [scheduler after:date repeatingEvery:interval withLeeway:leeway schedule:block]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACTargetQueueScheduler.h b/ReactiveCocoaFramework/ReactiveCocoa/RACTargetQueueScheduler.h new file mode 100644 index 0000000..429e595 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACTargetQueueScheduler.h
@@ -0,0 +1,24 @@ +// +// RACTargetQueueScheduler.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 6/6/13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACQueueScheduler.h" + +/// A scheduler that enqueues blocks on a private serial queue, targeting an +/// arbitrary GCD queue. +@interface RACTargetQueueScheduler : RACQueueScheduler + +/// Initializes the receiver with a serial queue that will target the given +/// `targetQueue`. +/// +/// name - The name of the scheduler. If nil, a default name will be used. +/// targetQueue - The queue to target. Cannot be NULL. +/// +/// Returns the initialized object. +- (id)initWithName:(NSString *)name targetQueue:(dispatch_queue_t)targetQueue; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACTargetQueueScheduler.m b/ReactiveCocoaFramework/ReactiveCocoa/RACTargetQueueScheduler.m new file mode 100644 index 0000000..65114d3 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACTargetQueueScheduler.m
@@ -0,0 +1,37 @@ +// +// RACTargetQueueScheduler.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 6/6/13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACTargetQueueScheduler.h" +#import "RACBacktrace.h" +#import "RACQueueScheduler+Subclass.h" + +@implementation RACTargetQueueScheduler + +#pragma mark Lifecycle + +- (id)initWithName:(NSString *)name targetQueue:(dispatch_queue_t)targetQueue { + NSCParameterAssert(targetQueue != NULL); + + if (name == nil) { + name = [NSString stringWithFormat:@"com.ReactiveCocoa.RACTargetQueueScheduler(%s)", dispatch_queue_get_label(targetQueue)]; + } + + dispatch_queue_t queue = dispatch_queue_create(name.UTF8String, DISPATCH_QUEUE_SERIAL); + if (queue == NULL) return nil; + + dispatch_set_target_queue(queue, targetQueue); + + self = [super initWithName:name queue:queue]; + if (self == nil) return nil; + + dispatch_release(queue); + + return self; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACTestScheduler.h b/ReactiveCocoaFramework/ReactiveCocoa/RACTestScheduler.h new file mode 100644 index 0000000..a790f5b --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACTestScheduler.h
@@ -0,0 +1,42 @@ +// +// RACTestScheduler.h +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-07-06. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACScheduler.h" + +/// A special kind of scheduler that steps through virtualized time. +/// +/// This scheduler class can be used in unit tests to verify asynchronous +/// behaviors without spending significant time waiting. +/// +/// This class can be used from multiple threads, but only one thread can `step` +/// through the enqueued actions at a time. Other threads will wait while the +/// scheduled blocks are being executed. +@interface RACTestScheduler : RACScheduler + +/// Initializes a new test scheduler. +- (instancetype)init; + +/// Executes the next scheduled block, if any. +/// +/// This method will block until the scheduled action has completed. +- (void)step; + +/// Executes up to the next `ticks` scheduled blocks. +/// +/// This method will block until the scheduled actions have completed. +/// +/// ticks - The number of scheduled blocks to execute. If there aren't this many +/// blocks enqueued, all scheduled blocks are executed. +- (void)step:(NSUInteger)ticks; + +/// Executes all of the scheduled blocks on the receiver. +/// +/// This method will block until the scheduled actions have completed. +- (void)stepAll; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACTestScheduler.m b/ReactiveCocoaFramework/ReactiveCocoa/RACTestScheduler.m new file mode 100644 index 0000000..b6997b2 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACTestScheduler.m
@@ -0,0 +1,223 @@ +// +// RACTestScheduler.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-07-06. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACTestScheduler.h" +#import "EXTScope.h" +#import "RACCompoundDisposable.h" +#import "RACDisposable.h" +#import "RACScheduler+Private.h" + +@interface RACTestSchedulerAction : NSObject + +// The date at which the action should be executed. +// +// This absolute time will not actually be honored. This date is only used for +// comparison, to determine which block should be run _next_. +@property (nonatomic, copy, readonly) NSDate *date; + +// The scheduled block. +@property (nonatomic, copy, readonly) void (^block)(void); + +// A disposable for this action. +// +// When disposed, the action should not start executing if it hasn't already. +@property (nonatomic, strong, readonly) RACDisposable *disposable; + +// Initializes a new scheduler action. +- (id)initWithDate:(NSDate *)date block:(void (^)(void))block; + +@end + +static CFComparisonResult RACCompareScheduledActions(const void *ptr1, const void *ptr2, void *info) { + RACTestSchedulerAction *action1 = (__bridge id)ptr1; + RACTestSchedulerAction *action2 = (__bridge id)ptr2; + return CFDateCompare((__bridge CFDateRef)action1.date, (__bridge CFDateRef)action2.date, NULL); +} + +static const void *RACRetainScheduledAction(CFAllocatorRef allocator, const void *ptr) { + return CFRetain(ptr); +} + +static void RACReleaseScheduledAction(CFAllocatorRef allocator, const void *ptr) { + CFRelease(ptr); +} + +@interface RACTestScheduler () + +// All of the RACTestSchedulerActions that have been enqueued and not yet +// executed. +// +// The minimum value in the heap represents the action to execute next. +// +// This property should only be used while synchronized on self. +@property (nonatomic, assign, readonly) CFBinaryHeapRef scheduledActions; + +// The number of blocks that have been directly enqueued with -schedule: so +// far. +// +// This is used to ensure unique dates when two blocks are enqueued +// simultaneously. +// +// This property should only be used while synchronized on self. +@property (nonatomic, assign) NSUInteger numberOfDirectlyScheduledBlocks; + +@end + +@implementation RACTestScheduler + +#pragma mark Lifecycle + +- (instancetype)init { + self = [super initWithName:@"com.github.ReactiveCocoa.RACTestScheduler"]; + if (self == nil) return nil; + + CFBinaryHeapCallBacks callbacks = (CFBinaryHeapCallBacks){ + .version = 0, + .retain = &RACRetainScheduledAction, + .release = &RACReleaseScheduledAction, + .copyDescription = &CFCopyDescription, + .compare = &RACCompareScheduledActions + }; + + _scheduledActions = CFBinaryHeapCreate(NULL, 0, &callbacks, NULL); + return self; +} + +- (void)dealloc { + [self stepAll]; + + if (_scheduledActions != NULL) { + CFRelease(_scheduledActions); + _scheduledActions = NULL; + } +} + +#pragma mark Execution + +- (void)step { + [self step:1]; +} + +- (void)step:(NSUInteger)ticks { + @synchronized (self) { + for (NSUInteger i = 0; i < ticks; i++) { + const void *actionPtr = NULL; + if (!CFBinaryHeapGetMinimumIfPresent(self.scheduledActions, &actionPtr)) break; + + RACTestSchedulerAction *action = (__bridge id)actionPtr; + CFBinaryHeapRemoveMinimumValue(self.scheduledActions); + + if (action.disposable.disposed) continue; + + RACScheduler *previousScheduler = RACScheduler.currentScheduler; + NSThread.currentThread.threadDictionary[RACSchedulerCurrentSchedulerKey] = self; + + action.block(); + + if (previousScheduler != nil) { + NSThread.currentThread.threadDictionary[RACSchedulerCurrentSchedulerKey] = previousScheduler; + } else { + [NSThread.currentThread.threadDictionary removeObjectForKey:RACSchedulerCurrentSchedulerKey]; + } + } + } +} + +- (void)stepAll { + [self step:NSUIntegerMax]; +} + +#pragma mark RACScheduler + +- (RACDisposable *)schedule:(void (^)(void))block { + NSCParameterAssert(block != nil); + + @synchronized (self) { + NSDate *uniqueDate = [NSDate dateWithTimeIntervalSinceReferenceDate:self.numberOfDirectlyScheduledBlocks]; + self.numberOfDirectlyScheduledBlocks++; + + RACTestSchedulerAction *action = [[RACTestSchedulerAction alloc] initWithDate:uniqueDate block:block]; + CFBinaryHeapAddValue(self.scheduledActions, (__bridge void *)action); + + return action.disposable; + } +} + +- (RACDisposable *)after:(NSDate *)date schedule:(void (^)(void))block { + NSCParameterAssert(date != nil); + NSCParameterAssert(block != nil); + + @synchronized (self) { + RACTestSchedulerAction *action = [[RACTestSchedulerAction alloc] initWithDate:date block:block]; + CFBinaryHeapAddValue(self.scheduledActions, (__bridge void *)action); + + return action.disposable; + } +} + +- (RACDisposable *)after:(NSDate *)date repeatingEvery:(NSTimeInterval)interval withLeeway:(NSTimeInterval)leeway schedule:(void (^)(void))block { + NSCParameterAssert(date != nil); + NSCParameterAssert(block != nil); + NSCParameterAssert(interval >= 0); + NSCParameterAssert(leeway >= 0); + + RACCompoundDisposable *compoundDisposable = [RACCompoundDisposable compoundDisposable]; + + @weakify(self); + @synchronized (self) { + __block RACDisposable *thisDisposable = nil; + + void (^reschedulingBlock)(void) = ^{ + @strongify(self); + + [compoundDisposable removeDisposable:thisDisposable]; + + // Schedule the next interval. + RACDisposable *schedulingDisposable = [self after:[date dateByAddingTimeInterval:interval] repeatingEvery:interval withLeeway:leeway schedule:block]; + [compoundDisposable addDisposable:schedulingDisposable]; + + block(); + }; + + RACTestSchedulerAction *action = [[RACTestSchedulerAction alloc] initWithDate:date block:reschedulingBlock]; + CFBinaryHeapAddValue(self.scheduledActions, (__bridge void *)action); + + thisDisposable = action.disposable; + [compoundDisposable addDisposable:thisDisposable]; + } + + return compoundDisposable; +} + +@end + +@implementation RACTestSchedulerAction + +#pragma mark Lifecycle + +- (id)initWithDate:(NSDate *)date block:(void (^)(void))block { + NSCParameterAssert(date != nil); + NSCParameterAssert(block != nil); + + self = [super init]; + if (self == nil) return nil; + + _date = [date copy]; + _block = [block copy]; + _disposable = [[RACDisposable alloc] init]; + + return self; +} + +#pragma mark NSObject + +- (NSString *)description { + return [NSString stringWithFormat:@"<%@: %p>{ date: %@ }", self.class, self, self.date]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACTuple.h b/ReactiveCocoaFramework/ReactiveCocoa/RACTuple.h new file mode 100644 index 0000000..647b42c --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACTuple.h
@@ -0,0 +1,159 @@ +// +// RACTuple.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 4/12/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import <Foundation/Foundation.h> +#import "metamacros.h" + +@class RACSequence; + +/// Creates a new tuple with the given values. At least one value must be given. +/// Values can be nil. +#define RACTuplePack(...) \ + RACTuplePack_(__VA_ARGS__) + +/// Declares new object variables and unpacks a RACTuple into them. +/// +/// This macro should be used on the left side of an assignment, with the +/// tuple on the right side. Nothing else should appear on the same line, and the +/// macro should not be the only statement in a conditional or loop body. +/// +/// If the tuple has more values than there are variables listed, the excess +/// values are ignored. +/// +/// If the tuple has fewer values than there are variables listed, the excess +/// variables are initialized to nil. +/// +/// Examples +/// +/// RACTupleUnpack(NSString *string, NSNumber *num) = [RACTuple tupleWithObjects:@"foo", @5, nil]; +/// NSLog(@"string: %@", string); +/// NSLog(@"num: %@", num); +/// +/// /* The above is equivalent to: */ +/// RACTuple *t = [RACTuple tupleWithObjects:@"foo", @5, nil]; +/// NSString *string = t[0]; +/// NSNumber *num = t[1]; +/// NSLog(@"string: %@", string); +/// NSLog(@"num: %@", num); +#define RACTupleUnpack(...) \ + RACTupleUnpack_(__VA_ARGS__) + +/// A sentinel object that represents nils in the tuple. +/// +/// It should never be necessary to create a tuple nil yourself. Just use +/// +tupleNil. +@interface RACTupleNil : NSObject <NSCopying, NSCoding> +/// A singleton instance. ++ (RACTupleNil *)tupleNil; +@end + + +/// A tuple is an ordered collection of objects. It may contain nils, represented +/// by RACTupleNil. +@interface RACTuple : NSObject <NSCoding, NSCopying, NSFastEnumeration> + +@property (nonatomic, readonly) NSUInteger count; + +/// These properties all return the object at that index or nil if the number of +/// objects is less than the index. +@property (nonatomic, readonly) id first; +@property (nonatomic, readonly) id second; +@property (nonatomic, readonly) id third; +@property (nonatomic, readonly) id fourth; +@property (nonatomic, readonly) id fifth; +@property (nonatomic, readonly) id last; + +/// Creates a new tuple out of the array. Does not convert nulls to nils. ++ (instancetype)tupleWithObjectsFromArray:(NSArray *)array; + +/// Creates a new tuple out of the array. If `convert` is YES, it also converts +/// every NSNull to RACTupleNil. ++ (instancetype)tupleWithObjectsFromArray:(NSArray *)array convertNullsToNils:(BOOL)convert; + +/// Creates a new tuple with the given objects. Use RACTupleNil to represent +/// nils. ++ (instancetype)tupleWithObjects:(id)object, ... NS_REQUIRES_NIL_TERMINATION; + +/// Returns the object at `index` or nil if the object is a RACTupleNil. Unlike +/// NSArray and friends, it's perfectly fine to ask for the object at an index +/// past the tuple's count - 1. It will simply return nil. +- (id)objectAtIndex:(NSUInteger)index; + +/// Returns an array of all the objects. RACTupleNils are converted to NSNulls. +- (NSArray *)allObjects; + +/// Appends `obj` to the receiver. +/// +/// obj - The object to add to the tuple. This argument may be nil. +/// +/// Returns a new tuple. +- (instancetype)tupleByAddingObject:(id)obj; + +@end + +@interface RACTuple (RACSequenceAdditions) + +/// Returns a sequence of all the objects. RACTupleNils are converted to NSNulls. +@property (nonatomic, copy, readonly) RACSequence *rac_sequence; + +@end + +@interface RACTuple (ObjectSubscripting) +/// Returns the object at that index or nil if the number of objects is less +/// than the index. +- (id)objectAtIndexedSubscript:(NSUInteger)idx; +@end + +/// This and everything below is for internal use only. +/// +/// See RACTuplePack() and RACTupleUnpack() instead. +#define RACTuplePack_(...) \ + ([RACTuple tupleWithObjectsFromArray:@[ metamacro_foreach(RACTuplePack_object_or_ractuplenil,, __VA_ARGS__) ]]) + +#define RACTuplePack_object_or_ractuplenil(INDEX, ARG) \ + (ARG) ?: RACTupleNil.tupleNil, + +#define RACTupleUnpack_(...) \ + metamacro_foreach(RACTupleUnpack_decl,, __VA_ARGS__) \ + \ + int RACTupleUnpack_state = 0; \ + \ + RACTupleUnpack_after: \ + ; \ + metamacro_foreach(RACTupleUnpack_assign,, __VA_ARGS__) \ + if (RACTupleUnpack_state != 0) RACTupleUnpack_state = 2; \ + \ + while (RACTupleUnpack_state != 2) \ + if (RACTupleUnpack_state == 1) { \ + goto RACTupleUnpack_after; \ + } else \ + for (; RACTupleUnpack_state != 1; RACTupleUnpack_state = 1) \ + [RACTupleUnpackingTrampoline trampoline][ @[ metamacro_foreach(RACTupleUnpack_value,, __VA_ARGS__) ] ] + +#define RACTupleUnpack_state metamacro_concat(RACTupleUnpack_state, __LINE__) +#define RACTupleUnpack_after metamacro_concat(RACTupleUnpack_after, __LINE__) +#define RACTupleUnpack_loop metamacro_concat(RACTupleUnpack_loop, __LINE__) + +#define RACTupleUnpack_decl_name(INDEX) \ + metamacro_concat(metamacro_concat(RACTupleUnpack, __LINE__), metamacro_concat(_var, INDEX)) + +#define RACTupleUnpack_decl(INDEX, ARG) \ + __strong id RACTupleUnpack_decl_name(INDEX); + +#define RACTupleUnpack_assign(INDEX, ARG) \ + __strong ARG = RACTupleUnpack_decl_name(INDEX); + +#define RACTupleUnpack_value(INDEX, ARG) \ + [NSValue valueWithPointer:&RACTupleUnpack_decl_name(INDEX)], + +@interface RACTupleUnpackingTrampoline : NSObject + ++ (instancetype)trampoline; +- (void)setObject:(RACTuple *)tuple forKeyedSubscript:(NSArray *)variables; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACTuple.m b/ReactiveCocoaFramework/ReactiveCocoa/RACTuple.m new file mode 100644 index 0000000..9d338db --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACTuple.m
@@ -0,0 +1,252 @@ +// +// RACTuple.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 4/12/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACTuple.h" +#import "EXTKeyPathCoding.h" +#import "RACTupleSequence.h" + +@implementation RACTupleNil + ++ (RACTupleNil *)tupleNil { + static dispatch_once_t onceToken; + static RACTupleNil *tupleNil = nil; + dispatch_once(&onceToken, ^{ + tupleNil = [[self alloc] init]; + }); + + return tupleNil; +} + +#pragma mark NSCopying + +- (id)copyWithZone:(NSZone *)zone { + return self; +} + +#pragma mark NSCoding + +- (id)initWithCoder:(NSCoder *)coder { + // Always return the singleton. + return self.class.tupleNil; +} + +- (void)encodeWithCoder:(NSCoder *)coder { +} + +@end + + +@interface RACTuple () +@property (nonatomic, strong) NSArray *backingArray; +@end + + +@implementation RACTuple + +- (instancetype)init { + self = [super init]; + if (self == nil) return nil; + + self.backingArray = [NSArray array]; + + return self; +} + +- (NSString *)description { + return [NSString stringWithFormat:@"<%@: %p> %@", self.class, self, self.allObjects]; +} + +- (BOOL)isEqual:(RACTuple *)object { + if (object == self) return YES; + if (![object isKindOfClass:self.class]) return NO; + + return [self.backingArray isEqual:object.backingArray]; +} + +- (NSUInteger)hash { + return self.backingArray.hash; +} + + +#pragma mark NSFastEnumeration + +- (NSUInteger)countByEnumeratingWithState:(NSFastEnumerationState *)state objects:(id __unsafe_unretained [])buffer count:(NSUInteger)len { + return [self.backingArray countByEnumeratingWithState:state objects:buffer count:len]; +} + + +#pragma mark NSCopying + +- (instancetype)copyWithZone:(NSZone *)zone { + // we're immutable, bitches! + return self; +} + + +#pragma mark NSCoding + +- (id)initWithCoder:(NSCoder *)coder { + self = [self init]; + if (self == nil) return nil; + + self.backingArray = [coder decodeObjectForKey:@keypath(self.backingArray)]; + return self; +} + +- (void)encodeWithCoder:(NSCoder *)coder { + if (self.backingArray != nil) [coder encodeObject:self.backingArray forKey:@keypath(self.backingArray)]; +} + + +#pragma mark API + ++ (instancetype)tupleWithObjectsFromArray:(NSArray *)array { + return [self tupleWithObjectsFromArray:array convertNullsToNils:NO]; +} + ++ (instancetype)tupleWithObjectsFromArray:(NSArray *)array convertNullsToNils:(BOOL)convert { + RACTuple *tuple = [[self alloc] init]; + + if (convert) { + NSMutableArray *newArray = [NSMutableArray arrayWithCapacity:array.count]; + for (id object in array) { + [newArray addObject:(object == NSNull.null ? RACTupleNil.tupleNil : object)]; + } + + tuple.backingArray = newArray; + } else { + tuple.backingArray = [array copy]; + } + + return tuple; +} + ++ (instancetype)tupleWithObjects:(id)object, ... { + RACTuple *tuple = [[self alloc] init]; + + va_list args; + va_start(args, object); + + NSUInteger count = 0; + for (id currentObject = object; currentObject != nil; currentObject = va_arg(args, id)) { + ++count; + } + + va_end(args); + + if (count == 0) { + tuple.backingArray = @[]; + return tuple; + } + + NSMutableArray *objects = [[NSMutableArray alloc] initWithCapacity:count]; + + va_start(args, object); + for (id currentObject = object; currentObject != nil; currentObject = va_arg(args, id)) { + [objects addObject:currentObject]; + } + + va_end(args); + + tuple.backingArray = objects; + return tuple; +} + +- (id)objectAtIndex:(NSUInteger)index { + if (index >= self.count) return nil; + + id object = [self.backingArray objectAtIndex:index]; + return (object == RACTupleNil.tupleNil ? nil : object); +} + +- (NSArray *)allObjects { + NSMutableArray *newArray = [NSMutableArray arrayWithCapacity:self.backingArray.count]; + for (id object in self.backingArray) { + [newArray addObject:(object == RACTupleNil.tupleNil ? NSNull.null : object)]; + } + + return newArray; +} + +- (instancetype)tupleByAddingObject:(id)obj { + NSArray *newArray = [self.backingArray arrayByAddingObject:obj ?: RACTupleNil.tupleNil]; + return [self.class tupleWithObjectsFromArray:newArray convertNullsToNils:NO]; +} + +- (NSUInteger)count { + return self.backingArray.count; +} + +- (id)first { + return [self objectAtIndex:0]; +} + +- (id)second { + return [self objectAtIndex:1]; +} + +- (id)third { + return [self objectAtIndex:2]; +} + +- (id)fourth { + return [self objectAtIndex:3]; +} + +- (id)fifth { + return [self objectAtIndex:4]; +} + +- (id)last { + return [self objectAtIndex:self.count - 1]; +} + +@end + + +@implementation RACTuple (RACSequenceAdditions) + +- (RACSequence *)rac_sequence { + return [RACTupleSequence sequenceWithTupleBackingArray:self.backingArray offset:0]; +} + +@end + +@implementation RACTuple (ObjectSubscripting) + +- (id)objectAtIndexedSubscript:(NSUInteger)idx { + return [self objectAtIndex:idx]; +} + +@end + + +@implementation RACTupleUnpackingTrampoline + +#pragma mark Lifecycle + ++ (instancetype)trampoline { + static dispatch_once_t onceToken; + static id trampoline = nil; + dispatch_once(&onceToken, ^{ + trampoline = [[self alloc] init]; + }); + + return trampoline; +} + +- (void)setObject:(RACTuple *)tuple forKeyedSubscript:(NSArray *)variables { + NSCParameterAssert(variables != nil); + + [variables enumerateObjectsUsingBlock:^(NSValue *value, NSUInteger index, BOOL *stop) { + __strong id *ptr = (__strong id *)value.pointerValue; + *ptr = tuple[index]; + }]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACTupleSequence.h b/ReactiveCocoaFramework/ReactiveCocoa/RACTupleSequence.h new file mode 100644 index 0000000..f6cd021 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACTupleSequence.h
@@ -0,0 +1,18 @@ +// +// RACTupleSequence.h +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-05-01. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACSequence.h" + +// Private class that adapts a RACTuple to the RACSequence interface. +@interface RACTupleSequence : RACSequence + +// Returns a sequence for enumerating over the given backing array (from a +// RACTuple), starting from the given offset. ++ (instancetype)sequenceWithTupleBackingArray:(NSArray *)backingArray offset:(NSUInteger)offset; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACTupleSequence.m b/ReactiveCocoaFramework/ReactiveCocoa/RACTupleSequence.m new file mode 100644 index 0000000..ba268f5 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACTupleSequence.m
@@ -0,0 +1,68 @@ +// +// RACTupleSequence.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-05-01. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACTupleSequence.h" +#import "RACTuple.h" + +@interface RACTupleSequence () + +// The array being sequenced, as taken from RACTuple.backingArray. +@property (nonatomic, strong, readonly) NSArray *tupleBackingArray; + +// The index in the array from which the sequence starts. +@property (nonatomic, assign, readonly) NSUInteger offset; + +@end + +@implementation RACTupleSequence + +#pragma mark Lifecycle + ++ (instancetype)sequenceWithTupleBackingArray:(NSArray *)backingArray offset:(NSUInteger)offset { + NSCParameterAssert(offset <= backingArray.count); + + if (offset == backingArray.count) return self.empty; + + RACTupleSequence *seq = [[self alloc] init]; + seq->_tupleBackingArray = backingArray; + seq->_offset = offset; + return seq; +} + +#pragma mark RACSequence + +- (id)head { + id object = [self.tupleBackingArray objectAtIndex:self.offset]; + return (object == RACTupleNil.tupleNil ? NSNull.null : object); +} + +- (RACSequence *)tail { + RACSequence *sequence = [self.class sequenceWithTupleBackingArray:self.tupleBackingArray offset:self.offset + 1]; + sequence.name = self.name; + return sequence; +} + +- (NSArray *)array { + NSRange range = NSMakeRange(self.offset, self.tupleBackingArray.count - self.offset); + NSMutableArray *array = [[NSMutableArray alloc] initWithCapacity:range.length]; + + [self.tupleBackingArray enumerateObjectsAtIndexes:[NSIndexSet indexSetWithIndexesInRange:range] options:0 usingBlock:^(id object, NSUInteger index, BOOL *stop) { + id mappedObject = (object == RACTupleNil.tupleNil ? NSNull.null : object); + [array addObject:mappedObject]; + }]; + + return array; +} + +#pragma mark NSObject + +- (NSString *)description { + return [NSString stringWithFormat:@"<%@: %p>{ name = %@, tuple = %@ }", self.class, self, self.name, self.tupleBackingArray]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACUnarySequence.h b/ReactiveCocoaFramework/ReactiveCocoa/RACUnarySequence.h new file mode 100644 index 0000000..86a514b --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACUnarySequence.h
@@ -0,0 +1,14 @@ +// +// RACUnarySequence.h +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-05-01. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACSequence.h" + +// Private class representing a sequence of exactly one value. +@interface RACUnarySequence : RACSequence + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACUnarySequence.m b/ReactiveCocoaFramework/ReactiveCocoa/RACUnarySequence.m new file mode 100644 index 0000000..f72bf09 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACUnarySequence.m
@@ -0,0 +1,81 @@ +// +// RACUnarySequence.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-05-01. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACUnarySequence.h" +#import "EXTKeyPathCoding.h" +#import "NSObject+RACDescription.h" + +@interface RACUnarySequence () + +// The single value stored in this sequence. +@property (nonatomic, strong, readwrite) id head; + +@end + +@implementation RACUnarySequence + +#pragma mark Properties + +@synthesize head = _head; + +#pragma mark Lifecycle + ++ (instancetype)return:(id)value { + RACUnarySequence *sequence = [[self alloc] init]; + sequence.head = value; + return [sequence setNameWithFormat:@"+return: %@", [value rac_description]]; +} + +#pragma mark RACSequence + +- (RACSequence *)tail { + return nil; +} + +- (instancetype)bind:(RACStreamBindBlock (^)(void))block { + RACStreamBindBlock bindBlock = block(); + BOOL stop = NO; + + RACSequence *result = (id)[bindBlock(self.head, &stop) setNameWithFormat:@"[%@] -bind:", self.name]; + return result ?: self.class.empty; +} + +#pragma mark NSCoding + +- (Class)classForCoder { + // Unary sequences should be encoded as themselves, not array sequences. + return self.class; +} + +- (id)initWithCoder:(NSCoder *)coder { + id value = [coder decodeObjectForKey:@keypath(self.head)]; + return [self.class return:value]; +} + +- (void)encodeWithCoder:(NSCoder *)coder { + if (self.head != nil) [coder encodeObject:self.head forKey:@keypath(self.head)]; +} + +#pragma mark NSObject + +- (NSString *)description { + return [NSString stringWithFormat:@"<%@: %p>{ name = %@, head = %@ }", self.class, self, self.name, self.head]; +} + +- (NSUInteger)hash { + return [self.head hash]; +} + +- (BOOL)isEqual:(RACUnarySequence *)seq { + if (self == seq) return YES; + if (![seq isKindOfClass:RACUnarySequence.class]) return NO; + + return self.head == seq.head || [(NSObject *)self.head isEqual:seq.head]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACUnit.h b/ReactiveCocoaFramework/ReactiveCocoa/RACUnit.h new file mode 100644 index 0000000..7713e1d --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACUnit.h
@@ -0,0 +1,20 @@ +// +// RACUnit.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 3/27/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import <Foundation/Foundation.h> + + +/// A unit represents an empty value. +/// +/// It should never be necessary to create a unit yourself. Just use +defaultUnit. +@interface RACUnit : NSObject + +/// A singleton instance. ++ (RACUnit *)defaultUnit; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACUnit.m b/ReactiveCocoaFramework/ReactiveCocoa/RACUnit.m new file mode 100644 index 0000000..76b8425 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACUnit.m
@@ -0,0 +1,27 @@ +// +// RACUnit.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 3/27/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACUnit.h" + + +@implementation RACUnit + + +#pragma mark API + ++ (RACUnit *)defaultUnit { + static dispatch_once_t onceToken; + static RACUnit *defaultUnit = nil; + dispatch_once(&onceToken, ^{ + defaultUnit = [[self alloc] init]; + }); + + return defaultUnit; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACValueTransformer.h b/ReactiveCocoaFramework/ReactiveCocoa/RACValueTransformer.h new file mode 100644 index 0000000..740b861 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACValueTransformer.h
@@ -0,0 +1,16 @@ +// +// RACValueTransformer.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 3/6/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import <Foundation/Foundation.h> + +// A private block based transformer. +@interface RACValueTransformer : NSValueTransformer + ++ (instancetype)transformerWithBlock:(id (^)(id value))block; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/RACValueTransformer.m b/ReactiveCocoaFramework/ReactiveCocoa/RACValueTransformer.m new file mode 100644 index 0000000..ccec07d --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/RACValueTransformer.m
@@ -0,0 +1,42 @@ +// +// RACValueTransformer.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 3/6/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACValueTransformer.h" + +@interface RACValueTransformer () +@property (nonatomic, copy) id (^transformBlock)(id value); +@end + + +@implementation RACValueTransformer + + +#pragma mark NSValueTransformer + ++ (BOOL)allowsReverseTransformation { + return NO; +} + +- (id)transformedValue:(id)value { + return self.transformBlock(value); +} + + +#pragma mark API + +@synthesize transformBlock; + ++ (instancetype)transformerWithBlock:(id (^)(id value))block { + NSCParameterAssert(block != NULL); + + RACValueTransformer *transformer = [[self alloc] init]; + transformer.transformBlock = block; + return transformer; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/ReactiveCocoa-Info.plist b/ReactiveCocoaFramework/ReactiveCocoa/ReactiveCocoa-Info.plist new file mode 100644 index 0000000..4e63eab --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/ReactiveCocoa-Info.plist
@@ -0,0 +1,30 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> +<plist version="1.0"> +<dict> + <key>CFBundleDevelopmentRegion</key> + <string>English</string> + <key>CFBundleExecutable</key> + <string>${EXECUTABLE_NAME}</string> + <key>CFBundleIconFile</key> + <string></string> + <key>CFBundleIdentifier</key> + <string>com.github.${PRODUCT_NAME:rfc1034identifier}</string> + <key>CFBundleInfoDictionaryVersion</key> + <string>6.0</string> + <key>CFBundleName</key> + <string>${PRODUCT_NAME}</string> + <key>CFBundlePackageType</key> + <string>FMWK</string> + <key>CFBundleShortVersionString</key> + <string>1.0</string> + <key>CFBundleSignature</key> + <string>????</string> + <key>CFBundleVersion</key> + <string>1</string> + <key>NSHumanReadableCopyright</key> + <string>Copyright © 2012 GitHub, Inc. All rights reserved.</string> + <key>NSPrincipalClass</key> + <string></string> +</dict> +</plist>
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/ReactiveCocoa-Prefix.pch b/ReactiveCocoaFramework/ReactiveCocoa/ReactiveCocoa-Prefix.pch new file mode 100644 index 0000000..aa9849d --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/ReactiveCocoa-Prefix.pch
@@ -0,0 +1,13 @@ +// +// Prefix header for all source files of the 'ReactiveCocoa' target in the 'ReactiveCocoa' project +// + +#ifdef __OBJC__ + #import <Foundation/Foundation.h> +#endif + +#undef NSAssert +#undef NSParameterAssert + +extern void NSAssert(int condition, ...) __attribute__((unavailable("Use NSCAssert instead."))); +extern void NSParameterAssert(int condition, ...) __attribute__((unavailable("Use NSCParameterAssert instead.")));
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/ReactiveCocoa.h b/ReactiveCocoaFramework/ReactiveCocoa/ReactiveCocoa.h new file mode 100644 index 0000000..41f32d9 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/ReactiveCocoa.h
@@ -0,0 +1,74 @@ +// +// ReactiveCocoa.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 3/5/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "EXTKeyPathCoding.h" +#import "NSArray+RACSequenceAdditions.h" +#import "NSData+RACSupport.h" +#import "NSDictionary+RACSequenceAdditions.h" +#import "NSEnumerator+RACSequenceAdditions.h" +#import "NSFileHandle+RACSupport.h" +#import "NSNotificationCenter+RACSupport.h" +#import "NSObject+RACDeallocating.h" +#import "NSObject+RACLifting.h" +#import "NSObject+RACPropertySubscribing.h" +#import "NSObject+RACSelectorSignal.h" +#import "NSOrderedSet+RACSequenceAdditions.h" +#import "NSSet+RACSequenceAdditions.h" +#import "NSString+RACSequenceAdditions.h" +#import "NSString+RACSupport.h" +#import "NSIndexSet+RACSequenceAdditions.h" +#import "NSURLConnection+RACSupport.h" +#import "NSUserDefaults+RACSupport.h" +#import "RACBehaviorSubject.h" +#import "RACChannel.h" +#import "RACCommand.h" +#import "RACCompoundDisposable.h" +#import "RACDisposable.h" +#import "RACEvent.h" +#import "RACGroupedSignal.h" +#import "RACKVOChannel.h" +#import "RACMulticastConnection.h" +#import "RACQueueScheduler.h" +#import "RACReplaySubject.h" +#import "RACScheduler.h" +#import "RACScopedDisposable.h" +#import "RACSequence.h" +#import "RACSerialDisposable.h" +#import "RACSignal+Operations.h" +#import "RACSignal.h" +#import "RACStream.h" +#import "RACSubject.h" +#import "RACSubscriber.h" +#import "RACSubscriptingAssignmentTrampoline.h" +#import "RACTargetQueueScheduler.h" +#import "RACTestScheduler.h" +#import "RACTuple.h" +#import "RACUnit.h" + +#ifdef __IPHONE_OS_VERSION_MIN_REQUIRED + #import "UIActionSheet+RACSignalSupport.h" + #import "UIAlertView+RACSignalSupport.h" + #import "UIBarButtonItem+RACCommandSupport.h" + #import "UIButton+RACCommandSupport.h" + #import "UICollectionReusableView+RACSignalSupport.h" + #import "UIControl+RACSignalSupport.h" + #import "UIDatePicker+RACSignalSupport.h" + #import "UIGestureRecognizer+RACSignalSupport.h" + #import "UISegmentedControl+RACSignalSupport.h" + #import "UISlider+RACSignalSupport.h" + #import "UIStepper+RACSignalSupport.h" + #import "UISwitch+RACSignalSupport.h" + #import "UITableViewCell+RACSignalSupport.h" + #import "UITextField+RACSignalSupport.h" + #import "UITextView+RACSignalSupport.h" +#elif TARGET_OS_MAC + #import "NSControl+RACCommandSupport.h" + #import "NSControl+RACTextSignalSupport.h" + #import "NSObject+RACAppKitBindings.h" + #import "NSText+RACSignalSupport.h" +#endif
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UIActionSheet+RACSignalSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/UIActionSheet+RACSignalSupport.h new file mode 100644 index 0000000..3d667e9 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/UIActionSheet+RACSignalSupport.h
@@ -0,0 +1,32 @@ +// +// UIActionSheet+RACSignalSupport.h +// ReactiveCocoa +// +// Created by Dave Lee on 2013-06-22. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import <UIKit/UIKit.h> + +@class RACDelegateProxy; +@class RACSignal; + +@interface UIActionSheet (RACSignalSupport) + +/// A delegate proxy which will be set as the receiver's delegate when any of the +/// methods in this category are used. +@property (nonatomic, strong, readonly) RACDelegateProxy *rac_delegateProxy; + +/// Creates a signal for button clicks on the receiver. +/// +/// When this method is invoked, the `rac_delegateProxy` will become the +/// receiver's delegate. Any previous delegate will become the -[RACDelegateProxy +/// rac_proxiedDelegate], so that it receives any messages that the proxy doesn't +/// know how to handle. Setting the receiver's `delegate` afterward is +/// considered undefined behavior. +/// +/// Returns a signal which will send the index of the specific button clicked. +/// The signal will complete when the receiver is deallocated. +- (RACSignal *)rac_buttonClickedSignal; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UIActionSheet+RACSignalSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/UIActionSheet+RACSignalSupport.m new file mode 100644 index 0000000..6198797 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/UIActionSheet+RACSignalSupport.m
@@ -0,0 +1,50 @@ +// +// UIActionSheet+RACSignalSupport.m +// ReactiveCocoa +// +// Created by Dave Lee on 2013-06-22. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "UIActionSheet+RACSignalSupport.h" +#import "RACDelegateProxy.h" +#import "RACSignal+Operations.h" +#import "NSObject+RACDeallocating.h" +#import "RACTuple.h" +#import "NSObject+RACDescription.h" +#import <objc/runtime.h> + +@implementation UIActionSheet (RACSignalSupport) + +static void RACUseDelegateProxy(UIActionSheet *self) { + if (self.delegate == self.rac_delegateProxy) return; + + self.rac_delegateProxy.rac_proxiedDelegate = self.delegate; + self.delegate = (id)self.rac_delegateProxy; +} + +- (RACDelegateProxy *)rac_delegateProxy { + RACDelegateProxy *proxy = objc_getAssociatedObject(self, _cmd); + if (proxy == nil) { + proxy = [[RACDelegateProxy alloc] initWithProtocol:@protocol(UIActionSheetDelegate)]; + objc_setAssociatedObject(self, _cmd, proxy, OBJC_ASSOCIATION_RETAIN_NONATOMIC); + } + + return proxy; +} + +- (RACSignal *)rac_buttonClickedSignal { + RACSignal *signal = [[[[self.rac_delegateProxy + signalForSelector:@selector(actionSheet:clickedButtonAtIndex:)] + reduceEach:^(UIActionSheet *actionSheet, NSNumber *buttonIndex) { + return buttonIndex; + }] + takeUntil:self.rac_willDeallocSignal] + setNameWithFormat:@"%@ -rac_buttonClickedSignal", [self rac_description]]; + + RACUseDelegateProxy(self); + + return signal; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UIAlertView+RACSignalSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/UIAlertView+RACSignalSupport.h new file mode 100644 index 0000000..4586460 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/UIAlertView+RACSignalSupport.h
@@ -0,0 +1,32 @@ +// +// UIAlertView+RACSignalSupport.h +// ReactiveCocoa +// +// Created by Henrik Hodne on 6/16/13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import <UIKit/UIKit.h> + +@class RACDelegateProxy; +@class RACSignal; + +@interface UIAlertView (RACSignalSupport) + +/// A delegate proxy which will be set as the receiver's delegate when any of the +/// methods in this category are used. +@property (nonatomic, strong, readonly) RACDelegateProxy *rac_delegateProxy; + +/// Creates a signal for button clicks on the receiver. +/// +/// When this method is invoked, the `rac_delegateProxy` will become the +/// receiver's delegate. Any previous delegate will become the -[RACDelegateProxy +/// rac_proxiedDelegate], so that it receives any messages that the proxy doesn't +/// know how to handle. Setting the receiver's `delegate` afterward is considered +/// undefined behavior. +/// +/// Returns a signal which will send the index of the specific button clicked. +/// The signal will complete itself when the receiver is deallocated. +- (RACSignal *)rac_buttonClickedSignal; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UIAlertView+RACSignalSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/UIAlertView+RACSignalSupport.m new file mode 100644 index 0000000..bf15b27 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/UIAlertView+RACSignalSupport.m
@@ -0,0 +1,50 @@ +// +// UIAlertView+RACSignalSupport.m +// ReactiveCocoa +// +// Created by Henrik Hodne on 6/16/13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "UIAlertView+RACSignalSupport.h" +#import "RACDelegateProxy.h" +#import "RACSignal+Operations.h" +#import "NSObject+RACDeallocating.h" +#import "NSObject+RACDescription.h" +#import "RACTuple.h" +#import <objc/runtime.h> + +@implementation UIAlertView (RACSignalSupport) + +static void RACUseDelegateProxy(UIAlertView *self) { + if (self.delegate == self.rac_delegateProxy) return; + + self.rac_delegateProxy.rac_proxiedDelegate = self.delegate; + self.delegate = (id)self.rac_delegateProxy; +} + +- (RACDelegateProxy *)rac_delegateProxy { + RACDelegateProxy *proxy = objc_getAssociatedObject(self, _cmd); + if (proxy == nil) { + proxy = [[RACDelegateProxy alloc] initWithProtocol:@protocol(UIAlertViewDelegate)]; + objc_setAssociatedObject(self, _cmd, proxy, OBJC_ASSOCIATION_RETAIN_NONATOMIC); + } + + return proxy; +} + +- (RACSignal *)rac_buttonClickedSignal { + RACSignal *signal = [[[[self.rac_delegateProxy + signalForSelector:@selector(alertView:clickedButtonAtIndex:)] + reduceEach:^(UIAlertView *alertView, NSNumber *buttonIndex) { + return buttonIndex; + }] + takeUntil:self.rac_willDeallocSignal] + setNameWithFormat:@"%@ -rac_buttonClickedSignal", [self rac_description]]; + + RACUseDelegateProxy(self); + + return signal; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UIBarButtonItem+RACCommandSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/UIBarButtonItem+RACCommandSupport.h new file mode 100644 index 0000000..c04648a --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/UIBarButtonItem+RACCommandSupport.h
@@ -0,0 +1,22 @@ +// +// UIBarButtonItem+RACCommandSupport.h +// ReactiveCocoa +// +// Created by Kyle LeNeau on 3/27/13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import <UIKit/UIKit.h> + +@class RACCommand; + +@interface UIBarButtonItem (RACCommandSupport) + +/// Sets the control's command. When the control is clicked, the command is +/// executed with the sender of the event. The control's enabledness is bound +/// to the command's `canExecute`. +/// +/// Note: this will reset the control's target and action. +@property (nonatomic, strong) RACCommand *rac_command; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UIBarButtonItem+RACCommandSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/UIBarButtonItem+RACCommandSupport.m new file mode 100644 index 0000000..91b7d19 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/UIBarButtonItem+RACCommandSupport.m
@@ -0,0 +1,55 @@ +// +// UIBarButtonItem+RACCommandSupport.m +// ReactiveCocoa +// +// Created by Kyle LeNeau on 3/27/13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "UIBarButtonItem+RACCommandSupport.h" +#import "EXTKeyPathCoding.h" +#import "NSObject+RACPropertySubscribing.h" +#import "RACCommand.h" +#import "RACDisposable.h" +#import "RACSignal+Operations.h" +#import <objc/runtime.h> + +static void *UIControlRACCommandKey = &UIControlRACCommandKey; +static void *UIControlEnabledDisposableKey = &UIControlEnabledDisposableKey; + +@implementation UIBarButtonItem (RACCommandSupport) + +- (RACCommand *)rac_command { + return objc_getAssociatedObject(self, UIControlRACCommandKey); +} + +- (void)setRac_command:(RACCommand *)command { + objc_setAssociatedObject(self, UIControlRACCommandKey, command, OBJC_ASSOCIATION_RETAIN_NONATOMIC); + + // Check for stored signal in order to remove it and add a new one + RACDisposable *disposable = objc_getAssociatedObject(self, UIControlEnabledDisposableKey); + [disposable dispose]; + + if (command == nil) return; + + disposable = [command.enabled setKeyPath:@keypath(self.enabled) onObject:self]; + objc_setAssociatedObject(self, UIControlEnabledDisposableKey, disposable, OBJC_ASSOCIATION_RETAIN_NONATOMIC); + + [self rac_hijackActionAndTargetIfNeeded]; +} + +- (void)rac_hijackActionAndTargetIfNeeded { + SEL hijackSelector = @selector(rac_commandPerformAction:); + if (self.target == self && self.action == hijackSelector) return; + + if (self.target != nil) NSLog(@"WARNING: UIBarButtonItem.rac_command hijacks the control's existing target and action."); + + self.target = self; + self.action = hijackSelector; +} + +- (void)rac_commandPerformAction:(id)sender { + [self.rac_command execute:sender]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UIButton+RACCommandSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/UIButton+RACCommandSupport.h new file mode 100644 index 0000000..642ba8e --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/UIButton+RACCommandSupport.h
@@ -0,0 +1,20 @@ +// +// UIButton+RACCommandSupport.h +// ReactiveCocoa +// +// Created by Ash Furrow on 2013-06-06. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import <UIKit/UIKit.h> + +@class RACCommand; + +@interface UIButton (RACCommandSupport) + +/// Sets the button's command. When the button is clicked, the command is +/// executed with the sender of the event. The button's enabledness is bound +/// to the command's `canExecute`. +@property (nonatomic, strong) RACCommand *rac_command; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UIButton+RACCommandSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/UIButton+RACCommandSupport.m new file mode 100644 index 0000000..2f5f1a0 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/UIButton+RACCommandSupport.m
@@ -0,0 +1,57 @@ +// +// UIButton+RACCommandSupport.m +// ReactiveCocoa +// +// Created by Ash Furrow on 2013-06-06. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "UIButton+RACCommandSupport.h" +#import "EXTKeyPathCoding.h" +#import "NSObject+RACPropertySubscribing.h" +#import "RACCommand.h" +#import "RACDisposable.h" +#import "RACSignal+Operations.h" +#import <objc/runtime.h> + +static void *UIButtonRACCommandKey = &UIButtonRACCommandKey; +static void *UIButtonEnabledDisposableKey = &UIButtonEnabledDisposableKey; + +@implementation UIButton (RACCommandSupport) + +- (RACCommand *)rac_command { + return objc_getAssociatedObject(self, UIButtonRACCommandKey); +} + +- (void)setRac_command:(RACCommand *)command { + objc_setAssociatedObject(self, UIButtonRACCommandKey, command, OBJC_ASSOCIATION_RETAIN_NONATOMIC); + + // Check for stored signal in order to remove it and add a new one + RACDisposable *disposable = objc_getAssociatedObject(self, UIButtonEnabledDisposableKey); + [disposable dispose]; + + if (command == nil) return; + + disposable = [command.enabled setKeyPath:@keypath(self.enabled) onObject:self]; + objc_setAssociatedObject(self, UIButtonEnabledDisposableKey, disposable, OBJC_ASSOCIATION_RETAIN_NONATOMIC); + + [self rac_hijackActionAndTargetIfNeeded]; +} + +- (void)rac_hijackActionAndTargetIfNeeded { + SEL hijackSelector = @selector(rac_commandPerformAction:); + + for (NSString *selector in [self actionsForTarget:self forControlEvent:UIControlEventTouchUpInside]) { + if (hijackSelector == NSSelectorFromString(selector)) { + return; + } + } + + [self addTarget:self action:hijackSelector forControlEvents:UIControlEventTouchUpInside]; +} + +- (void)rac_commandPerformAction:(id)sender { + [self.rac_command execute:sender]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UICollectionReusableView+RACSignalSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/UICollectionReusableView+RACSignalSupport.h new file mode 100644 index 0000000..96b3dfe --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/UICollectionReusableView+RACSignalSupport.h
@@ -0,0 +1,29 @@ +// +// UICollectionReusableView+RACSignalSupport.h +// ReactiveCocoa +// +// Created by Kent Wong on 2013-10-04. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import <UIKit/UIKit.h> + +@class RACSignal; + +// This category is only applicable to iOS >= 6.0. +@interface UICollectionReusableView (RACSignalSupport) + +/// A signal which will send a RACUnit whenever -prepareForReuse is invoked upon +/// the receiver. +/// +/// Examples +/// +/// [[[self.cancelButton +/// rac_signalForControlEvents:UIControlEventTouchUpInside] +/// takeUntil:self.rac_prepareForReuseSignal] +/// subscribeNext:^(UIButton *x) { +/// // do other things +/// }]; +@property (nonatomic, strong, readonly) RACSignal *rac_prepareForReuseSignal; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UICollectionReusableView+RACSignalSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/UICollectionReusableView+RACSignalSupport.m new file mode 100644 index 0000000..7e8680c --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/UICollectionReusableView+RACSignalSupport.m
@@ -0,0 +1,31 @@ +// +// UICollectionReusableView+RACSignalSupport.m +// ReactiveCocoa +// +// Created by Kent Wong on 2013-10-04. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "UICollectionReusableView+RACSignalSupport.h" +#import "NSObject+RACDescription.h" +#import "NSObject+RACSelectorSignal.h" +#import "RACSignal+Operations.h" +#import "RACUnit.h" +#import <objc/runtime.h> + +@implementation UICollectionReusableView (RACSignalSupport) + +- (RACSignal *)rac_prepareForReuseSignal { + RACSignal *signal = objc_getAssociatedObject(self, _cmd); + if (signal != nil) return signal; + + signal = [[[self + rac_signalForSelector:@selector(prepareForReuse)] + mapReplace:RACUnit.defaultUnit] + setNameWithFormat:@"%@ -rac_prepareForReuseSignal", self.rac_description]; + + objc_setAssociatedObject(self, _cmd, signal, OBJC_ASSOCIATION_RETAIN_NONATOMIC); + return signal; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UIControl+RACSignalSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/UIControl+RACSignalSupport.h new file mode 100644 index 0000000..2de86cf --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/UIControl+RACSignalSupport.h
@@ -0,0 +1,19 @@ +// +// UIControl+RACSignalSupport.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 4/17/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import <UIKit/UIKit.h> + +@class RACSignal; + +@interface UIControl (RACSignalSupport) + +/// Creates and returns a signal that sends the sender of the control event +/// whenever one of the control events is triggered. +- (RACSignal *)rac_signalForControlEvents:(UIControlEvents)controlEvents; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UIControl+RACSignalSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/UIControl+RACSignalSupport.m new file mode 100644 index 0000000..9e818ca --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/UIControl+RACSignalSupport.m
@@ -0,0 +1,41 @@ +// +// UIControl+RACSignalSupport.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 4/17/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "UIControl+RACSignalSupport.h" +#import "EXTScope.h" +#import "RACCompoundDisposable.h" +#import "RACDisposable.h" +#import "RACSignal.h" +#import "RACSignal+Operations.h" +#import "RACSubscriber+Private.h" +#import "NSObject+RACDeallocating.h" +#import "NSObject+RACDescription.h" + +@implementation UIControl (RACSignalSupport) + +- (RACSignal *)rac_signalForControlEvents:(UIControlEvents)controlEvents { + @weakify(self); + + return [[RACSignal + createSignal:^(id<RACSubscriber> subscriber) { + @strongify(self); + + [self addTarget:subscriber action:@selector(sendNext:) forControlEvents:controlEvents]; + [self.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + [subscriber sendCompleted]; + }]]; + + return [RACDisposable disposableWithBlock:^{ + @strongify(self); + [self removeTarget:subscriber action:@selector(sendNext:) forControlEvents:controlEvents]; + }]; + }] + setNameWithFormat:@"%@ -rac_signalForControlEvents: %lx", [self rac_description], (unsigned long)controlEvents]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UIControl+RACSignalSupportPrivate.h b/ReactiveCocoaFramework/ReactiveCocoa/UIControl+RACSignalSupportPrivate.h new file mode 100644 index 0000000..7f778a4 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/UIControl+RACSignalSupportPrivate.h
@@ -0,0 +1,29 @@ +// +// UIControl+RACSignalSupportPrivate.h +// ReactiveCocoa +// +// Created by Uri Baghin on 06/08/2013. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import <UIKit/UIKit.h> + +@class RACChannelTerminal; + +@interface UIControl (RACSignalSupportPrivate) + +// Adds a RACChannel-based interface to the receiver for the given +// UIControlEvents and exposes it. +// +// controlEvents - A mask of UIControlEvents on which to send new values. +// key - The key whose value should be read and set when a control +// event fires and when a value is sent to the +// RACChannelTerminal respectively. +// nilValue - The value to be assigned to the key when `nil` is sent to the +// RACChannelTerminal. +// +// Returns a RACChannelTerminal which will send future values from the receiver, +// and update the receiver when values are sent to the terminal. +- (RACChannelTerminal *)rac_channelForControlEvents:(UIControlEvents)controlEvents key:(NSString *)key nilValue:(id)nilValue; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UIControl+RACSignalSupportPrivate.m b/ReactiveCocoaFramework/ReactiveCocoa/UIControl+RACSignalSupportPrivate.m new file mode 100644 index 0000000..b73f817 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/UIControl+RACSignalSupportPrivate.m
@@ -0,0 +1,50 @@ +// +// UIControl+RACSignalSupportPrivate.m +// ReactiveCocoa +// +// Created by Uri Baghin on 06/08/2013. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "UIControl+RACSignalSupportPrivate.h" +#import "EXTScope.h" +#import "NSInvocation+RACTypeParsing.h" +#import "NSObject+RACDeallocating.h" +#import "NSObject+RACLifting.h" +#import "RACChannel.h" +#import "RACCompoundDisposable.h" +#import "RACDisposable.h" +#import "RACSignal+Operations.h" +#import "UIControl+RACSignalSupport.h" + +@implementation UIControl (RACSignalSupportPrivate) + +- (RACChannelTerminal *)rac_channelForControlEvents:(UIControlEvents)controlEvents key:(NSString *)key nilValue:(id)nilValue { + NSCParameterAssert(key.length > 0); + key = [key copy]; + RACChannel *channel = [[RACChannel alloc] init]; + + [self.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + [channel.followingTerminal sendCompleted]; + }]]; + + RACSignal *eventSignal = [[[self + rac_signalForControlEvents:controlEvents] + mapReplace:key] + takeUntil:[[channel.followingTerminal + ignoreValues] + catchTo:RACSignal.empty]]; + [[self + rac_liftSelector:@selector(valueForKey:) withSignals:eventSignal, nil] + subscribe:channel.followingTerminal]; + + RACSignal *valuesSignal = [channel.followingTerminal + map:^(id value) { + return value ?: nilValue; + }]; + [self rac_liftSelector:@selector(setValue:forKey:) withSignals:valuesSignal, [RACSignal return:key], nil]; + + return channel.leadingTerminal; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UIDatePicker+RACSignalSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/UIDatePicker+RACSignalSupport.h new file mode 100644 index 0000000..e620dfc --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/UIDatePicker+RACSignalSupport.h
@@ -0,0 +1,24 @@ +// +// UIDatePicker+RACSignalSupport.h +// ReactiveCocoa +// +// Created by Uri Baghin on 20/07/2013. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import <UIKit/UIKit.h> + +@class RACChannelTerminal; + +@interface UIDatePicker (RACSignalSupport) + +/// Creates a new RACChannel-based binding to the receiver. +/// +/// nilValue - The date to set when the terminal receives `nil`. +/// +/// Returns a RACChannelTerminal that sends the receiver's date whenever the +/// UIControlEventValueChanged control event is fired, and sets the date to the +/// values it receives. +- (RACChannelTerminal *)rac_newDateChannelWithNilValue:(NSDate *)nilValue; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UIDatePicker+RACSignalSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/UIDatePicker+RACSignalSupport.m new file mode 100644 index 0000000..fbae59c --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/UIDatePicker+RACSignalSupport.m
@@ -0,0 +1,20 @@ +// +// UIDatePicker+RACSignalSupport.m +// ReactiveCocoa +// +// Created by Uri Baghin on 20/07/2013. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "UIDatePicker+RACSignalSupport.h" +#import "EXTKeyPathCoding.h" +#import "UIControl+RACSignalSupport.h" +#import "UIControl+RACSignalSupportPrivate.h" + +@implementation UIDatePicker (RACSignalSupport) + +- (RACChannelTerminal *)rac_newDateChannelWithNilValue:(NSDate *)nilValue { + return [self rac_channelForControlEvents:UIControlEventValueChanged key:@keypath(self.date) nilValue:nilValue]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UIGestureRecognizer+RACSignalSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/UIGestureRecognizer+RACSignalSupport.h new file mode 100644 index 0000000..ee774fe --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/UIGestureRecognizer+RACSignalSupport.h
@@ -0,0 +1,18 @@ +// +// UIGestureRecognizer+RACSignalSupport.h +// Talks +// +// Created by Josh Vera on 5/5/13. +// Copyright (c) 2013 GitHub. All rights reserved. +// + +#import <UIKit/UIKit.h> + +@class RACSignal; + +@interface UIGestureRecognizer (RACSignalSupport) + +/// Returns a signal that sends the receiver when its gesture occurs. +- (RACSignal *)rac_gestureSignal; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UIGestureRecognizer+RACSignalSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/UIGestureRecognizer+RACSignalSupport.m new file mode 100644 index 0000000..afd5127 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/UIGestureRecognizer+RACSignalSupport.m
@@ -0,0 +1,40 @@ +// +// UIGestureRecognizer+RACSignalSupport.m +// Talks +// +// Created by Josh Vera on 5/5/13. +// Copyright (c) 2013 GitHub. All rights reserved. +// + +#import "UIGestureRecognizer+RACSignalSupport.h" +#import "EXTScope.h" +#import "NSObject+RACDeallocating.h" +#import "RACCompoundDisposable.h" +#import "RACDisposable.h" +#import "RACSignal.h" +#import "RACSubscriber.h" +#import "NSObject+RACDescription.h" + +@implementation UIGestureRecognizer (RACSignalSupport) + +- (RACSignal *)rac_gestureSignal { + @weakify(self); + + return [[RACSignal + createSignal:^(id<RACSubscriber> subscriber) { + @strongify(self); + + [self addTarget:subscriber action:@selector(sendNext:)]; + [self.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + [subscriber sendCompleted]; + }]]; + + return [RACDisposable disposableWithBlock:^{ + @strongify(self); + [self removeTarget:subscriber action:@selector(sendNext:)]; + }]; + }] + setNameWithFormat:@"%@ -rac_gestureSignal", [self rac_description]]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UIRefreshControl+RACCommandSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/UIRefreshControl+RACCommandSupport.h new file mode 100644 index 0000000..0bd1bf1 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/UIRefreshControl+RACCommandSupport.h
@@ -0,0 +1,22 @@ +// +// UIRefreshControl+RACCommandSupport.h +// ReactiveCocoa +// +// Created by Dave Lee on 2013-10-17. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import <UIKit/UIKit.h> + +@class RACCommand; + +@interface UIRefreshControl (RACCommandSupport) + +/// Manipulate the RACCommand property associated with this refresh control. +/// +/// When this refresh control is activated by the user, the command will be +/// executed. Upon completion or error of the execution signal, -endRefreshing +/// will be invoked. +@property (nonatomic, strong) RACCommand *rac_command; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UIRefreshControl+RACCommandSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/UIRefreshControl+RACCommandSupport.m new file mode 100644 index 0000000..9447f3e --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/UIRefreshControl+RACCommandSupport.m
@@ -0,0 +1,59 @@ +// +// UIRefreshControl+RACCommandSupport.m +// ReactiveCocoa +// +// Created by Dave Lee on 2013-10-17. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "UIRefreshControl+RACCommandSupport.h" +#import "EXTKeyPathCoding.h" +#import "NSObject+RACSelectorSignal.h" +#import "RACDisposable.h" +#import "RACCommand.h" +#import "RACCompoundDisposable.h" +#import "RACSignal.h" +#import "RACSignal+Operations.h" +#import "UIControl+RACSignalSupport.h" +#import <objc/runtime.h> + +static void *UIRefreshControlRACCommandKey = &UIRefreshControlRACCommandKey; +static void *UIRefreshControlDisposableKey = &UIRefreshControlDisposableKey; + +@implementation UIRefreshControl (RACCommandSupport) + +- (RACCommand *)rac_command { + return objc_getAssociatedObject(self, UIRefreshControlRACCommandKey); +} + +- (void)setRac_command:(RACCommand *)command { + objc_setAssociatedObject(self, UIRefreshControlRACCommandKey, command, OBJC_ASSOCIATION_RETAIN_NONATOMIC); + + // Dispose of any active command associations. + [objc_getAssociatedObject(self, UIRefreshControlDisposableKey) dispose]; + + if (command == nil) return; + + // Like RAC(self, enabled) = command.enabled; but with access to disposable. + RACDisposable *enabledDisposable = [command.enabled setKeyPath:@keypath(self.enabled) onObject:self]; + + RACDisposable *executionDisposable = [[[[self + rac_signalForControlEvents:UIControlEventValueChanged] + map:^(UIRefreshControl *x) { + return [[[command + execute:x] + catchTo:[RACSignal empty]] + then:^{ + return [RACSignal return:x]; + }]; + }] + concat] + subscribeNext:^(UIRefreshControl *x) { + [x endRefreshing]; + }]; + + RACDisposable *commandDisposable = [RACCompoundDisposable compoundDisposableWithDisposables:@[ enabledDisposable, executionDisposable ]]; + objc_setAssociatedObject(self, UIRefreshControlDisposableKey, commandDisposable, OBJC_ASSOCIATION_RETAIN_NONATOMIC); +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UISegmentedControl+RACSignalSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/UISegmentedControl+RACSignalSupport.h new file mode 100644 index 0000000..2d3c3e7 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/UISegmentedControl+RACSignalSupport.h
@@ -0,0 +1,24 @@ +// +// UISegmentedControl+RACSignalSupport.h +// ReactiveCocoa +// +// Created by Uri Baghin on 20/07/2013. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import <UIKit/UIKit.h> + +@class RACChannelTerminal; + +@interface UISegmentedControl (RACSignalSupport) + +/// Creates a new RACChannel-based binding to the receiver. +/// +/// nilValue - The segment to select when the terminal receives `nil`. +/// +/// Returns a RACChannelTerminal that sends the receiver's currently selected +/// segment's index whenever the UIControlEventValueChanged control event is +/// fired, and sets the selected segment index to the values it receives. +- (RACChannelTerminal *)rac_newSelectedSegmentIndexChannelWithNilValue:(NSNumber *)nilValue; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UISegmentedControl+RACSignalSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/UISegmentedControl+RACSignalSupport.m new file mode 100644 index 0000000..9ccea2b --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/UISegmentedControl+RACSignalSupport.m
@@ -0,0 +1,20 @@ +// +// UISegmentedControl+RACSignalSupport.m +// ReactiveCocoa +// +// Created by Uri Baghin on 20/07/2013. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "UISegmentedControl+RACSignalSupport.h" +#import "EXTKeyPathCoding.h" +#import "UIControl+RACSignalSupport.h" +#import "UIControl+RACSignalSupportPrivate.h" + +@implementation UISegmentedControl (RACSignalSupport) + +- (RACChannelTerminal *)rac_newSelectedSegmentIndexChannelWithNilValue:(NSNumber *)nilValue { + return [self rac_channelForControlEvents:UIControlEventValueChanged key:@keypath(self.selectedSegmentIndex) nilValue:nilValue]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UISlider+RACSignalSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/UISlider+RACSignalSupport.h new file mode 100644 index 0000000..75626ad --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/UISlider+RACSignalSupport.h
@@ -0,0 +1,24 @@ +// +// UISlider+RACSignalSupport.h +// ReactiveCocoa +// +// Created by Uri Baghin on 20/07/2013. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import <UIKit/UIKit.h> + +@class RACChannelTerminal; + +@interface UISlider (RACSignalSupport) + +/// Creates a new RACChannel-based binding to the receiver. +/// +/// nilValue - The value to set when the terminal receives `nil`. +/// +/// Returns a RACChannelTerminal that sends the receiver's value whenever the +/// UIControlEventValueChanged control event is fired, and sets the value to the +/// values it receives. +- (RACChannelTerminal *)rac_newValueChannelWithNilValue:(NSNumber *)nilValue; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UISlider+RACSignalSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/UISlider+RACSignalSupport.m new file mode 100644 index 0000000..2d37a3b --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/UISlider+RACSignalSupport.m
@@ -0,0 +1,20 @@ +// +// UISlider+RACSignalSupport.m +// ReactiveCocoa +// +// Created by Uri Baghin on 20/07/2013. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "UISlider+RACSignalSupport.h" +#import "EXTKeyPathCoding.h" +#import "UIControl+RACSignalSupport.h" +#import "UIControl+RACSignalSupportPrivate.h" + +@implementation UISlider (RACSignalSupport) + +- (RACChannelTerminal *)rac_newValueChannelWithNilValue:(NSNumber *)nilValue { + return [self rac_channelForControlEvents:UIControlEventValueChanged key:@keypath(self.value) nilValue:nilValue]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UIStepper+RACSignalSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/UIStepper+RACSignalSupport.h new file mode 100644 index 0000000..da6d97b --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/UIStepper+RACSignalSupport.h
@@ -0,0 +1,24 @@ +// +// UIStepper+RACSignalSupport.h +// ReactiveCocoa +// +// Created by Uri Baghin on 20/07/2013. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import <UIKit/UIKit.h> + +@class RACChannelTerminal; + +@interface UIStepper (RACSignalSupport) + +/// Creates a new RACChannel-based binding to the receiver. +/// +/// nilValue - The value to set when the terminal receives `nil`. +/// +/// Returns a RACChannelTerminal that sends the receiver's value whenever the +/// UIControlEventValueChanged control event is fired, and sets the value to the +/// values it receives. +- (RACChannelTerminal *)rac_newValueChannelWithNilValue:(NSNumber *)nilValue; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UIStepper+RACSignalSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/UIStepper+RACSignalSupport.m new file mode 100644 index 0000000..d8c5e81 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/UIStepper+RACSignalSupport.m
@@ -0,0 +1,20 @@ +// +// UIStepper+RACSignalSupport.m +// ReactiveCocoa +// +// Created by Uri Baghin on 20/07/2013. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "UIStepper+RACSignalSupport.h" +#import "EXTKeyPathCoding.h" +#import "UIControl+RACSignalSupport.h" +#import "UIControl+RACSignalSupportPrivate.h" + +@implementation UIStepper (RACSignalSupport) + +- (RACChannelTerminal *)rac_newValueChannelWithNilValue:(NSNumber *)nilValue { + return [self rac_channelForControlEvents:UIControlEventValueChanged key:@keypath(self.value) nilValue:nilValue]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UISwitch+RACSignalSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/UISwitch+RACSignalSupport.h new file mode 100644 index 0000000..1313a2c --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/UISwitch+RACSignalSupport.h
@@ -0,0 +1,22 @@ +// +// UISwitch+RACSignalSupport.h +// ReactiveCocoa +// +// Created by Uri Baghin on 20/07/2013. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import <UIKit/UIKit.h> + +@class RACChannelTerminal; + +@interface UISwitch (RACSignalSupport) + +/// Creates a new RACChannel-based binding to the receiver. +/// +/// Returns a RACChannelTerminal that sends whether the receiver is on whenever +/// the UIControlEventValueChanged control event is fired, and sets it on or off +/// when it receives @YES or @NO respectively. +- (RACChannelTerminal *)rac_newOnChannel; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UISwitch+RACSignalSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/UISwitch+RACSignalSupport.m new file mode 100644 index 0000000..1733fc5 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/UISwitch+RACSignalSupport.m
@@ -0,0 +1,20 @@ +// +// UISwitch+RACSignalSupport.m +// ReactiveCocoa +// +// Created by Uri Baghin on 20/07/2013. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "UISwitch+RACSignalSupport.h" +#import "EXTKeyPathCoding.h" +#import "UIControl+RACSignalSupport.h" +#import "UIControl+RACSignalSupportPrivate.h" + +@implementation UISwitch (RACSignalSupport) + +- (RACChannelTerminal *)rac_newOnChannel { + return [self rac_channelForControlEvents:UIControlEventValueChanged key:@keypath(self.on) nilValue:@NO]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UITableViewCell+RACSignalSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/UITableViewCell+RACSignalSupport.h new file mode 100644 index 0000000..c29d47c --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/UITableViewCell+RACSignalSupport.h
@@ -0,0 +1,28 @@ +// +// UITableViewCell+RACSignalSupport.h +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-07-22. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import <UIKit/UIKit.h> + +@class RACSignal; + +@interface UITableViewCell (RACSignalSupport) + +/// A signal which will send a RACUnit whenever -prepareForReuse is invoked upon +/// the receiver. +/// +/// Examples +/// +/// [[[self.cancelButton +/// rac_signalForControlEvents:UIControlEventTouchUpInside] +/// takeUntil:self.rac_prepareForReuseSignal] +/// subscribeNext:^(UIButton *x) { +/// // do other things +/// }]; +@property (nonatomic, strong, readonly) RACSignal *rac_prepareForReuseSignal; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UITableViewCell+RACSignalSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/UITableViewCell+RACSignalSupport.m new file mode 100644 index 0000000..8a81c30 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/UITableViewCell+RACSignalSupport.m
@@ -0,0 +1,31 @@ +// +// UITableViewCell+RACSignalSupport.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-07-22. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "UITableViewCell+RACSignalSupport.h" +#import "NSObject+RACDescription.h" +#import "NSObject+RACSelectorSignal.h" +#import "RACSignal+Operations.h" +#import "RACUnit.h" +#import <objc/runtime.h> + +@implementation UITableViewCell (RACSignalSupport) + +- (RACSignal *)rac_prepareForReuseSignal { + RACSignal *signal = objc_getAssociatedObject(self, _cmd); + if (signal != nil) return signal; + + signal = [[[self + rac_signalForSelector:@selector(prepareForReuse)] + mapReplace:RACUnit.defaultUnit] + setNameWithFormat:@"%@ -rac_prepareForReuseSignal", self.rac_description]; + + objc_setAssociatedObject(self, _cmd, signal, OBJC_ASSOCIATION_RETAIN_NONATOMIC); + return signal; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UITableViewHeaderFooterView+RACSignalSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/UITableViewHeaderFooterView+RACSignalSupport.h new file mode 100644 index 0000000..6c5d6b8 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/UITableViewHeaderFooterView+RACSignalSupport.h
@@ -0,0 +1,29 @@ +// +// UITableViewHeaderFooterView+RACSignalSupport.h +// ReactiveCocoa +// +// Created by Syo Ikeda on 12/30/13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import <UIKit/UIKit.h> + +@class RACSignal; + +// This category is only applicable to iOS >= 6.0. +@interface UITableViewHeaderFooterView (RACSignalSupport) + +/// A signal which will send a RACUnit whenever -prepareForReuse is invoked upon +/// the receiver. +/// +/// Examples +/// +/// [[[self.cancelButton +/// rac_signalForControlEvents:UIControlEventTouchUpInside] +/// takeUntil:self.rac_prepareForReuseSignal] +/// subscribeNext:^(UIButton *x) { +/// // do other things +/// }]; +@property (nonatomic, strong, readonly) RACSignal *rac_prepareForReuseSignal; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UITableViewHeaderFooterView+RACSignalSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/UITableViewHeaderFooterView+RACSignalSupport.m new file mode 100644 index 0000000..0ecfc37 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/UITableViewHeaderFooterView+RACSignalSupport.m
@@ -0,0 +1,31 @@ +// +// UITableViewHeaderFooterView+RACSignalSupport.m +// ReactiveCocoa +// +// Created by Syo Ikeda on 12/30/13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "UITableViewHeaderFooterView+RACSignalSupport.h" +#import "NSObject+RACDescription.h" +#import "NSObject+RACSelectorSignal.h" +#import "RACSignal+Operations.h" +#import "RACUnit.h" +#import <objc/runtime.h> + +@implementation UITableViewHeaderFooterView (RACSignalSupport) + +- (RACSignal *)rac_prepareForReuseSignal { + RACSignal *signal = objc_getAssociatedObject(self, _cmd); + if (signal != nil) return signal; + + signal = [[[self + rac_signalForSelector:@selector(prepareForReuse)] + mapReplace:RACUnit.defaultUnit] + setNameWithFormat:@"%@ -rac_prepareForReuseSignal", self.rac_description]; + + objc_setAssociatedObject(self, _cmd, signal, OBJC_ASSOCIATION_RETAIN_NONATOMIC); + return signal; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UITextField+RACSignalSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/UITextField+RACSignalSupport.h new file mode 100644 index 0000000..4ff6ee4 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/UITextField+RACSignalSupport.h
@@ -0,0 +1,27 @@ +// +// UITextField+RACSignalSupport.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 4/17/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import <UIKit/UIKit.h> + +@class RACSignal, RACChannelTerminal; + +@interface UITextField (RACSignalSupport) + +/// Creates and returns a signal for the text of the field. It always starts with +/// the current text. The signal sends next when the UIControlEventEditingChanged +/// or UIControlEventEditingDidBegin control event is fired on the control. +- (RACSignal *)rac_textSignal; + +/// Creates a new RACChannel-based binding to the receiver. +/// +/// Returns a RACChannelTerminal that sends the receiver's text whenever the +/// UIControlEventEditingChanged or UIControlEventEditingDidBegin control event +/// is fired, and sets the text to the values it receives. +- (RACChannelTerminal *)rac_newTextChannel; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UITextField+RACSignalSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/UITextField+RACSignalSupport.m new file mode 100644 index 0000000..ca2c68c --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/UITextField+RACSignalSupport.m
@@ -0,0 +1,39 @@ +// +// UITextField+RACSignalSupport.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 4/17/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "UITextField+RACSignalSupport.h" +#import "EXTKeyPathCoding.h" +#import "EXTScope.h" +#import "NSObject+RACDeallocating.h" +#import "NSObject+RACDescription.h" +#import "RACSignal+Operations.h" +#import "UIControl+RACSignalSupport.h" +#import "UIControl+RACSignalSupportPrivate.h" + +@implementation UITextField (RACSignalSupport) + +- (RACSignal *)rac_textSignal { + @weakify(self); + return [[[[[RACSignal + defer:^{ + @strongify(self); + return [RACSignal return:self]; + }] + concat:[self rac_signalForControlEvents:UIControlEventEditingChanged | UIControlEventEditingDidBegin]] + map:^(UITextField *x) { + return x.text; + }] + takeUntil:self.rac_willDeallocSignal] + setNameWithFormat:@"%@ -rac_textSignal", [self rac_description]]; +} + +- (RACChannelTerminal *)rac_newTextChannel { + return [self rac_channelForControlEvents:UIControlEventEditingChanged | UIControlEventEditingDidBegin key:@keypath(self.text) nilValue:@""]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UITextView+RACSignalSupport.h b/ReactiveCocoaFramework/ReactiveCocoa/UITextView+RACSignalSupport.h new file mode 100644 index 0000000..174b1ba --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/UITextView+RACSignalSupport.h
@@ -0,0 +1,39 @@ +// +// UITextView+RACSignalSupport.h +// ReactiveCocoa +// +// Created by Cody Krieger on 5/18/12. +// Copyright (c) 2012 Cody Krieger. All rights reserved. +// + +#import <UIKit/UIKit.h> + +@class RACDelegateProxy; +@class RACSignal; + +@interface UITextView (RACSignalSupport) + +/// A delegate proxy which will be set as the receiver's delegate when any of the +/// methods in this category are used. +@property (nonatomic, strong, readonly) RACDelegateProxy *rac_delegateProxy; + +/// Creates a signal for the text of the receiver. +/// +/// When this method is invoked, the `rac_delegateProxy` will become the +/// receiver's delegate. Any previous delegate will become the -[RACDelegateProxy +/// rac_proxiedDelegate], so that it receives any messages that the proxy doesn't +/// know how to handle. Setting the receiver's `delegate` afterward is +/// considered undefined behavior. +/// +/// Returns a signal which will send the current text upon subscription, then +/// again whenever the receiver's text is changed. The signal will complete when +/// the receiver is deallocated. +- (RACSignal *)rac_textSignal; + +@end + +@interface UITextView (RACSignalSupportUnavailable) + +- (RACSignal *)rac_signalForDelegateMethod:(SEL)method __attribute__((unavailable("Use -rac_signalForSelector:fromProtocol: instead"))); + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/UITextView+RACSignalSupport.m b/ReactiveCocoaFramework/ReactiveCocoa/UITextView+RACSignalSupport.m new file mode 100644 index 0000000..aa1cf12 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/UITextView+RACSignalSupport.m
@@ -0,0 +1,56 @@ +// +// UITextView+RACSignalSupport.m +// ReactiveCocoa +// +// Created by Cody Krieger on 5/18/12. +// Copyright (c) 2012 Cody Krieger. All rights reserved. +// + +#import "UITextView+RACSignalSupport.h" +#import "EXTScope.h" +#import "NSObject+RACDeallocating.h" +#import "RACDelegateProxy.h" +#import "RACSignal+Operations.h" +#import "RACTuple.h" +#import "NSObject+RACDescription.h" +#import <objc/runtime.h> + +@implementation UITextView (RACSignalSupport) + +static void RACUseDelegateProxy(UITextView *self) { + if (self.delegate == self.rac_delegateProxy) return; + + self.rac_delegateProxy.rac_proxiedDelegate = self.delegate; + self.delegate = (id)self.rac_delegateProxy; +} + +- (RACDelegateProxy *)rac_delegateProxy { + RACDelegateProxy *proxy = objc_getAssociatedObject(self, _cmd); + if (proxy == nil) { + proxy = [[RACDelegateProxy alloc] initWithProtocol:@protocol(UITextViewDelegate)]; + objc_setAssociatedObject(self, _cmd, proxy, OBJC_ASSOCIATION_RETAIN_NONATOMIC); + } + + return proxy; +} + +- (RACSignal *)rac_textSignal { + @weakify(self); + RACSignal *signal = [[[[[RACSignal + defer:^{ + @strongify(self); + return [RACSignal return:RACTuplePack(self)]; + }] + concat:[self.rac_delegateProxy signalForSelector:@selector(textViewDidChange:)]] + reduceEach:^(UITextView *x) { + return x.text; + }] + takeUntil:self.rac_willDeallocSignal] + setNameWithFormat:@"%@ -rac_textSignal", [self rac_description]]; + + RACUseDelegateProxy(self); + + return signal; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/en.lproj/InfoPlist.strings b/ReactiveCocoaFramework/ReactiveCocoa/en.lproj/InfoPlist.strings new file mode 100644 index 0000000..477b28f --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/en.lproj/InfoPlist.strings
@@ -0,0 +1,2 @@ +/* Localized versions of Info.plist keys */ +
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/extobjc/EXTKeyPathCoding.h b/ReactiveCocoaFramework/ReactiveCocoa/extobjc/EXTKeyPathCoding.h new file mode 100644 index 0000000..f34dc4a --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/extobjc/EXTKeyPathCoding.h
@@ -0,0 +1,68 @@ +// +// EXTKeyPathCoding.h +// extobjc +// +// Created by Justin Spahr-Summers on 19.06.12. +// Copyright (C) 2012 Justin Spahr-Summers. +// Released under the MIT license. +// + +#import <Foundation/Foundation.h> +#import "metamacros.h" + +/** + * \@keypath allows compile-time verification of key paths. Given a real object + * receiver and key path: + * + * @code + +NSString *UTF8StringPath = @keypath(str.lowercaseString.UTF8String); +// => @"lowercaseString.UTF8String" + +NSString *versionPath = @keypath(NSObject, version); +// => @"version" + +NSString *lowercaseStringPath = @keypath(NSString.new, lowercaseString); +// => @"lowercaseString" + + * @endcode + * + * ... the macro returns an \c NSString containing all but the first path + * component or argument (e.g., @"lowercaseString.UTF8String", @"version"). + * + * In addition to simply creating a key path, this macro ensures that the key + * path is valid at compile-time (causing a syntax error if not), and supports + * refactoring, such that changing the name of the property will also update any + * uses of \@keypath. + */ +#define keypath(...) \ + metamacro_if_eq(1, metamacro_argcount(__VA_ARGS__))(keypath1(__VA_ARGS__))(keypath2(__VA_ARGS__)) + +#define keypath1(PATH) \ + (((void)(NO && ((void)PATH, NO)), strchr(# PATH, '.') + 1)) + +#define keypath2(OBJ, PATH) \ + (((void)(NO && ((void)OBJ.PATH, NO)), # PATH)) + +/** + * \@collectionKeypath allows compile-time verification of key paths across collections NSArray/NSSet etc. Given a real object + * receiver, collection object receiver and related keypaths: + * + * @code + + NSString *employessFirstNamePath = @collectionKeypath(department.employees, Employee.new, firstName) + // => @"employees.firstName" + + NSString *employessFirstNamePath = @collectionKeypath(Department.new, employees, Employee.new, firstName) + // => @"employees.firstName" + + * @endcode + * + */ +#define collectionKeypath(...) \ + metamacro_if_eq(3, metamacro_argcount(__VA_ARGS__))(collectionKeypath3(__VA_ARGS__))(collectionKeypath4(__VA_ARGS__)) + +#define collectionKeypath3(PATH, COLLECTION_OBJECT, COLLECTION_PATH) ([[NSString stringWithFormat:@"%s.%s",keypath(PATH), keypath(COLLECTION_OBJECT, COLLECTION_PATH)] UTF8String]) + +#define collectionKeypath4(OBJ, PATH, COLLECTION_OBJECT, COLLECTION_PATH) ([[NSString stringWithFormat:@"%s.%s",keypath(OBJ, PATH), keypath(COLLECTION_OBJECT, COLLECTION_PATH)] UTF8String]) +
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/extobjc/EXTRuntimeExtensions.h b/ReactiveCocoaFramework/ReactiveCocoa/extobjc/EXTRuntimeExtensions.h new file mode 100644 index 0000000..ab4e11d --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/extobjc/EXTRuntimeExtensions.h
@@ -0,0 +1,122 @@ +// +// EXTRuntimeExtensions.h +// extobjc +// +// Created by Justin Spahr-Summers on 2011-03-05. +// Copyright (C) 2012 Justin Spahr-Summers. +// Released under the MIT license. +// + +#import <objc/runtime.h> + +/** + * Describes the memory management policy of a property. + */ +typedef enum { + /** + * The value is assigned. + */ + rac_propertyMemoryManagementPolicyAssign = 0, + + /** + * The value is retained. + */ + rac_propertyMemoryManagementPolicyRetain, + + /** + * The value is copied. + */ + rac_propertyMemoryManagementPolicyCopy +} rac_propertyMemoryManagementPolicy; + +/** + * Describes the attributes and type information of a property. + */ +typedef struct { + /** + * Whether this property was declared with the \c readonly attribute. + */ + BOOL readonly; + + /** + * Whether this property was declared with the \c nonatomic attribute. + */ + BOOL nonatomic; + + /** + * Whether the property is a weak reference. + */ + BOOL weak; + + /** + * Whether the property is eligible for garbage collection. + */ + BOOL canBeCollected; + + /** + * Whether this property is defined with \c \@dynamic. + */ + BOOL dynamic; + + /** + * The memory management policy for this property. This will always be + * #rac_propertyMemoryManagementPolicyAssign if #readonly is \c YES. + */ + rac_propertyMemoryManagementPolicy memoryManagementPolicy; + + /** + * The selector for the getter of this property. This will reflect any + * custom \c getter= attribute provided in the property declaration, or the + * inferred getter name otherwise. + */ + SEL getter; + + /** + * The selector for the setter of this property. This will reflect any + * custom \c setter= attribute provided in the property declaration, or the + * inferred setter name otherwise. + * + * @note If #readonly is \c YES, this value will represent what the setter + * \e would be, if the property were writable. + */ + SEL setter; + + /** + * The backing instance variable for this property, or \c NULL if \c + * \c @synthesize was not used, and therefore no instance variable exists. This + * would also be the case if the property is implemented dynamically. + */ + const char *ivar; + + /** + * If this property is defined as being an instance of a specific class, + * this will be the class object representing it. + * + * This will be \c nil if the property was defined as type \c id, if the + * property is not of an object type, or if the class could not be found at + * runtime. + */ + Class objectClass; + + /** + * The type encoding for the value of this property. This is the type as it + * would be returned by the \c \@encode() directive. + */ + char type[]; +} rac_propertyAttributes; + +/** + * Finds the instance method named \a aSelector on \a aClass and returns it, or + * returns \c NULL if no such instance method exists. Unlike \c + * class_getInstanceMethod(), this does not search superclasses. + * + * @note To get class methods in this manner, use a metaclass for \a aClass. + */ +Method rac_getImmediateInstanceMethod (Class aClass, SEL aSelector); + +/** + * Returns a pointer to a structure containing information about \a property. + * You must \c free() the returned pointer. Returns \c NULL if there is an error + * obtaining information from \a property. + */ +rac_propertyAttributes *rac_copyPropertyAttributes (objc_property_t property);
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/extobjc/EXTRuntimeExtensions.m b/ReactiveCocoaFramework/ReactiveCocoa/extobjc/EXTRuntimeExtensions.m new file mode 100644 index 0000000..4d35a3e --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/extobjc/EXTRuntimeExtensions.m
@@ -0,0 +1,232 @@ +// +// EXTRuntimeExtensions.m +// extobjc +// +// Created by Justin Spahr-Summers on 2011-03-05. +// Copyright (C) 2012 Justin Spahr-Summers. +// Released under the MIT license. +// + +#import "EXTRuntimeExtensions.h" +#import <ctype.h> +#import <libkern/OSAtomic.h> +#import <objc/message.h> +#import <pthread.h> +#import <stdio.h> +#import <stdlib.h> +#import <string.h> + +rac_propertyAttributes *rac_copyPropertyAttributes (objc_property_t property) { + const char * const attrString = property_getAttributes(property); + if (!attrString) { + fprintf(stderr, "ERROR: Could not get attribute string from property %s\n", property_getName(property)); + return NULL; + } + + if (attrString[0] != 'T') { + fprintf(stderr, "ERROR: Expected attribute string \"%s\" for property %s to start with 'T'\n", attrString, property_getName(property)); + return NULL; + } + + const char *typeString = attrString + 1; + const char *next = NSGetSizeAndAlignment(typeString, NULL, NULL); + if (!next) { + fprintf(stderr, "ERROR: Could not read past type in attribute string \"%s\" for property %s\n", attrString, property_getName(property)); + return NULL; + } + + size_t typeLength = (size_t)(next - typeString); + if (!typeLength) { + fprintf(stderr, "ERROR: Invalid type in attribute string \"%s\" for property %s\n", attrString, property_getName(property)); + return NULL; + } + + // allocate enough space for the structure and the type string (plus a NUL) + rac_propertyAttributes *attributes = calloc(1, sizeof(rac_propertyAttributes) + typeLength + 1); + if (!attributes) { + fprintf(stderr, "ERROR: Could not allocate rac_propertyAttributes structure for attribute string \"%s\" for property %s\n", attrString, property_getName(property)); + return NULL; + } + + // copy the type string + strncpy(attributes->type, typeString, typeLength); + attributes->type[typeLength] = '\0'; + + // if this is an object type, and immediately followed by a quoted string... + if (typeString[0] == *(@encode(id)) && typeString[1] == '"') { + // we should be able to extract a class name + const char *className = typeString + 2; + next = strchr(className, '"'); + + if (!next) { + fprintf(stderr, "ERROR: Could not read class name in attribute string \"%s\" for property %s\n", attrString, property_getName(property)); + return NULL; + } + + if (className != next) { + size_t classNameLength = (size_t)(next - className); + char trimmedName[classNameLength + 1]; + + strncpy(trimmedName, className, classNameLength); + trimmedName[classNameLength] = '\0'; + + // attempt to look up the class in the runtime + attributes->objectClass = objc_getClass(trimmedName); + } + } + + if (*next != '\0') { + // skip past any junk before the first flag + next = strchr(next, ','); + } + + while (next && *next == ',') { + char flag = next[1]; + next += 2; + + switch (flag) { + case '\0': + break; + + case 'R': + attributes->readonly = YES; + break; + + case 'C': + attributes->memoryManagementPolicy = rac_propertyMemoryManagementPolicyCopy; + break; + + case '&': + attributes->memoryManagementPolicy = rac_propertyMemoryManagementPolicyRetain; + break; + + case 'N': + attributes->nonatomic = YES; + break; + + case 'G': + case 'S': + { + const char *nextFlag = strchr(next, ','); + SEL name = NULL; + + if (!nextFlag) { + // assume that the rest of the string is the selector + const char *selectorString = next; + next = ""; + + name = sel_registerName(selectorString); + } else { + size_t selectorLength = (size_t)(nextFlag - next); + if (!selectorLength) { + fprintf(stderr, "ERROR: Found zero length selector name in attribute string \"%s\" for property %s\n", attrString, property_getName(property)); + goto errorOut; + } + + char selectorString[selectorLength + 1]; + + strncpy(selectorString, next, selectorLength); + selectorString[selectorLength] = '\0'; + + name = sel_registerName(selectorString); + next = nextFlag; + } + + if (flag == 'G') + attributes->getter = name; + else + attributes->setter = name; + } + + break; + + case 'D': + attributes->dynamic = YES; + attributes->ivar = NULL; + break; + + case 'V': + // assume that the rest of the string (if present) is the ivar name + if (*next == '\0') { + // if there's nothing there, let's assume this is dynamic + attributes->ivar = NULL; + } else { + attributes->ivar = next; + next = ""; + } + + break; + + case 'W': + attributes->weak = YES; + break; + + case 'P': + attributes->canBeCollected = YES; + break; + + case 't': + fprintf(stderr, "ERROR: Old-style type encoding is unsupported in attribute string \"%s\" for property %s\n", attrString, property_getName(property)); + + // skip over this type encoding + while (*next != ',' && *next != '\0') + ++next; + + break; + + default: + fprintf(stderr, "ERROR: Unrecognized attribute string flag '%c' in attribute string \"%s\" for property %s\n", flag, attrString, property_getName(property)); + } + } + + if (next && *next != '\0') { + fprintf(stderr, "Warning: Unparsed data \"%s\" in attribute string \"%s\" for property %s\n", next, attrString, property_getName(property)); + } + + if (!attributes->getter) { + // use the property name as the getter by default + attributes->getter = sel_registerName(property_getName(property)); + } + + if (!attributes->setter) { + const char *propertyName = property_getName(property); + size_t propertyNameLength = strlen(propertyName); + + // we want to transform the name to setProperty: style + size_t setterLength = propertyNameLength + 4; + + char setterName[setterLength + 1]; + strncpy(setterName, "set", 3); + strncpy(setterName + 3, propertyName, propertyNameLength); + + // capitalize property name for the setter + setterName[3] = (char)toupper(setterName[3]); + + setterName[setterLength - 1] = ':'; + setterName[setterLength] = '\0'; + + attributes->setter = sel_registerName(setterName); + } + + return attributes; + +errorOut: + free(attributes); + return NULL; +} + +Method rac_getImmediateInstanceMethod (Class aClass, SEL aSelector) { + unsigned methodCount = 0; + Method *methods = class_copyMethodList(aClass, &methodCount); + Method foundMethod = NULL; + + for (unsigned methodIndex = 0;methodIndex < methodCount;++methodIndex) { + if (method_getName(methods[methodIndex]) == aSelector) { + foundMethod = methods[methodIndex]; + break; + } + } + + free(methods); + return foundMethod; +}
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/extobjc/EXTScope.h b/ReactiveCocoaFramework/ReactiveCocoa/extobjc/EXTScope.h new file mode 100644 index 0000000..2e51747 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/extobjc/EXTScope.h
@@ -0,0 +1,101 @@ +// +// EXTScope.h +// extobjc +// +// Created by Justin Spahr-Summers on 2011-05-04. +// Copyright (C) 2012 Justin Spahr-Summers. +// Released under the MIT license. +// + +#import "metamacros.h" + +/** + * \@onExit defines some code to be executed when the current scope exits. The + * code must be enclosed in braces and terminated with a semicolon, and will be + * executed regardless of how the scope is exited, including from exceptions, + * \c goto, \c return, \c break, and \c continue. + * + * Provided code will go into a block to be executed later. Keep this in mind as + * it pertains to memory management, restrictions on assignment, etc. Because + * the code is used within a block, \c return is a legal (though perhaps + * confusing) way to exit the cleanup block early. + * + * Multiple \@onExit statements in the same scope are executed in reverse + * lexical order. This helps when pairing resource acquisition with \@onExit + * statements, as it guarantees teardown in the opposite order of acquisition. + * + * @note This statement cannot be used within scopes defined without braces + * (like a one line \c if). In practice, this is not an issue, since \@onExit is + * a useless construct in such a case anyways. + */ +#define onExit \ + autoreleasepool {} \ + __strong rac_cleanupBlock_t metamacro_concat(rac_exitBlock_, __LINE__) __attribute__((cleanup(rac_executeCleanupBlock), unused)) = ^ + +/** + * Creates \c __weak shadow variables for each of the variables provided as + * arguments, which can later be made strong again with #strongify. + * + * This is typically used to weakly reference variables in a block, but then + * ensure that the variables stay alive during the actual execution of the block + * (if they were live upon entry). + * + * See #strongify for an example of usage. + */ +#define weakify(...) \ + autoreleasepool {} \ + metamacro_foreach_cxt(rac_weakify_,, __weak, __VA_ARGS__) + +/** + * Like #weakify, but uses \c __unsafe_unretained instead, for targets or + * classes that do not support weak references. + */ +#define unsafeify(...) \ + autoreleasepool {} \ + metamacro_foreach_cxt(rac_weakify_,, __unsafe_unretained, __VA_ARGS__) + +/** + * Strongly references each of the variables provided as arguments, which must + * have previously been passed to #weakify. + * + * The strong references created will shadow the original variable names, such + * that the original names can be used without issue (and a significantly + * reduced risk of retain cycles) in the current scope. + * + * @code + + id foo = [[NSObject alloc] init]; + id bar = [[NSObject alloc] init]; + + @weakify(foo, bar); + + // this block will not keep 'foo' or 'bar' alive + BOOL (^matchesFooOrBar)(id) = ^ BOOL (id obj){ + // but now, upon entry, 'foo' and 'bar' will stay alive until the block has + // finished executing + @strongify(foo, bar); + + return [foo isEqual:obj] || [bar isEqual:obj]; + }; + + * @endcode + */ +#define strongify(...) \ + try {} @finally {} \ + _Pragma("clang diagnostic push") \ + _Pragma("clang diagnostic ignored \"-Wshadow\"") \ + metamacro_foreach(rac_strongify_,, __VA_ARGS__) \ + _Pragma("clang diagnostic pop") + +/*** implementation details follow ***/ +typedef void (^rac_cleanupBlock_t)(); + +static inline void rac_executeCleanupBlock (__strong rac_cleanupBlock_t *block) { + (*block)(); +} + +#define rac_weakify_(INDEX, CONTEXT, VAR) \ + CONTEXT __typeof__(VAR) metamacro_concat(VAR, _weak_) = (VAR); + +#define rac_strongify_(INDEX, VAR) \ + __strong __typeof__(VAR) VAR = metamacro_concat(VAR, _weak_);
diff --git a/ReactiveCocoaFramework/ReactiveCocoa/extobjc/metamacros.h b/ReactiveCocoaFramework/ReactiveCocoa/extobjc/metamacros.h new file mode 100644 index 0000000..77a77b5 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoa/extobjc/metamacros.h
@@ -0,0 +1,666 @@ +/** + * Macros for metaprogramming + * ExtendedC + * + * Copyright (C) 2012 Justin Spahr-Summers + * Released under the MIT license + */ + +#ifndef EXTC_METAMACROS_H +#define EXTC_METAMACROS_H + +/** + * Executes one or more expressions (which may have a void type, such as a call + * to a function that returns no value) and always returns true. + */ +#define metamacro_exprify(...) \ + ((__VA_ARGS__), true) + +/** + * Returns a string representation of VALUE after full macro expansion. + */ +#define metamacro_stringify(VALUE) \ + metamacro_stringify_(VALUE) + +/** + * Returns A and B concatenated after full macro expansion. + */ +#define metamacro_concat(A, B) \ + metamacro_concat_(A, B) + +/** + * Returns the Nth variadic argument (starting from zero). At least + * N + 1 variadic arguments must be given. N must be between zero and twenty, + * inclusive. + */ +#define metamacro_at(N, ...) \ + metamacro_concat(metamacro_at, N)(__VA_ARGS__) + +/** + * Returns the number of arguments (up to twenty) provided to the macro. At + * least one argument must be provided. + * + * Inspired by P99: http://p99.gforge.inria.fr + */ +#define metamacro_argcount(...) \ + metamacro_at(20, __VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1) + +/** + * Identical to #metamacro_foreach_cxt, except that no CONTEXT argument is + * given. Only the index and current argument will thus be passed to MACRO. + */ +#define metamacro_foreach(MACRO, SEP, ...) \ + metamacro_foreach_cxt(metamacro_foreach_iter, SEP, MACRO, __VA_ARGS__) + +/** + * For each consecutive variadic argument (up to twenty), MACRO is passed the + * zero-based index of the current argument, CONTEXT, and then the argument + * itself. The results of adjoining invocations of MACRO are then separated by + * SEP. + * + * Inspired by P99: http://p99.gforge.inria.fr + */ +#define metamacro_foreach_cxt(MACRO, SEP, CONTEXT, ...) \ + metamacro_concat(metamacro_foreach_cxt, metamacro_argcount(__VA_ARGS__))(MACRO, SEP, CONTEXT, __VA_ARGS__) + +/** + * Identical to #metamacro_foreach_cxt. This can be used when the former would + * fail due to recursive macro expansion. + */ +#define metamacro_foreach_cxt_recursive(MACRO, SEP, CONTEXT, ...) \ + metamacro_concat(metamacro_foreach_cxt_recursive, metamacro_argcount(__VA_ARGS__))(MACRO, SEP, CONTEXT, __VA_ARGS__) + +/** + * In consecutive order, appends each variadic argument (up to twenty) onto + * BASE. The resulting concatenations are then separated by SEP. + * + * This is primarily useful to manipulate a list of macro invocations into instead + * invoking a different, possibly related macro. + */ +#define metamacro_foreach_concat(BASE, SEP, ...) \ + metamacro_foreach_cxt(metamacro_foreach_concat_iter, SEP, BASE, __VA_ARGS__) + +/** + * Iterates COUNT times, each time invoking MACRO with the current index + * (starting at zero) and CONTEXT. The results of adjoining invocations of MACRO + * are then separated by SEP. + * + * COUNT must be an integer between zero and twenty, inclusive. + */ +#define metamacro_for_cxt(COUNT, MACRO, SEP, CONTEXT) \ + metamacro_concat(metamacro_for_cxt, COUNT)(MACRO, SEP, CONTEXT) + +/** + * Returns the first argument given. At least one argument must be provided. + * + * This is useful when implementing a variadic macro, where you may have only + * one variadic argument, but no way to retrieve it (for example, because \c ... + * always needs to match at least one argument). + * + * @code + +#define varmacro(...) \ + metamacro_head(__VA_ARGS__) + + * @endcode + */ +#define metamacro_head(...) \ + metamacro_head_(__VA_ARGS__, 0) + +/** + * Returns every argument except the first. At least two arguments must be + * provided. + */ +#define metamacro_tail(...) \ + metamacro_tail_(__VA_ARGS__) + +/** + * Returns the first N (up to twenty) variadic arguments as a new argument list. + * At least N variadic arguments must be provided. + */ +#define metamacro_take(N, ...) \ + metamacro_concat(metamacro_take, N)(__VA_ARGS__) + +/** + * Removes the first N (up to twenty) variadic arguments from the given argument + * list. At least N variadic arguments must be provided. + */ +#define metamacro_drop(N, ...) \ + metamacro_concat(metamacro_drop, N)(__VA_ARGS__) + +/** + * Decrements VAL, which must be a number between zero and twenty, inclusive. + * + * This is primarily useful when dealing with indexes and counts in + * metaprogramming. + */ +#define metamacro_dec(VAL) \ + metamacro_at(VAL, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19) + +/** + * Increments VAL, which must be a number between zero and twenty, inclusive. + * + * This is primarily useful when dealing with indexes and counts in + * metaprogramming. + */ +#define metamacro_inc(VAL) \ + metamacro_at(VAL, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21) + +/** + * If A is equal to B, the next argument list is expanded; otherwise, the + * argument list after that is expanded. A and B must be numbers between zero + * and twenty, inclusive. Additionally, B must be greater than or equal to A. + * + * @code + +// expands to true +metamacro_if_eq(0, 0)(true)(false) + +// expands to false +metamacro_if_eq(0, 1)(true)(false) + + * @endcode + * + * This is primarily useful when dealing with indexes and counts in + * metaprogramming. + */ +#define metamacro_if_eq(A, B) \ + metamacro_concat(metamacro_if_eq, A)(B) + +/** + * Identical to #metamacro_if_eq. This can be used when the former would fail + * due to recursive macro expansion. + */ +#define metamacro_if_eq_recursive(A, B) \ + metamacro_concat(metamacro_if_eq_recursive, A)(B) + +/** + * Returns 1 if N is an even number, or 0 otherwise. N must be between zero and + * twenty, inclusive. + * + * For the purposes of this test, zero is considered even. + */ +#define metamacro_is_even(N) \ + metamacro_at(N, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1) + +/** + * Returns the logical NOT of B, which must be the number zero or one. + */ +#define metamacro_not(B) \ + metamacro_at(B, 1, 0) + +// IMPLEMENTATION DETAILS FOLLOW! +// Do not write code that depends on anything below this line. +#define metamacro_stringify_(VALUE) # VALUE +#define metamacro_concat_(A, B) A ## B +#define metamacro_foreach_iter(INDEX, MACRO, ARG) MACRO(INDEX, ARG) +#define metamacro_head_(FIRST, ...) FIRST +#define metamacro_tail_(FIRST, ...) __VA_ARGS__ +#define metamacro_consume_(...) +#define metamacro_expand_(...) __VA_ARGS__ + +// implemented from scratch so that metamacro_concat() doesn't end up nesting +#define metamacro_foreach_concat_iter(INDEX, BASE, ARG) metamacro_foreach_concat_iter_(BASE, ARG) +#define metamacro_foreach_concat_iter_(BASE, ARG) BASE ## ARG + +// metamacro_at expansions +#define metamacro_at0(...) metamacro_head(__VA_ARGS__) +#define metamacro_at1(_0, ...) metamacro_head(__VA_ARGS__) +#define metamacro_at2(_0, _1, ...) metamacro_head(__VA_ARGS__) +#define metamacro_at3(_0, _1, _2, ...) metamacro_head(__VA_ARGS__) +#define metamacro_at4(_0, _1, _2, _3, ...) metamacro_head(__VA_ARGS__) +#define metamacro_at5(_0, _1, _2, _3, _4, ...) metamacro_head(__VA_ARGS__) +#define metamacro_at6(_0, _1, _2, _3, _4, _5, ...) metamacro_head(__VA_ARGS__) +#define metamacro_at7(_0, _1, _2, _3, _4, _5, _6, ...) metamacro_head(__VA_ARGS__) +#define metamacro_at8(_0, _1, _2, _3, _4, _5, _6, _7, ...) metamacro_head(__VA_ARGS__) +#define metamacro_at9(_0, _1, _2, _3, _4, _5, _6, _7, _8, ...) metamacro_head(__VA_ARGS__) +#define metamacro_at10(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, ...) metamacro_head(__VA_ARGS__) +#define metamacro_at11(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, ...) metamacro_head(__VA_ARGS__) +#define metamacro_at12(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, ...) metamacro_head(__VA_ARGS__) +#define metamacro_at13(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, ...) metamacro_head(__VA_ARGS__) +#define metamacro_at14(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, ...) metamacro_head(__VA_ARGS__) +#define metamacro_at15(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, ...) metamacro_head(__VA_ARGS__) +#define metamacro_at16(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, ...) metamacro_head(__VA_ARGS__) +#define metamacro_at17(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, ...) metamacro_head(__VA_ARGS__) +#define metamacro_at18(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, ...) metamacro_head(__VA_ARGS__) +#define metamacro_at19(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, ...) metamacro_head(__VA_ARGS__) +#define metamacro_at20(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, ...) metamacro_head(__VA_ARGS__) + +// metamacro_foreach_cxt expansions +#define metamacro_foreach_cxt0(MACRO, SEP, CONTEXT) +#define metamacro_foreach_cxt1(MACRO, SEP, CONTEXT, _0) MACRO(0, CONTEXT, _0) + +#define metamacro_foreach_cxt2(MACRO, SEP, CONTEXT, _0, _1) \ + metamacro_foreach_cxt1(MACRO, SEP, CONTEXT, _0) \ + SEP \ + MACRO(1, CONTEXT, _1) + +#define metamacro_foreach_cxt3(MACRO, SEP, CONTEXT, _0, _1, _2) \ + metamacro_foreach_cxt2(MACRO, SEP, CONTEXT, _0, _1) \ + SEP \ + MACRO(2, CONTEXT, _2) + +#define metamacro_foreach_cxt4(MACRO, SEP, CONTEXT, _0, _1, _2, _3) \ + metamacro_foreach_cxt3(MACRO, SEP, CONTEXT, _0, _1, _2) \ + SEP \ + MACRO(3, CONTEXT, _3) + +#define metamacro_foreach_cxt5(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4) \ + metamacro_foreach_cxt4(MACRO, SEP, CONTEXT, _0, _1, _2, _3) \ + SEP \ + MACRO(4, CONTEXT, _4) + +#define metamacro_foreach_cxt6(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5) \ + metamacro_foreach_cxt5(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4) \ + SEP \ + MACRO(5, CONTEXT, _5) + +#define metamacro_foreach_cxt7(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6) \ + metamacro_foreach_cxt6(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5) \ + SEP \ + MACRO(6, CONTEXT, _6) + +#define metamacro_foreach_cxt8(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7) \ + metamacro_foreach_cxt7(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6) \ + SEP \ + MACRO(7, CONTEXT, _7) + +#define metamacro_foreach_cxt9(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8) \ + metamacro_foreach_cxt8(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7) \ + SEP \ + MACRO(8, CONTEXT, _8) + +#define metamacro_foreach_cxt10(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9) \ + metamacro_foreach_cxt9(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8) \ + SEP \ + MACRO(9, CONTEXT, _9) + +#define metamacro_foreach_cxt11(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) \ + metamacro_foreach_cxt10(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9) \ + SEP \ + MACRO(10, CONTEXT, _10) + +#define metamacro_foreach_cxt12(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) \ + metamacro_foreach_cxt11(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) \ + SEP \ + MACRO(11, CONTEXT, _11) + +#define metamacro_foreach_cxt13(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) \ + metamacro_foreach_cxt12(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) \ + SEP \ + MACRO(12, CONTEXT, _12) + +#define metamacro_foreach_cxt14(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13) \ + metamacro_foreach_cxt13(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) \ + SEP \ + MACRO(13, CONTEXT, _13) + +#define metamacro_foreach_cxt15(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14) \ + metamacro_foreach_cxt14(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13) \ + SEP \ + MACRO(14, CONTEXT, _14) + +#define metamacro_foreach_cxt16(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15) \ + metamacro_foreach_cxt15(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14) \ + SEP \ + MACRO(15, CONTEXT, _15) + +#define metamacro_foreach_cxt17(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16) \ + metamacro_foreach_cxt16(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15) \ + SEP \ + MACRO(16, CONTEXT, _16) + +#define metamacro_foreach_cxt18(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17) \ + metamacro_foreach_cxt17(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16) \ + SEP \ + MACRO(17, CONTEXT, _17) + +#define metamacro_foreach_cxt19(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18) \ + metamacro_foreach_cxt18(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17) \ + SEP \ + MACRO(18, CONTEXT, _18) + +#define metamacro_foreach_cxt20(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19) \ + metamacro_foreach_cxt19(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18) \ + SEP \ + MACRO(19, CONTEXT, _19) + +// metamacro_foreach_cxt_recursive expansions +#define metamacro_foreach_cxt_recursive0(MACRO, SEP, CONTEXT) +#define metamacro_foreach_cxt_recursive1(MACRO, SEP, CONTEXT, _0) MACRO(0, CONTEXT, _0) + +#define metamacro_foreach_cxt_recursive2(MACRO, SEP, CONTEXT, _0, _1) \ + metamacro_foreach_cxt_recursive1(MACRO, SEP, CONTEXT, _0) \ + SEP \ + MACRO(1, CONTEXT, _1) + +#define metamacro_foreach_cxt_recursive3(MACRO, SEP, CONTEXT, _0, _1, _2) \ + metamacro_foreach_cxt_recursive2(MACRO, SEP, CONTEXT, _0, _1) \ + SEP \ + MACRO(2, CONTEXT, _2) + +#define metamacro_foreach_cxt_recursive4(MACRO, SEP, CONTEXT, _0, _1, _2, _3) \ + metamacro_foreach_cxt_recursive3(MACRO, SEP, CONTEXT, _0, _1, _2) \ + SEP \ + MACRO(3, CONTEXT, _3) + +#define metamacro_foreach_cxt_recursive5(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4) \ + metamacro_foreach_cxt_recursive4(MACRO, SEP, CONTEXT, _0, _1, _2, _3) \ + SEP \ + MACRO(4, CONTEXT, _4) + +#define metamacro_foreach_cxt_recursive6(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5) \ + metamacro_foreach_cxt_recursive5(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4) \ + SEP \ + MACRO(5, CONTEXT, _5) + +#define metamacro_foreach_cxt_recursive7(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6) \ + metamacro_foreach_cxt_recursive6(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5) \ + SEP \ + MACRO(6, CONTEXT, _6) + +#define metamacro_foreach_cxt_recursive8(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7) \ + metamacro_foreach_cxt_recursive7(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6) \ + SEP \ + MACRO(7, CONTEXT, _7) + +#define metamacro_foreach_cxt_recursive9(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8) \ + metamacro_foreach_cxt_recursive8(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7) \ + SEP \ + MACRO(8, CONTEXT, _8) + +#define metamacro_foreach_cxt_recursive10(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9) \ + metamacro_foreach_cxt_recursive9(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8) \ + SEP \ + MACRO(9, CONTEXT, _9) + +#define metamacro_foreach_cxt_recursive11(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) \ + metamacro_foreach_cxt_recursive10(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9) \ + SEP \ + MACRO(10, CONTEXT, _10) + +#define metamacro_foreach_cxt_recursive12(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) \ + metamacro_foreach_cxt_recursive11(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) \ + SEP \ + MACRO(11, CONTEXT, _11) + +#define metamacro_foreach_cxt_recursive13(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) \ + metamacro_foreach_cxt_recursive12(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) \ + SEP \ + MACRO(12, CONTEXT, _12) + +#define metamacro_foreach_cxt_recursive14(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13) \ + metamacro_foreach_cxt_recursive13(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) \ + SEP \ + MACRO(13, CONTEXT, _13) + +#define metamacro_foreach_cxt_recursive15(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14) \ + metamacro_foreach_cxt_recursive14(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13) \ + SEP \ + MACRO(14, CONTEXT, _14) + +#define metamacro_foreach_cxt_recursive16(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15) \ + metamacro_foreach_cxt_recursive15(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14) \ + SEP \ + MACRO(15, CONTEXT, _15) + +#define metamacro_foreach_cxt_recursive17(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16) \ + metamacro_foreach_cxt_recursive16(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15) \ + SEP \ + MACRO(16, CONTEXT, _16) + +#define metamacro_foreach_cxt_recursive18(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17) \ + metamacro_foreach_cxt_recursive17(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16) \ + SEP \ + MACRO(17, CONTEXT, _17) + +#define metamacro_foreach_cxt_recursive19(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18) \ + metamacro_foreach_cxt_recursive18(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17) \ + SEP \ + MACRO(18, CONTEXT, _18) + +#define metamacro_foreach_cxt_recursive20(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19) \ + metamacro_foreach_cxt_recursive19(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18) \ + SEP \ + MACRO(19, CONTEXT, _19) + +// metamacro_for_cxt expansions +#define metamacro_for_cxt0(MACRO, SEP, CONTEXT) +#define metamacro_for_cxt1(MACRO, SEP, CONTEXT) MACRO(0, CONTEXT) + +#define metamacro_for_cxt2(MACRO, SEP, CONTEXT) \ + metamacro_for_cxt1(MACRO, SEP, CONTEXT) \ + SEP \ + MACRO(1, CONTEXT) + +#define metamacro_for_cxt3(MACRO, SEP, CONTEXT) \ + metamacro_for_cxt2(MACRO, SEP, CONTEXT) \ + SEP \ + MACRO(2, CONTEXT) + +#define metamacro_for_cxt4(MACRO, SEP, CONTEXT) \ + metamacro_for_cxt3(MACRO, SEP, CONTEXT) \ + SEP \ + MACRO(3, CONTEXT) + +#define metamacro_for_cxt5(MACRO, SEP, CONTEXT) \ + metamacro_for_cxt4(MACRO, SEP, CONTEXT) \ + SEP \ + MACRO(4, CONTEXT) + +#define metamacro_for_cxt6(MACRO, SEP, CONTEXT) \ + metamacro_for_cxt5(MACRO, SEP, CONTEXT) \ + SEP \ + MACRO(5, CONTEXT) + +#define metamacro_for_cxt7(MACRO, SEP, CONTEXT) \ + metamacro_for_cxt6(MACRO, SEP, CONTEXT) \ + SEP \ + MACRO(6, CONTEXT) + +#define metamacro_for_cxt8(MACRO, SEP, CONTEXT) \ + metamacro_for_cxt7(MACRO, SEP, CONTEXT) \ + SEP \ + MACRO(7, CONTEXT) + +#define metamacro_for_cxt9(MACRO, SEP, CONTEXT) \ + metamacro_for_cxt8(MACRO, SEP, CONTEXT) \ + SEP \ + MACRO(8, CONTEXT) + +#define metamacro_for_cxt10(MACRO, SEP, CONTEXT) \ + metamacro_for_cxt9(MACRO, SEP, CONTEXT) \ + SEP \ + MACRO(9, CONTEXT) + +#define metamacro_for_cxt11(MACRO, SEP, CONTEXT) \ + metamacro_for_cxt10(MACRO, SEP, CONTEXT) \ + SEP \ + MACRO(10, CONTEXT) + +#define metamacro_for_cxt12(MACRO, SEP, CONTEXT) \ + metamacro_for_cxt11(MACRO, SEP, CONTEXT) \ + SEP \ + MACRO(11, CONTEXT) + +#define metamacro_for_cxt13(MACRO, SEP, CONTEXT) \ + metamacro_for_cxt12(MACRO, SEP, CONTEXT) \ + SEP \ + MACRO(12, CONTEXT) + +#define metamacro_for_cxt14(MACRO, SEP, CONTEXT) \ + metamacro_for_cxt13(MACRO, SEP, CONTEXT) \ + SEP \ + MACRO(13, CONTEXT) + +#define metamacro_for_cxt15(MACRO, SEP, CONTEXT) \ + metamacro_for_cxt14(MACRO, SEP, CONTEXT) \ + SEP \ + MACRO(14, CONTEXT) + +#define metamacro_for_cxt16(MACRO, SEP, CONTEXT) \ + metamacro_for_cxt15(MACRO, SEP, CONTEXT) \ + SEP \ + MACRO(15, CONTEXT) + +#define metamacro_for_cxt17(MACRO, SEP, CONTEXT) \ + metamacro_for_cxt16(MACRO, SEP, CONTEXT) \ + SEP \ + MACRO(16, CONTEXT) + +#define metamacro_for_cxt18(MACRO, SEP, CONTEXT) \ + metamacro_for_cxt17(MACRO, SEP, CONTEXT) \ + SEP \ + MACRO(17, CONTEXT) + +#define metamacro_for_cxt19(MACRO, SEP, CONTEXT) \ + metamacro_for_cxt18(MACRO, SEP, CONTEXT) \ + SEP \ + MACRO(18, CONTEXT) + +#define metamacro_for_cxt20(MACRO, SEP, CONTEXT) \ + metamacro_for_cxt19(MACRO, SEP, CONTEXT) \ + SEP \ + MACRO(19, CONTEXT) + +// metamacro_if_eq expansions +#define metamacro_if_eq0(VALUE) \ + metamacro_concat(metamacro_if_eq0_, VALUE) + +#define metamacro_if_eq0_0(...) __VA_ARGS__ metamacro_consume_ +#define metamacro_if_eq0_1(...) metamacro_expand_ +#define metamacro_if_eq0_2(...) metamacro_expand_ +#define metamacro_if_eq0_3(...) metamacro_expand_ +#define metamacro_if_eq0_4(...) metamacro_expand_ +#define metamacro_if_eq0_5(...) metamacro_expand_ +#define metamacro_if_eq0_6(...) metamacro_expand_ +#define metamacro_if_eq0_7(...) metamacro_expand_ +#define metamacro_if_eq0_8(...) metamacro_expand_ +#define metamacro_if_eq0_9(...) metamacro_expand_ +#define metamacro_if_eq0_10(...) metamacro_expand_ +#define metamacro_if_eq0_11(...) metamacro_expand_ +#define metamacro_if_eq0_12(...) metamacro_expand_ +#define metamacro_if_eq0_13(...) metamacro_expand_ +#define metamacro_if_eq0_14(...) metamacro_expand_ +#define metamacro_if_eq0_15(...) metamacro_expand_ +#define metamacro_if_eq0_16(...) metamacro_expand_ +#define metamacro_if_eq0_17(...) metamacro_expand_ +#define metamacro_if_eq0_18(...) metamacro_expand_ +#define metamacro_if_eq0_19(...) metamacro_expand_ +#define metamacro_if_eq0_20(...) metamacro_expand_ + +#define metamacro_if_eq1(VALUE) metamacro_if_eq0(metamacro_dec(VALUE)) +#define metamacro_if_eq2(VALUE) metamacro_if_eq1(metamacro_dec(VALUE)) +#define metamacro_if_eq3(VALUE) metamacro_if_eq2(metamacro_dec(VALUE)) +#define metamacro_if_eq4(VALUE) metamacro_if_eq3(metamacro_dec(VALUE)) +#define metamacro_if_eq5(VALUE) metamacro_if_eq4(metamacro_dec(VALUE)) +#define metamacro_if_eq6(VALUE) metamacro_if_eq5(metamacro_dec(VALUE)) +#define metamacro_if_eq7(VALUE) metamacro_if_eq6(metamacro_dec(VALUE)) +#define metamacro_if_eq8(VALUE) metamacro_if_eq7(metamacro_dec(VALUE)) +#define metamacro_if_eq9(VALUE) metamacro_if_eq8(metamacro_dec(VALUE)) +#define metamacro_if_eq10(VALUE) metamacro_if_eq9(metamacro_dec(VALUE)) +#define metamacro_if_eq11(VALUE) metamacro_if_eq10(metamacro_dec(VALUE)) +#define metamacro_if_eq12(VALUE) metamacro_if_eq11(metamacro_dec(VALUE)) +#define metamacro_if_eq13(VALUE) metamacro_if_eq12(metamacro_dec(VALUE)) +#define metamacro_if_eq14(VALUE) metamacro_if_eq13(metamacro_dec(VALUE)) +#define metamacro_if_eq15(VALUE) metamacro_if_eq14(metamacro_dec(VALUE)) +#define metamacro_if_eq16(VALUE) metamacro_if_eq15(metamacro_dec(VALUE)) +#define metamacro_if_eq17(VALUE) metamacro_if_eq16(metamacro_dec(VALUE)) +#define metamacro_if_eq18(VALUE) metamacro_if_eq17(metamacro_dec(VALUE)) +#define metamacro_if_eq19(VALUE) metamacro_if_eq18(metamacro_dec(VALUE)) +#define metamacro_if_eq20(VALUE) metamacro_if_eq19(metamacro_dec(VALUE)) + +// metamacro_if_eq_recursive expansions +#define metamacro_if_eq_recursive0(VALUE) \ + metamacro_concat(metamacro_if_eq_recursive0_, VALUE) + +#define metamacro_if_eq_recursive0_0(...) __VA_ARGS__ metamacro_consume_ +#define metamacro_if_eq_recursive0_1(...) metamacro_expand_ +#define metamacro_if_eq_recursive0_2(...) metamacro_expand_ +#define metamacro_if_eq_recursive0_3(...) metamacro_expand_ +#define metamacro_if_eq_recursive0_4(...) metamacro_expand_ +#define metamacro_if_eq_recursive0_5(...) metamacro_expand_ +#define metamacro_if_eq_recursive0_6(...) metamacro_expand_ +#define metamacro_if_eq_recursive0_7(...) metamacro_expand_ +#define metamacro_if_eq_recursive0_8(...) metamacro_expand_ +#define metamacro_if_eq_recursive0_9(...) metamacro_expand_ +#define metamacro_if_eq_recursive0_10(...) metamacro_expand_ +#define metamacro_if_eq_recursive0_11(...) metamacro_expand_ +#define metamacro_if_eq_recursive0_12(...) metamacro_expand_ +#define metamacro_if_eq_recursive0_13(...) metamacro_expand_ +#define metamacro_if_eq_recursive0_14(...) metamacro_expand_ +#define metamacro_if_eq_recursive0_15(...) metamacro_expand_ +#define metamacro_if_eq_recursive0_16(...) metamacro_expand_ +#define metamacro_if_eq_recursive0_17(...) metamacro_expand_ +#define metamacro_if_eq_recursive0_18(...) metamacro_expand_ +#define metamacro_if_eq_recursive0_19(...) metamacro_expand_ +#define metamacro_if_eq_recursive0_20(...) metamacro_expand_ + +#define metamacro_if_eq_recursive1(VALUE) metamacro_if_eq_recursive0(metamacro_dec(VALUE)) +#define metamacro_if_eq_recursive2(VALUE) metamacro_if_eq_recursive1(metamacro_dec(VALUE)) +#define metamacro_if_eq_recursive3(VALUE) metamacro_if_eq_recursive2(metamacro_dec(VALUE)) +#define metamacro_if_eq_recursive4(VALUE) metamacro_if_eq_recursive3(metamacro_dec(VALUE)) +#define metamacro_if_eq_recursive5(VALUE) metamacro_if_eq_recursive4(metamacro_dec(VALUE)) +#define metamacro_if_eq_recursive6(VALUE) metamacro_if_eq_recursive5(metamacro_dec(VALUE)) +#define metamacro_if_eq_recursive7(VALUE) metamacro_if_eq_recursive6(metamacro_dec(VALUE)) +#define metamacro_if_eq_recursive8(VALUE) metamacro_if_eq_recursive7(metamacro_dec(VALUE)) +#define metamacro_if_eq_recursive9(VALUE) metamacro_if_eq_recursive8(metamacro_dec(VALUE)) +#define metamacro_if_eq_recursive10(VALUE) metamacro_if_eq_recursive9(metamacro_dec(VALUE)) +#define metamacro_if_eq_recursive11(VALUE) metamacro_if_eq_recursive10(metamacro_dec(VALUE)) +#define metamacro_if_eq_recursive12(VALUE) metamacro_if_eq_recursive11(metamacro_dec(VALUE)) +#define metamacro_if_eq_recursive13(VALUE) metamacro_if_eq_recursive12(metamacro_dec(VALUE)) +#define metamacro_if_eq_recursive14(VALUE) metamacro_if_eq_recursive13(metamacro_dec(VALUE)) +#define metamacro_if_eq_recursive15(VALUE) metamacro_if_eq_recursive14(metamacro_dec(VALUE)) +#define metamacro_if_eq_recursive16(VALUE) metamacro_if_eq_recursive15(metamacro_dec(VALUE)) +#define metamacro_if_eq_recursive17(VALUE) metamacro_if_eq_recursive16(metamacro_dec(VALUE)) +#define metamacro_if_eq_recursive18(VALUE) metamacro_if_eq_recursive17(metamacro_dec(VALUE)) +#define metamacro_if_eq_recursive19(VALUE) metamacro_if_eq_recursive18(metamacro_dec(VALUE)) +#define metamacro_if_eq_recursive20(VALUE) metamacro_if_eq_recursive19(metamacro_dec(VALUE)) + +// metamacro_take expansions +#define metamacro_take0(...) +#define metamacro_take1(...) metamacro_head(__VA_ARGS__) +#define metamacro_take2(...) metamacro_head(__VA_ARGS__), metamacro_take1(metamacro_tail(__VA_ARGS__)) +#define metamacro_take3(...) metamacro_head(__VA_ARGS__), metamacro_take2(metamacro_tail(__VA_ARGS__)) +#define metamacro_take4(...) metamacro_head(__VA_ARGS__), metamacro_take3(metamacro_tail(__VA_ARGS__)) +#define metamacro_take5(...) metamacro_head(__VA_ARGS__), metamacro_take4(metamacro_tail(__VA_ARGS__)) +#define metamacro_take6(...) metamacro_head(__VA_ARGS__), metamacro_take5(metamacro_tail(__VA_ARGS__)) +#define metamacro_take7(...) metamacro_head(__VA_ARGS__), metamacro_take6(metamacro_tail(__VA_ARGS__)) +#define metamacro_take8(...) metamacro_head(__VA_ARGS__), metamacro_take7(metamacro_tail(__VA_ARGS__)) +#define metamacro_take9(...) metamacro_head(__VA_ARGS__), metamacro_take8(metamacro_tail(__VA_ARGS__)) +#define metamacro_take10(...) metamacro_head(__VA_ARGS__), metamacro_take9(metamacro_tail(__VA_ARGS__)) +#define metamacro_take11(...) metamacro_head(__VA_ARGS__), metamacro_take10(metamacro_tail(__VA_ARGS__)) +#define metamacro_take12(...) metamacro_head(__VA_ARGS__), metamacro_take11(metamacro_tail(__VA_ARGS__)) +#define metamacro_take13(...) metamacro_head(__VA_ARGS__), metamacro_take12(metamacro_tail(__VA_ARGS__)) +#define metamacro_take14(...) metamacro_head(__VA_ARGS__), metamacro_take13(metamacro_tail(__VA_ARGS__)) +#define metamacro_take15(...) metamacro_head(__VA_ARGS__), metamacro_take14(metamacro_tail(__VA_ARGS__)) +#define metamacro_take16(...) metamacro_head(__VA_ARGS__), metamacro_take15(metamacro_tail(__VA_ARGS__)) +#define metamacro_take17(...) metamacro_head(__VA_ARGS__), metamacro_take16(metamacro_tail(__VA_ARGS__)) +#define metamacro_take18(...) metamacro_head(__VA_ARGS__), metamacro_take17(metamacro_tail(__VA_ARGS__)) +#define metamacro_take19(...) metamacro_head(__VA_ARGS__), metamacro_take18(metamacro_tail(__VA_ARGS__)) +#define metamacro_take20(...) metamacro_head(__VA_ARGS__), metamacro_take19(metamacro_tail(__VA_ARGS__)) + +// metamacro_drop expansions +#define metamacro_drop0(...) __VA_ARGS__ +#define metamacro_drop1(...) metamacro_tail(__VA_ARGS__) +#define metamacro_drop2(...) metamacro_drop1(metamacro_tail(__VA_ARGS__)) +#define metamacro_drop3(...) metamacro_drop2(metamacro_tail(__VA_ARGS__)) +#define metamacro_drop4(...) metamacro_drop3(metamacro_tail(__VA_ARGS__)) +#define metamacro_drop5(...) metamacro_drop4(metamacro_tail(__VA_ARGS__)) +#define metamacro_drop6(...) metamacro_drop5(metamacro_tail(__VA_ARGS__)) +#define metamacro_drop7(...) metamacro_drop6(metamacro_tail(__VA_ARGS__)) +#define metamacro_drop8(...) metamacro_drop7(metamacro_tail(__VA_ARGS__)) +#define metamacro_drop9(...) metamacro_drop8(metamacro_tail(__VA_ARGS__)) +#define metamacro_drop10(...) metamacro_drop9(metamacro_tail(__VA_ARGS__)) +#define metamacro_drop11(...) metamacro_drop10(metamacro_tail(__VA_ARGS__)) +#define metamacro_drop12(...) metamacro_drop11(metamacro_tail(__VA_ARGS__)) +#define metamacro_drop13(...) metamacro_drop12(metamacro_tail(__VA_ARGS__)) +#define metamacro_drop14(...) metamacro_drop13(metamacro_tail(__VA_ARGS__)) +#define metamacro_drop15(...) metamacro_drop14(metamacro_tail(__VA_ARGS__)) +#define metamacro_drop16(...) metamacro_drop15(metamacro_tail(__VA_ARGS__)) +#define metamacro_drop17(...) metamacro_drop16(metamacro_tail(__VA_ARGS__)) +#define metamacro_drop18(...) metamacro_drop17(metamacro_tail(__VA_ARGS__)) +#define metamacro_drop19(...) metamacro_drop18(metamacro_tail(__VA_ARGS__)) +#define metamacro_drop20(...) metamacro_drop19(metamacro_tail(__VA_ARGS__)) + +#endif
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/NSControlRACSupportSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/NSControlRACSupportSpec.m new file mode 100644 index 0000000..1825277 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/NSControlRACSupportSpec.m
@@ -0,0 +1,106 @@ +// +// NSControlRACSupportSpec.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 9/4/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACControlCommandExamples.h" + +#import "NSControl+RACCommandSupport.h" +#import "NSControl+RACTextSignalSupport.h" +#import "NSObject+RACDeallocating.h" +#import "NSObject+RACPropertySubscribing.h" +#import "RACCommand.h" +#import "RACCompoundDisposable.h" +#import "RACDisposable.h" +#import "RACSubject.h" + +SpecBegin(NSControlRACSupport) + +describe(@"NSButton", ^{ + __block NSButton *button; + + beforeEach(^{ + button = [[NSButton alloc] initWithFrame:NSZeroRect]; + expect(button).notTo.beNil(); + }); + + itShouldBehaveLike(RACControlCommandExamples, ^{ + return @{ + RACControlCommandExampleControl: button, + RACControlCommandExampleActivateBlock: ^(NSButton *button) { + [button performClick:nil]; + } + }; + }); +}); + +describe(@"NSTextField", ^{ + __block NSTextField *field; + __block NSWindow *window; + + beforeEach(^{ + field = [[NSTextField alloc] initWithFrame:NSZeroRect]; + expect(field).notTo.beNil(); + + [field.cell setSendsActionOnEndEditing:YES]; + + window = [[NSWindow alloc] initWithContentRect:NSZeroRect styleMask:NSTitledWindowMask backing:NSBackingStoreBuffered defer:NO]; + expect(window).notTo.beNil(); + + [window.contentView addSubview:field]; + + expect([window makeFirstResponder:field]).to.beTruthy(); + expect(window.firstResponder).notTo.equal(window); + }); + + itShouldBehaveLike(RACControlCommandExamples, ^{ + return @{ + RACControlCommandExampleControl: field, + RACControlCommandExampleActivateBlock: ^(NSTextField *field) { + expect([window makeFirstResponder:nil]).to.beTruthy(); + expect(window.firstResponder).to.equal(window); + } + }; + }); + + describe(@"-rac_textSignal", ^{ + it(@"should send changes", ^{ + NSMutableArray *strings = [NSMutableArray array]; + [field.rac_textSignal subscribeNext:^(NSString *str) { + [strings addObject:str]; + }]; + + expect(strings).to.equal(@[ @"" ]); + + NSText *fieldEditor = (id)window.firstResponder; + expect(fieldEditor).to.beKindOf(NSText.class); + + [fieldEditor insertText:@"f"]; + [fieldEditor insertText:@"o"]; + [fieldEditor insertText:@"b"]; + + NSArray *expected = @[ @"", @"f", @"fo", @"fob" ]; + expect(strings).to.equal(expected); + }); + + it(@"shouldn't give the text field eternal life", ^{ + __block BOOL dealloced = NO; + @autoreleasepool { + NSTextField *field __attribute__((objc_precise_lifetime)) = [[NSTextField alloc] initWithFrame:CGRectZero]; + [field.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + dealloced = YES; + }]]; + [field.rac_textSignal subscribeNext:^(id x) { + + }]; + } + + expect(dealloced).will.beTruthy(); + }); + }); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/NSControllerRACSupportSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/NSControllerRACSupportSpec.m new file mode 100644 index 0000000..d309b25 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/NSControllerRACSupportSpec.m
@@ -0,0 +1,44 @@ +// +// NSControllerRACSupportSpec.m +// ReactiveCocoa +// +// Created by Uri Baghin on 26/10/13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import <AppKit/AppKit.h> +#import "RACKVOChannel.h" + +@interface RACTestController : NSController + +@property (nonatomic, strong) id object; + +@end + +@implementation RACTestController + +@end + +SpecBegin(NSControllerRACSupport) + +it(@"RACKVOChannel should support NSController", ^{ + RACTestController *a = [[RACTestController alloc] init]; + RACTestController *b = [[RACTestController alloc] init]; + RACChannelTo(a, object) = RACChannelTo(b, object); + expect(a.object).to.beNil(); + expect(b.object).to.beNil(); + + a.object = a; + expect(a.object).to.equal(a); + expect(b.object).to.equal(a); + + b.object = b; + expect(a.object).to.equal(b); + expect(b.object).to.equal(b); + + a.object = nil; + expect(a.object).to.beNil(); + expect(b.object).to.beNil(); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/NSEnumeratorRACSequenceAdditionsSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/NSEnumeratorRACSequenceAdditionsSpec.m new file mode 100644 index 0000000..50328bd --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/NSEnumeratorRACSequenceAdditionsSpec.m
@@ -0,0 +1,25 @@ +// +// NSEnumeratorRACSequenceAdditionsSpec.m +// ReactiveCocoa +// +// Created by Uri Baghin on 07/01/2013. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACSequenceExamples.h" + +#import "NSEnumerator+RACSequenceAdditions.h" + +SpecBegin(NSEnumeratorRACSequenceAdditions) + +describe(@"-rac_sequence", ^{ + NSArray *values = @[ @0, @1, @2, @3, @4 ]; + itShouldBehaveLike(RACSequenceExamples, ^{ + return @{ + RACSequenceExampleSequence: values.objectEnumerator.rac_sequence, + RACSequenceExampleExpectedValues: values + }; + }); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/NSNotificationCenterRACSupportSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/NSNotificationCenterRACSupportSpec.m new file mode 100644 index 0000000..26143df --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/NSNotificationCenterRACSupportSpec.m
@@ -0,0 +1,84 @@ +// +// NSNotificationCenterRACSupportSpec.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-12-07. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "NSNotificationCenter+RACSupport.h" +#import "RACSignal.h" +#import "RACCompoundDisposable.h" +#import "RACDisposable.h" +#import "NSObject+RACDeallocating.h" + +static NSString * const TestNotification = @"TestNotification"; + +SpecBegin(NSNotificationCenterRACSupport) + +__block NSNotificationCenter *notificationCenter; + +beforeEach(^{ + // The compiler gets confused and thinks you might be messaging + // NSDistributedNotificationCenter otherwise. Wtf? + notificationCenter = NSNotificationCenter.defaultCenter; +}); + +it(@"should send the notification when posted by any object", ^{ + RACSignal *signal = [notificationCenter rac_addObserverForName:TestNotification object:nil]; + + __block NSUInteger count = 0; + [signal subscribeNext:^(NSNotification *notification) { + ++count; + + expect(notification).to.beKindOf(NSNotification.class); + expect(notification.name).to.equal(TestNotification); + }]; + + expect(count).to.equal(0); + + [notificationCenter postNotificationName:TestNotification object:nil]; + expect(count).to.equal(1); + + [notificationCenter postNotificationName:TestNotification object:self]; + expect(count).to.equal(2); +}); + +it(@"should send the notification when posted by a specific object", ^{ + RACSignal *signal = [notificationCenter rac_addObserverForName:TestNotification object:self]; + + __block NSUInteger count = 0; + [signal subscribeNext:^(NSNotification *notification) { + ++count; + + expect(notification).to.beKindOf(NSNotification.class); + expect(notification.name).to.equal(TestNotification); + expect(notification.object).to.equal(self); + }]; + + expect(count).to.equal(0); + + [notificationCenter postNotificationName:TestNotification object:nil]; + expect(count).to.equal(0); + + [notificationCenter postNotificationName:TestNotification object:self]; + expect(count).to.equal(1); +}); + +it(@"shouldn't strongly capture the notification object", ^{ + RACSignal *signal __attribute__((objc_precise_lifetime, unused)); + + __block BOOL dealloced = NO; + @autoreleasepool { + NSObject *notificationObject = [[NSObject alloc] init]; + [notificationObject.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + dealloced = YES; + }]]; + + signal = [notificationCenter rac_addObserverForName:TestNotification object:notificationObject]; + } + + expect(dealloced).to.beTruthy(); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACAppKitBindingsSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACAppKitBindingsSpec.m new file mode 100644 index 0000000..fcb4837 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACAppKitBindingsSpec.m
@@ -0,0 +1,36 @@ +// +// NSObjectRACAppKitBindingsSpec.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-07-01. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACChannelExamples.h" + +#import "EXTKeyPathCoding.h" +#import "NSObject+RACAppKitBindings.h" + +SpecBegin(NSObjectRACAppKitBindings) + +itShouldBehaveLike(RACViewChannelExamples, ^{ + return @{ + RACViewChannelExampleCreateViewBlock: ^{ + return [[NSSlider alloc] initWithFrame:NSZeroRect]; + }, + RACViewChannelExampleCreateTerminalBlock: ^(NSSlider *view) { + return [view rac_channelToBinding:NSValueBinding]; + }, + RACViewChannelExampleKeyPath: @keypath(NSSlider.new, objectValue), + RACViewChannelExampleSetViewValueBlock: ^(NSSlider *view, NSNumber *value) { + view.objectValue = value; + + // Bindings don't actually trigger from programmatic modification. Do it + // manually. + NSDictionary *bindingInfo = [view infoForBinding:NSValueBinding]; + [bindingInfo[NSObservedObjectKey] setValue:value forKeyPath:bindingInfo[NSObservedKeyPathKey]]; + } + }; +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACDeallocatingSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACDeallocatingSpec.m new file mode 100644 index 0000000..b5e80b2 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACDeallocatingSpec.m
@@ -0,0 +1,195 @@ +// +// NSObject+RACDeallocating.m +// ReactiveCocoa +// +// Created by Kazuo Koga on 2013/03/15. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACTestObject.h" + +#import "NSObject+RACDeallocating.h" +#import "RACCompoundDisposable.h" +#import "RACDisposable.h" +#import "RACSignal+Operations.h" +#import <objc/runtime.h> + +@interface RACDeallocSwizzlingTestClass : NSObject +@end + +@implementation RACDeallocSwizzlingTestClass + +- (void)dealloc { + // Provide an empty implementation just so we can swizzle it. +} + +@end + +@interface RACDeallocSwizzlingTestSubclass : RACDeallocSwizzlingTestClass +@end + +@implementation RACDeallocSwizzlingTestSubclass +@end + +SpecBegin(NSObjectRACDeallocatingSpec) + +describe(@"-dealloc swizzling", ^{ + SEL selector = NSSelectorFromString(@"dealloc"); + + it(@"should not invoke superclass -dealloc method twice", ^{ + __block NSUInteger superclassDeallocatedCount = 0; + __block BOOL subclassDeallocated = NO; + + @autoreleasepool { + RACDeallocSwizzlingTestSubclass *object __attribute__((objc_precise_lifetime)) = [[RACDeallocSwizzlingTestSubclass alloc] init]; + + Method oldDeallocMethod = class_getInstanceMethod(RACDeallocSwizzlingTestClass.class, selector); + void (*oldDealloc)(id, SEL) = (__typeof__(oldDealloc))method_getImplementation(oldDeallocMethod); + + id newDealloc = ^(__unsafe_unretained id self) { + superclassDeallocatedCount++; + oldDealloc(self, selector); + }; + + class_replaceMethod(RACDeallocSwizzlingTestClass.class, selector, imp_implementationWithBlock(newDealloc), method_getTypeEncoding(oldDeallocMethod)); + + [object.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + subclassDeallocated = YES; + }]]; + + expect(subclassDeallocated).to.beFalsy(); + expect(superclassDeallocatedCount).to.equal(0); + } + + expect(subclassDeallocated).to.beTruthy(); + expect(superclassDeallocatedCount).to.equal(1); + }); + + it(@"should invoke superclass -dealloc method swizzled in after the subclass", ^{ + __block BOOL superclassDeallocated = NO; + __block BOOL subclassDeallocated = NO; + + @autoreleasepool { + RACDeallocSwizzlingTestSubclass *object __attribute__((objc_precise_lifetime)) = [[RACDeallocSwizzlingTestSubclass alloc] init]; + [object.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + subclassDeallocated = YES; + }]]; + + Method oldDeallocMethod = class_getInstanceMethod(RACDeallocSwizzlingTestClass.class, selector); + void (*oldDealloc)(id, SEL) = (__typeof__(oldDealloc))method_getImplementation(oldDeallocMethod); + + id newDealloc = ^(__unsafe_unretained id self) { + superclassDeallocated = YES; + oldDealloc(self, selector); + }; + + class_replaceMethod(RACDeallocSwizzlingTestClass.class, selector, imp_implementationWithBlock(newDealloc), method_getTypeEncoding(oldDeallocMethod)); + + expect(subclassDeallocated).to.beFalsy(); + expect(superclassDeallocated).to.beFalsy(); + } + + expect(subclassDeallocated).to.beTruthy(); + expect(superclassDeallocated).to.beTruthy(); + }); +}); + +describe(@"-rac_deallocDisposable", ^{ + it(@"should dispose of the disposable when it is dealloc'd", ^{ + __block BOOL wasDisposed = NO; + @autoreleasepool { + NSObject *object __attribute__((objc_precise_lifetime)) = [[NSObject alloc] init]; + [object.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + wasDisposed = YES; + }]]; + + expect(wasDisposed).to.beFalsy(); + } + + expect(wasDisposed).to.beTruthy(); + }); + + it(@"should be able to use the object during disposal", ^{ + @autoreleasepool { + RACTestObject *object __attribute__((objc_precise_lifetime)) = [[RACTestObject alloc] init]; + + @autoreleasepool { + object.objectValue = [@"foo" mutableCopy]; + } + + __unsafe_unretained RACTestObject *weakObject = object; + + [object.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + expect(weakObject.objectValue).to.equal(@"foo"); + }]]; + } + }); +}); + +describe(@"-rac_willDeallocSignal", ^{ + it(@"should complete on dealloc", ^{ + __block BOOL completed = NO; + @autoreleasepool { + [[[[RACTestObject alloc] init] rac_willDeallocSignal] subscribeCompleted:^{ + completed = YES; + }]; + } + + expect(completed).to.beTruthy(); + }); + + it(@"should not send anything", ^{ + __block BOOL valueReceived = NO; + __block BOOL completed = NO; + @autoreleasepool { + [[[[RACTestObject alloc] init] rac_willDeallocSignal] subscribeNext:^(id x) { + valueReceived = YES; + } completed:^{ + completed = YES; + }]; + } + + expect(valueReceived).to.beFalsy(); + expect(completed).to.beTruthy(); + }); + + it(@"should complete upon subscription if already deallocated", ^{ + __block BOOL deallocated = NO; + + RACSignal *signal; + + @autoreleasepool { + RACTestObject *object = [[RACTestObject alloc] init]; + + signal = [object rac_willDeallocSignal]; + [signal subscribeCompleted:^{ + deallocated = YES; + }]; + } + + expect(deallocated).to.beTruthy(); + expect([signal waitUntilCompleted:NULL]).to.beTruthy(); + }); + + it(@"should complete before the object is invalid", ^{ + __block NSString *objectValue; + + @autoreleasepool { + RACTestObject *object __attribute__((objc_precise_lifetime)) = [[RACTestObject alloc] init]; + + @autoreleasepool { + object.objectValue = [@"foo" mutableCopy]; + } + + __unsafe_unretained RACTestObject *weakObject = object; + + [[object rac_willDeallocSignal] subscribeCompleted:^{ + objectValue = [weakObject.objectValue copy]; + }]; + } + + expect(objectValue).to.equal(@"foo"); + }); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACLiftingSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACLiftingSpec.m new file mode 100644 index 0000000..7a2acfc --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACLiftingSpec.m
@@ -0,0 +1,407 @@ +// +// NSObjectRACLifting.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 10/2/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACTestObject.h" + +#import "NSObject+RACLifting.h" +#import "NSObject+RACDeallocating.h" +#import "NSObject+RACPropertySubscribing.h" +#import "RACCompoundDisposable.h" +#import "RACDisposable.h" +#import "RACSubject.h" +#import "RACTuple.h" +#import "RACUnit.h" + +SpecBegin(NSObjectRACLifting) + +describe(@"-rac_liftSelector:withSignals:", ^{ + __block RACTestObject *object; + + beforeEach(^{ + object = [[RACTestObject alloc] init]; + }); + + it(@"should call the selector with the value of the signal", ^{ + RACSubject *subject = [RACSubject subject]; + [object rac_liftSelector:@selector(setObjectValue:) withSignals:subject, nil]; + + expect(object.objectValue).to.beNil(); + + [subject sendNext:@1]; + expect(object.objectValue).to.equal(@1); + + [subject sendNext:@42]; + expect(object.objectValue).to.equal(@42); + }); +}); + +describe(@"-rac_liftSelector:withSignalsFromArray:", ^{ + __block RACTestObject *object; + + beforeEach(^{ + object = [[RACTestObject alloc] init]; + }); + + it(@"should call the selector with the value of the signal", ^{ + RACSubject *subject = [RACSubject subject]; + [object rac_liftSelector:@selector(setObjectValue:) withSignalsFromArray:@[ subject ]]; + + expect(object.objectValue).to.beNil(); + + [subject sendNext:@1]; + expect(object.objectValue).to.equal(@1); + + [subject sendNext:@42]; + expect(object.objectValue).to.equal(@42); + }); + + it(@"should call the selector with the value of the signal unboxed", ^{ + RACSubject *subject = [RACSubject subject]; + [object rac_liftSelector:@selector(setIntegerValue:) withSignalsFromArray:@[ subject ]]; + + expect(object.integerValue).to.equal(0); + + [subject sendNext:@1]; + expect(object.integerValue).to.equal(1); + + [subject sendNext:@42]; + expect(object.integerValue).to.equal(42); + }); + + it(@"should work with multiple arguments", ^{ + RACSubject *objectValueSubject = [RACSubject subject]; + RACSubject *integerValueSubject = [RACSubject subject]; + [object rac_liftSelector:@selector(setObjectValue:andIntegerValue:) withSignalsFromArray:@[ objectValueSubject, integerValueSubject ]]; + + expect(object.hasInvokedSetObjectValueAndIntegerValue).to.beFalsy(); + expect(object.objectValue).to.beNil(); + expect(object.integerValue).to.equal(0); + + [objectValueSubject sendNext:@1]; + expect(object.hasInvokedSetObjectValueAndIntegerValue).to.beFalsy(); + expect(object.objectValue).to.beNil(); + expect(object.integerValue).to.equal(0); + + [integerValueSubject sendNext:@42]; + expect(object.hasInvokedSetObjectValueAndIntegerValue).to.beTruthy(); + expect(object.objectValue).to.equal(@1); + expect(object.integerValue).to.equal(42); + }); + + it(@"should work with signals that immediately start with a value", ^{ + RACSubject *subject = [RACSubject subject]; + [object rac_liftSelector:@selector(setObjectValue:) withSignalsFromArray:@[ [subject startWith:@42] ]]; + + expect(object.objectValue).to.equal(@42); + + [subject sendNext:@1]; + expect(object.objectValue).to.equal(@1); + }); + + it(@"should work with signals that send nil", ^{ + RACSubject *subject = [RACSubject subject]; + [object rac_liftSelector:@selector(setObjectValue:) withSignalsFromArray:@[ subject ]]; + + [subject sendNext:nil]; + expect(object.objectValue).to.equal(nil); + + [subject sendNext:RACTupleNil.tupleNil]; + expect(object.objectValue).to.equal(nil); + }); + + it(@"should work with integers", ^{ + RACSubject *subject = [RACSubject subject]; + [object rac_liftSelector:@selector(setIntegerValue:) withSignalsFromArray:@[ subject ]]; + + expect(object.integerValue).to.equal(0); + + [subject sendNext:@1]; + expect(object.integerValue).to.equal(@1); + }); + + it(@"should convert between numeric types", ^{ + RACSubject *subject = [RACSubject subject]; + [object rac_liftSelector:@selector(setIntegerValue:) withSignalsFromArray:@[ subject ]]; + + expect(object.integerValue).to.equal(0); + + [subject sendNext:@1.0]; + expect(object.integerValue).to.equal(@1); + }); + + it(@"should work with class objects", ^{ + RACSubject *subject = [RACSubject subject]; + [object rac_liftSelector:@selector(setObjectValue:) withSignalsFromArray:@[ subject ]]; + + expect(object.objectValue).to.equal(nil); + + [subject sendNext:self.class]; + expect(object.objectValue).to.equal(self.class); + }); + + it(@"should work for char pointer", ^{ + RACSubject *subject = [RACSubject subject]; + [object rac_liftSelector:@selector(setCharPointerValue:) withSignalsFromArray:@[ subject ]]; + + expect(object.charPointerValue).to.equal(NULL); + + NSString *string = @"blah blah blah"; + [subject sendNext:string]; + expect(@(object.charPointerValue)).to.equal(string); + }); + + it(@"should work for const char pointer", ^{ + RACSubject *subject = [RACSubject subject]; + [object rac_liftSelector:@selector(setConstCharPointerValue:) withSignalsFromArray:@[ subject ]]; + + expect(object.constCharPointerValue).to.equal(NULL); + + NSString *string = @"blah blah blah"; + [subject sendNext:string]; + expect(@(object.constCharPointerValue)).to.equal(string); + }); + + it(@"should work for CGRect", ^{ + RACSubject *subject = [RACSubject subject]; + [object rac_liftSelector:@selector(setRectValue:) withSignalsFromArray:@[ subject ]]; + + expect(object.rectValue).to.equal(CGRectZero); + + CGRect value = CGRectMake(10, 20, 30, 40); + [subject sendNext:[NSValue valueWithBytes:&value objCType:@encode(CGRect)]]; + expect(object.rectValue).to.equal(value); + }); + + it(@"should work for CGSize", ^{ + RACSubject *subject = [RACSubject subject]; + [object rac_liftSelector:@selector(setSizeValue:) withSignalsFromArray:@[ subject ]]; + + expect(object.sizeValue).to.equal(CGSizeZero); + + CGSize value = CGSizeMake(10, 20); + [subject sendNext:[NSValue valueWithBytes:&value objCType:@encode(CGSize)]]; + expect(object.sizeValue).to.equal(value); + }); + + it(@"should work for CGPoint", ^{ + RACSubject *subject = [RACSubject subject]; + [object rac_liftSelector:@selector(setPointValue:) withSignalsFromArray:@[ subject ]]; + + expect(object.pointValue).to.equal(CGPointZero); + + CGPoint value = CGPointMake(10, 20); + [subject sendNext:[NSValue valueWithBytes:&value objCType:@encode(CGPoint)]]; + expect(object.pointValue).to.equal(value); + }); + + it(@"should work for NSRange", ^{ + RACSubject *subject = [RACSubject subject]; + [object rac_liftSelector:@selector(setRangeValue:) withSignalsFromArray:@[ subject ]]; + + expect(NSEqualRanges(object.rangeValue, NSMakeRange(0, 0))).to.beTruthy(); + + NSRange value = NSMakeRange(10, 20); + [subject sendNext:[NSValue valueWithRange:value]]; + expect(NSEqualRanges(object.rangeValue, value)).to.beTruthy(); + }); + + it(@"should work for _Bool", ^{ + RACSubject *subject = [RACSubject subject]; + [object rac_liftSelector:@selector(setC99BoolValue:) withSignalsFromArray:@[ subject ]]; + + expect(object.c99BoolValue).to.beFalsy(); + + _Bool value = true; + [subject sendNext:@(value)]; + expect(object.c99BoolValue).to.beTruthy(); + }); + + it(@"should work for primitive pointers", ^{ + RACSubject *subject = [RACSubject subject]; + [object rac_liftSelector:@selector(write5ToIntPointer:) withSignalsFromArray:@[ subject ]]; + + int value = 0; + int *valuePointer = &value; + expect(value).to.equal(0); + + [subject sendNext:[NSValue valueWithPointer:valuePointer]]; + expect(value).to.equal(5); + }); + + it(@"should work for custom structs", ^{ + RACSubject *subject = [RACSubject subject]; + [object rac_liftSelector:@selector(setStructValue:) withSignalsFromArray:@[ subject ]]; + + expect(object.structValue.integerField).to.equal(0); + expect(object.structValue.doubleField).to.equal(0.0); + + RACTestStruct value = (RACTestStruct){7, 1.23}; + [subject sendNext:[NSValue valueWithBytes:&value objCType:@encode(typeof(value))]]; + expect(object.structValue.integerField).to.equal(value.integerField); + expect(object.structValue.doubleField).to.equal(value.doubleField); + }); + + it(@"should send the latest value of the signal as the right argument", ^{ + RACSubject *subject = [RACSubject subject]; + [object rac_liftSelector:@selector(setObjectValue:andIntegerValue:) withSignalsFromArray:@[ [RACSignal return:@"object"], subject ]]; + [subject sendNext:@1]; + + expect(object.objectValue).to.equal(@"object"); + expect(object.integerValue).to.equal(1); + }); + + describe(@"the returned signal", ^{ + it(@"should send the return value of the method invocation", ^{ + RACSubject *objectSubject = [RACSubject subject]; + RACSubject *integerSubject = [RACSubject subject]; + RACSignal *signal = [object rac_liftSelector:@selector(combineObjectValue:andIntegerValue:) withSignalsFromArray:@[ objectSubject, integerSubject ]]; + + __block NSString *result; + [signal subscribeNext:^(id x) { + result = x; + }]; + + [objectSubject sendNext:@"Magic number"]; + expect(result).to.beNil(); + + [integerSubject sendNext:@42]; + expect(result).to.equal(@"Magic number: 42"); + }); + + it(@"should send RACUnit.defaultUnit for void-returning methods", ^{ + RACSubject *subject = [RACSubject subject]; + RACSignal *signal = [object rac_liftSelector:@selector(setObjectValue:) withSignalsFromArray:@[ subject ]]; + + __block id result; + [signal subscribeNext:^(id x) { + result = x; + }]; + + [subject sendNext:@1]; + + expect(result).to.equal(RACUnit.defaultUnit); + }); + + it(@"should support integer returning methods", ^{ + RACSubject *subject = [RACSubject subject]; + RACSignal *signal = [object rac_liftSelector:@selector(doubleInteger:) withSignalsFromArray:@[ subject ]]; + + __block id result; + [signal subscribeNext:^(id x) { + result = x; + }]; + + [subject sendNext:@1]; + + expect(result).to.equal(@2); + }); + + it(@"should support char * returning methods", ^{ + RACSubject *subject = [RACSubject subject]; + RACSignal *signal = [object rac_liftSelector:@selector(doubleString:) withSignalsFromArray:@[ subject ]]; + + __block id result; + [signal subscribeNext:^(id x) { + result = x; + }]; + + [subject sendNext:@"test"]; + + expect(result).to.equal(@"testtest"); + }); + + it(@"should support const char * returning methods", ^{ + RACSubject *subject = [RACSubject subject]; + RACSignal *signal = [object rac_liftSelector:@selector(doubleConstString:) withSignalsFromArray:@[ subject ]]; + + __block id result; + [signal subscribeNext:^(id x) { + result = x; + }]; + + [subject sendNext:@"test"]; + + expect(result).to.equal(@"testtest"); + }); + + it(@"should support struct returning methods", ^{ + RACSubject *subject = [RACSubject subject]; + RACSignal *signal = [object rac_liftSelector:@selector(doubleStruct:) withSignalsFromArray:@[ subject ]]; + + __block NSValue *boxedResult; + [signal subscribeNext:^(id x) { + boxedResult = x; + }]; + + RACTestStruct value = {4, 12.3}; + NSValue *boxedValue = [NSValue valueWithBytes:&value objCType:@encode(typeof(value))]; + [subject sendNext:boxedValue]; + + RACTestStruct result = {0, 0.0}; + [boxedResult getValue:&result]; + expect(result.integerField).to.equal(8); + expect(result.doubleField).to.equal(24.6); + }); + + it(@"should support block arguments and returns", ^{ + RACSubject *subject = [RACSubject subject]; + RACSignal *signal = [object rac_liftSelector:@selector(wrapBlock:) withSignalsFromArray:@[ subject ]]; + + __block BOOL blockInvoked = NO; + dispatch_block_t testBlock = ^{ + blockInvoked = YES; + }; + + __block dispatch_block_t result; + [signal subscribeNext:^(id x) { + result = x; + }]; + + [subject sendNext:testBlock]; + expect(result).notTo.beNil(); + + result(); + expect(blockInvoked).to.beTruthy(); + }); + + it(@"should replay the last value", ^{ + RACSubject *objectSubject = [RACSubject subject]; + RACSubject *integerSubject = [RACSubject subject]; + RACSignal *signal = [object rac_liftSelector:@selector(combineObjectValue:andIntegerValue:) withSignalsFromArray:@[ objectSubject, integerSubject ]]; + + [objectSubject sendNext:@"Magic number"]; + [integerSubject sendNext:@42]; + [integerSubject sendNext:@43]; + + __block NSString *result; + [signal subscribeNext:^(id x) { + result = x; + }]; + + expect(result).to.equal(@"Magic number: 43"); + }); + }); + + it(@"shouldn't strongly capture the receiver", ^{ + __block BOOL dealloced = NO; + @autoreleasepool { + RACTestObject *testObject __attribute__((objc_precise_lifetime)) = [[RACTestObject alloc] init]; + [testObject.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + dealloced = YES; + }]]; + + RACSubject *subject = [RACSubject subject]; + [testObject rac_liftSelector:@selector(setObjectValue:) withSignalsFromArray:@[ subject ]]; + [subject sendNext:@1]; + } + + expect(dealloced).to.beTruthy(); + }); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACPropertySubscribingExamples.h b/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACPropertySubscribingExamples.h new file mode 100644 index 0000000..694ce59 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACPropertySubscribingExamples.h
@@ -0,0 +1,16 @@ +// +// NSObjectRACPropertySubscribingExamples.h +// ReactiveCocoa +// +// Created by Josh Vera on 4/10/13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +// The name of the shared examples for a signal-driven observation. +extern NSString * const RACPropertySubscribingExamples; + +// The block should have the signature: +// RACSignal * (^)(RACTestObject *testObject, NSString *keyPath, id observer) +// and should observe the value of the key path on testObject with observer. The value +// for this key should not be nil. +extern NSString * const RACPropertySubscribingExamplesSetupBlock;
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACPropertySubscribingExamples.m b/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACPropertySubscribingExamples.m new file mode 100644 index 0000000..1dae113 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACPropertySubscribingExamples.m
@@ -0,0 +1,279 @@ +// +// NSObjectRACPropertySubscribingExamples.m +// ReactiveCocoa +// +// Created by Josh Vera on 4/10/13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACTestObject.h" +#import "NSObjectRACPropertySubscribingExamples.h" + +#import "EXTScope.h" +#import "NSObject+RACDeallocating.h" +#import "NSObject+RACPropertySubscribing.h" +#import "RACCompoundDisposable.h" +#import "RACDisposable.h" +#import "RACSignal.h" + +NSString * const RACPropertySubscribingExamples = @"RACPropertySubscribingExamples"; +NSString * const RACPropertySubscribingExamplesSetupBlock = @"RACPropertySubscribingExamplesSetupBlock"; + +SharedExamplesBegin(NSObjectRACPropertySubscribingExamples) + +sharedExamples(RACPropertySubscribingExamples, ^(NSDictionary *data) { + __block RACSignal *(^signalBlock)(RACTestObject *object, NSString *keyPath, id observer); + + before(^{ + signalBlock = data[RACPropertySubscribingExamplesSetupBlock]; + }); + + it(@"should send the current value once on subscription", ^{ + RACTestObject *object = [[RACTestObject alloc] init]; + RACSignal *signal = signalBlock(object, @keypath(object, objectValue), self); + NSMutableArray *values = [NSMutableArray array]; + + object.objectValue = @0; + [signal subscribeNext:^(id x) { + [values addObject:x]; + }]; + + expect(values).to.equal((@[ @0 ])); + }); + + it(@"should send the new value when it changes", ^{ + RACTestObject *object = [[RACTestObject alloc] init]; + RACSignal *signal = signalBlock(object, @keypath(object, objectValue), self); + NSMutableArray *values = [NSMutableArray array]; + + object.objectValue = @0; + [signal subscribeNext:^(id x) { + [values addObject:x]; + }]; + + expect(values).to.equal((@[ @0 ])); + + object.objectValue = @1; + expect(values).to.equal((@[ @0, @1 ])); + + }); + + it(@"should stop observing when disposed", ^{ + RACTestObject *object = [[RACTestObject alloc] init]; + RACSignal *signal = signalBlock(object, @keypath(object, objectValue), self); + NSMutableArray *values = [NSMutableArray array]; + + object.objectValue = @0; + RACDisposable *disposable = [signal subscribeNext:^(id x) { + [values addObject:x]; + }]; + + object.objectValue = @1; + NSArray *expected = @[ @0, @1 ]; + expect(values).to.equal(expected); + + [disposable dispose]; + object.objectValue = @2; + expect(values).to.equal(expected); + }); + + it(@"shouldn't send any more values after the observer is gone", ^{ + __block BOOL observerDealloced = NO; + RACTestObject *object = [[RACTestObject alloc] init]; + NSMutableArray *values = [NSMutableArray array]; + @autoreleasepool { + RACTestObject *observer __attribute__((objc_precise_lifetime)) = [[RACTestObject alloc] init]; + [observer.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + observerDealloced = YES; + }]]; + + RACSignal *signal = signalBlock(object, @keypath(object, objectValue), observer); + object.objectValue = @1; + [signal subscribeNext:^(id x) { + [values addObject:x]; + }]; + } + + expect(observerDealloced).to.beTruthy(); + + NSArray *expected = @[ @1 ]; + expect(values).to.equal(expected); + + object.objectValue = @2; + expect(values).to.equal(expected); + }); + + it(@"shouldn't keep either object alive unnaturally long", ^{ + __block BOOL objectDealloced = NO; + __block BOOL scopeObjectDealloced = NO; + @autoreleasepool { + RACTestObject *object __attribute__((objc_precise_lifetime)) = [[RACTestObject alloc] init]; + [object.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + objectDealloced = YES; + }]]; + RACTestObject *scopeObject __attribute__((objc_precise_lifetime)) = [[RACTestObject alloc] init]; + [scopeObject.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + scopeObjectDealloced = YES; + }]]; + + RACSignal *signal = signalBlock(object, @keypath(object, objectValue), scopeObject); + + [signal subscribeNext:^(id _) { + + }]; + } + + expect(objectDealloced).to.beTruthy(); + expect(scopeObjectDealloced).to.beTruthy(); + }); + + it(@"shouldn't keep the signal alive past the lifetime of the object", ^{ + __block BOOL objectDealloced = NO; + __block BOOL signalDealloced = NO; + @autoreleasepool { + RACTestObject *object __attribute__((objc_precise_lifetime)) = [[RACTestObject alloc] init]; + [object.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + objectDealloced = YES; + }]]; + + RACSignal *signal = [signalBlock(object, @keypath(object, objectValue), self) map:^(id value) { + return value; + }]; + + [signal.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + signalDealloced = YES; + }]]; + + [signal subscribeNext:^(id _) { + + }]; + } + + expect(signalDealloced).will.beTruthy(); + expect(objectDealloced).to.beTruthy(); + }); + + it(@"should not resurrect a deallocated object upon subscription", ^{ + dispatch_queue_t queue = dispatch_queue_create(NULL, DISPATCH_QUEUE_CONCURRENT); + @onExit { + dispatch_release(queue); + }; + + dispatch_set_target_queue(queue, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0)); + + // Fuzz out race conditions. + for (unsigned i = 0; i < 100; i++) { + dispatch_suspend(queue); + + __block CFTypeRef object; + __block BOOL deallocated; + + RACSignal *signal; + + @autoreleasepool { + RACTestObject *testObject = [[RACTestObject alloc] init]; + [testObject.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + deallocated = YES; + }]]; + + signal = signalBlock(testObject, @keypath(testObject, objectValue), nil); + object = CFBridgingRetain(testObject); + } + + dispatch_block_t testSubscription = ^{ + RACDisposable *disposable = [signal subscribeCompleted:^{}]; + expect(disposable).notTo.beNil(); + }; + + unsigned beforeCount = arc4random_uniform(20); + for (unsigned j = 0; j < beforeCount; j++) { + dispatch_async(queue, testSubscription); + } + + dispatch_async(queue, ^{ + CFRelease(object); + + // expect() is a bit finicky on background threads. + STAssertTrue(deallocated, @"Object did not deallocate after being released"); + }); + + unsigned afterCount = arc4random_uniform(20); + for (unsigned j = 0; j < afterCount; j++) { + dispatch_async(queue, testSubscription); + } + + dispatch_barrier_async(queue, testSubscription); + + // Start everything and wait for it all to complete. + dispatch_resume(queue); + + expect(deallocated).will.beTruthy(); + dispatch_barrier_sync(queue, ^{}); + } + }); + + it(@"shouldn't crash when the value is changed on a different queue", ^{ + __block id value; + @autoreleasepool { + RACTestObject *object __attribute__((objc_precise_lifetime)) = [[RACTestObject alloc] init]; + + RACSignal *signal = signalBlock(object, @keypath(object, objectValue), self); + + [signal subscribeNext:^(id x) { + value = x; + }]; + + NSOperationQueue *queue = [[NSOperationQueue alloc] init]; + [queue addOperationWithBlock:^{ + object.objectValue = @1; + }]; + + [queue waitUntilAllOperationsAreFinished]; + } + + expect(value).will.equal(@1); + }); + + describe(@"mutating collections", ^{ + __block RACTestObject *object; + __block NSMutableOrderedSet *lastValue; + __block NSMutableOrderedSet *proxySet; + + before(^{ + object = [[RACTestObject alloc] init]; + object.objectValue = [NSMutableOrderedSet orderedSetWithObject:@1]; + + NSString *keyPath = @keypath(object, objectValue); + + [signalBlock(object, keyPath, self) subscribeNext:^(NSMutableOrderedSet *x) { + lastValue = x; + }]; + + proxySet = [object mutableOrderedSetValueForKey:keyPath]; + }); + + it(@"sends the newest object when inserting values into an observed object", ^{ + NSMutableOrderedSet *expected = [NSMutableOrderedSet orderedSetWithObjects: @1, @2, nil]; + + [proxySet addObject:@2]; + expect(lastValue).to.equal(expected); + }); + + it(@"sends the newest object when removing values in an observed object", ^{ + NSMutableOrderedSet *expected = [NSMutableOrderedSet orderedSet]; + + [proxySet removeAllObjects]; + expect(lastValue).to.equal(expected); + }); + + it(@"sends the newest object when replacing values in an observed object", ^{ + NSMutableOrderedSet *expected = [NSMutableOrderedSet orderedSetWithObjects: @2, nil]; + + [proxySet replaceObjectAtIndex:0 withObject:@2]; + expect(lastValue).to.equal(expected); + }); + }); + +}); + +SharedExamplesEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACPropertySubscribingSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACPropertySubscribingSpec.m new file mode 100644 index 0000000..1b69c2a --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACPropertySubscribingSpec.m
@@ -0,0 +1,155 @@ +// +// NSObjectRACPropertySubscribingSpec.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 9/28/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "NSObjectRACPropertySubscribingExamples.h" +#import "RACTestObject.h" + +#import "NSObject+RACPropertySubscribing.h" +#import "RACDisposable.h" +#import "RACSignal.h" + +SpecBegin(NSObjectRACPropertySubscribing) + +describe(@"-rac_valuesForKeyPath:observer:", ^{ + id (^setupBlock)(id, id, id) = ^(RACTestObject *object, NSString *keyPath, id observer) { + return [object rac_valuesForKeyPath:keyPath observer:observer]; + }; + + itShouldBehaveLike(RACPropertySubscribingExamples, ^{ + return @{ RACPropertySubscribingExamplesSetupBlock: setupBlock }; + }); + +}); + +describe(@"+rac_signalWithChangesFor:keyPath:options:observer:", ^{ + describe(@"KVO options argument", ^{ + __block RACTestObject *object; + __block id actual; + __block RACSignal *(^objectValueSignal)(NSKeyValueObservingOptions); + + before(^{ + object = [[RACTestObject alloc] init]; + + objectValueSignal = ^(NSKeyValueObservingOptions options) { + return [[object rac_valuesAndChangesForKeyPath:@keypath(object, objectValue) options:options observer:self] reduceEach:^(id value, NSDictionary *change) { + return change; + }]; + }; + }); + + it(@"sends a KVO dictionary", ^{ + [objectValueSignal(0) subscribeNext:^(NSDictionary *x) { + actual = x; + }]; + + object.objectValue = @1; + + expect(actual).to.beKindOf(NSDictionary.class); + }); + + it(@"sends a kind key by default", ^{ + [objectValueSignal(0) subscribeNext:^(NSDictionary *x) { + actual = x[NSKeyValueChangeKindKey]; + }]; + + object.objectValue = @1; + + expect(actual).notTo.beNil(); + }); + + it(@"sends the newest changes with NSKeyValueObservingOptionNew", ^{ + [objectValueSignal(NSKeyValueObservingOptionNew) subscribeNext:^(NSDictionary *x) { + actual = x[NSKeyValueChangeNewKey]; + }]; + + object.objectValue = @1; + expect(actual).to.equal(@1); + + object.objectValue = @2; + expect(actual).to.equal(@2); + }); + + it(@"sends an additional change value with NSKeyValueObservingOptionPrior", ^{ + NSMutableArray *values = [NSMutableArray new]; + NSArray *expected = @[ @(YES), @(NO) ]; + + [objectValueSignal(NSKeyValueObservingOptionPrior) subscribeNext:^(NSDictionary *x) { + BOOL isPrior = [x[NSKeyValueChangeNotificationIsPriorKey] boolValue]; + [values addObject:@(isPrior)]; + }]; + + object.objectValue = @[ @1 ]; + + expect(values).to.equal(expected); + }); + + it(@"sends index changes when adding, inserting or removing a value from an observed object", ^{ + __block NSUInteger hasIndexesCount = 0; + + [objectValueSignal(0) subscribeNext:^(NSDictionary *x) { + if (x[NSKeyValueChangeIndexesKey] != nil) { + hasIndexesCount += 1; + } + }]; + + object.objectValue = [NSMutableOrderedSet orderedSet]; + expect(hasIndexesCount).to.equal(0); + + NSMutableOrderedSet *objectValue = [object mutableOrderedSetValueForKey:@"objectValue"]; + + [objectValue addObject:@1]; + expect(hasIndexesCount).to.equal(1); + + [objectValue replaceObjectAtIndex:0 withObject:@2]; + expect(hasIndexesCount).to.equal(2); + + [objectValue removeObject:@2]; + expect(hasIndexesCount).to.equal(3); + }); + + it(@"sends the previous value with NSKeyValueObservingOptionOld", ^{ + [objectValueSignal(NSKeyValueObservingOptionOld) subscribeNext:^(NSDictionary *x) { + actual = x[NSKeyValueChangeOldKey]; + }]; + + object.objectValue = @1; + expect(actual).to.equal(NSNull.null); + + object.objectValue = @2; + expect(actual).to.equal(@1); + }); + + it(@"sends the initial value with NSKeyValueObservingOptionInitial", ^{ + [objectValueSignal(NSKeyValueObservingOptionInitial | NSKeyValueObservingOptionNew) subscribeNext:^(NSDictionary *x) { + actual = x[NSKeyValueChangeNewKey]; + }]; + + expect(actual).to.equal(NSNull.null); + }); + }); +}); + +describe(@"-rac_valuesAndChangesForKeyPath:options:observer:", ^{ + it(@"should complete immediately if the receiver or observer have deallocated", ^{ + RACSignal *signal; + @autoreleasepool { + RACTestObject *object __attribute__((objc_precise_lifetime)) = [[RACTestObject alloc] init]; + RACTestObject *observer __attribute__((objc_precise_lifetime)) = [[RACTestObject alloc] init]; + signal = [object rac_valuesAndChangesForKeyPath:@keypath(object, stringValue) options:0 observer:observer]; + } + + __block BOOL completed = NO; + [signal subscribeCompleted:^{ + completed = YES; + }]; + + expect(completed).to.beTruthy(); + }); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACSelectorSignalSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACSelectorSignalSpec.m new file mode 100644 index 0000000..b5b1839 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/NSObjectRACSelectorSignalSpec.m
@@ -0,0 +1,434 @@ +// +// NSObjectRACSelectorSignalSpec.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 3/18/13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACTestObject.h" +#import "RACSubclassObject.h" + +#import "NSObject+RACDeallocating.h" +#import "NSObject+RACPropertySubscribing.h" +#import "NSObject+RACSelectorSignal.h" +#import "RACCompoundDisposable.h" +#import "RACDisposable.h" +#import "RACMulticastConnection.h" +#import "RACSignal+Operations.h" +#import "RACSignal.h" +#import "RACTuple.h" + +@protocol TestProtocol + +@required +- (BOOL)requiredMethod:(NSUInteger)number; +- (void)lifeIsGood:(id)sender; + +@optional +- (NSUInteger)optionalMethodWithObject:(id)object flag:(BOOL)flag; +- (id)objectValue; + +@end + +SpecBegin(NSObjectRACSelectorSignal) + +describe(@"RACTestObject", ^{ + it(@"should send the argument for each invocation", ^{ + RACTestObject *object = [[RACTestObject alloc] init]; + __block id value; + [[object rac_signalForSelector:@selector(lifeIsGood:)] subscribeNext:^(RACTuple *x) { + value = x.first; + }]; + + [object lifeIsGood:@42]; + + expect(value).to.equal(@42); + }); + + it(@"should send completed on deallocation", ^{ + __block BOOL completed = NO; + __block BOOL deallocated = NO; + + @autoreleasepool { + RACTestObject *object __attribute__((objc_precise_lifetime)) = [[RACTestObject alloc] init]; + + [object.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + deallocated = YES; + }]]; + + [[object rac_signalForSelector:@selector(lifeIsGood:)] subscribeCompleted:^{ + completed = YES; + }]; + + expect(deallocated).to.beFalsy(); + expect(completed).to.beFalsy(); + } + + expect(deallocated).to.beTruthy(); + expect(completed).to.beTruthy(); + }); + + it(@"should send for a zero-argument method", ^{ + RACTestObject *object = [[RACTestObject alloc] init]; + + __block RACTuple *value; + [[object rac_signalForSelector:@selector(objectValue)] subscribeNext:^(RACTuple *x) { + value = x; + }]; + + [object objectValue]; + expect(value).to.equal([RACTuple tupleWithObjectsFromArray:@[]]); + }); + + it(@"should send the argument for each invocation to the instance's own signal", ^{ + RACTestObject *object1 = [[RACTestObject alloc] init]; + __block id value1; + [[object1 rac_signalForSelector:@selector(lifeIsGood:)] subscribeNext:^(RACTuple *x) { + value1 = x.first; + }]; + + RACTestObject *object2 = [[RACTestObject alloc] init]; + __block id value2; + [[object2 rac_signalForSelector:@selector(lifeIsGood:)] subscribeNext:^(RACTuple *x) { + value2 = x.first; + }]; + + [object1 lifeIsGood:@42]; + [object2 lifeIsGood:@"Carpe diem"]; + + expect(value1).to.equal(@42); + expect(value2).to.equal(@"Carpe diem"); + }); + + it(@"should send multiple arguments for each invocation", ^{ + RACTestObject *object = [[RACTestObject alloc] init]; + + __block id value1; + __block id value2; + [[object rac_signalForSelector:@selector(combineObjectValue:andSecondObjectValue:)] subscribeNext:^(RACTuple *x) { + value1 = x.first; + value2 = x.second; + }]; + + expect([object combineObjectValue:@42 andSecondObjectValue:@"foo"]).to.equal(@"42: foo"); + expect(value1).to.equal(@42); + expect(value2).to.equal(@"foo"); + }); + + it(@"should send arguments for invocation of non-existant methods", ^{ + RACTestObject *object = [[RACTestObject alloc] init]; + __block id key; + __block id value; + [[object rac_signalForSelector:@selector(setObject:forKey:)] subscribeNext:^(RACTuple *x) { + value = x.first; + key = x.second; + }]; + + [object performSelector:@selector(setObject:forKey:) withObject:@YES withObject:@"Winner"]; + + expect(value).to.equal(@YES); + expect(key).to.equal(@"Winner"); + }); + + it(@"should send arguments for invocation and invoke the original method on previously KVO'd receiver", ^{ + RACTestObject *object = [[RACTestObject alloc] init]; + + [[RACObserve(object, objectValue) publish] connect]; + + __block id key; + __block id value; + [[object rac_signalForSelector:@selector(setObjectValue:andSecondObjectValue:)] subscribeNext:^(RACTuple *x) { + value = x.first; + key = x.second; + }]; + + [object setObjectValue:@YES andSecondObjectValue:@"Winner"]; + + expect(object.hasInvokedSetObjectValueAndSecondObjectValue).to.beTruthy(); + expect(object.objectValue).to.equal(@YES); + expect(object.secondObjectValue).to.equal(@"Winner"); + + expect(value).to.equal(@YES); + expect(key).to.equal(@"Winner"); + }); + + it(@"should send arguments for invocation and invoke the original method when receiver is subsequently KVO'd", ^{ + RACTestObject *object = [[RACTestObject alloc] init]; + + __block id key; + __block id value; + [[object rac_signalForSelector:@selector(setObjectValue:andSecondObjectValue:)] subscribeNext:^(RACTuple *x) { + value = x.first; + key = x.second; + }]; + + [[RACObserve(object, objectValue) publish] connect]; + + [object setObjectValue:@YES andSecondObjectValue:@"Winner"]; + + expect(object.hasInvokedSetObjectValueAndSecondObjectValue).to.beTruthy(); + expect(object.objectValue).to.equal(@YES); + expect(object.secondObjectValue).to.equal(@"Winner"); + + expect(value).to.equal(@YES); + expect(key).to.equal(@"Winner"); + }); + + it(@"should properly implement -respondsToSelector: when called on KVO'd receiver", ^{ + RACTestObject *object = [[RACTestObject alloc] init]; + + // First, setup KVO on `object`, which gives us the desired side-effect + // of `object` taking on a KVO-custom subclass. + [[RACObserve(object, objectValue) publish] connect]; + + SEL selector = NSSelectorFromString(@"anyOldSelector:"); + + // With the KVO subclass in place, call -rac_signalForSelector: to + // implement -anyOldSelector: directly on the KVO subclass. + [object rac_signalForSelector:selector]; + + expect([object respondsToSelector:selector]).to.beTruthy(); + }); + + it(@"should properly implement -respondsToSelector: for optional method from a protocol", ^{ + // Selector for the targeted optional method from a protocol. + SEL selector = @selector(optionalProtocolMethodWithObjectValue:); + + RACTestObject *object1 = [[RACTestObject alloc] init]; + + // Method implementation of the selector is added to its swizzled class. + [object1 rac_signalForSelector:selector fromProtocol:@protocol(RACTestProtocol)]; + + expect([object1 respondsToSelector:selector]).to.beTruthy(); + + RACTestObject *object2 = [[RACTestObject alloc] init]; + + // Call -rac_signalForSelector: to swizzle this instance's class, + // method implementations of -respondsToSelector: and + // -forwardInvocation:. + [object2 rac_signalForSelector:@selector(lifeIsGood:)]; + + // This instance should not respond to the selector because of not + // calling -rac_signalForSelector: with the selector. + expect([object2 respondsToSelector:selector]).to.beFalsy(); + }); + + it(@"should send non-object arguments", ^{ + RACTestObject *object = [[RACTestObject alloc] init]; + + __block id value; + [[object rac_signalForSelector:@selector(setIntegerValue:)] subscribeNext:^(RACTuple *x) { + value = x.first; + }]; + + object.integerValue = 42; + expect(value).to.equal(@42); + }); + + it(@"should send on signal after the original method is invoked", ^{ + RACTestObject *object = [[RACTestObject alloc] init]; + + __block BOOL invokedMethodBefore = NO; + [[object rac_signalForSelector:@selector(setObjectValue:andSecondObjectValue:)] subscribeNext:^(RACTuple *x) { + invokedMethodBefore = object.hasInvokedSetObjectValueAndSecondObjectValue; + }]; + + [object setObjectValue:@YES andSecondObjectValue:@"Winner"]; + expect(invokedMethodBefore).to.beTruthy(); + }); +}); + +it(@"should swizzle an NSObject method", ^{ + NSObject *object = [[NSObject alloc] init]; + + __block RACTuple *value; + [[object rac_signalForSelector:@selector(description)] subscribeNext:^(RACTuple *x) { + value = x; + }]; + + expect([object description]).notTo.beNil(); + expect(value).to.equal([RACTuple tupleWithObjectsFromArray:@[]]); +}); + +describe(@"a class that already overrides -forwardInvocation:", ^{ + it(@"should invoke the superclass' implementation", ^{ + RACSubclassObject *object = [[RACSubclassObject alloc] init]; + + __block id value; + [[object rac_signalForSelector:@selector(lifeIsGood:)] subscribeNext:^(RACTuple *x) { + value = x.first; + }]; + + [object lifeIsGood:@42]; + expect(value).to.equal(@42); + + expect(object.forwardedSelector).to.beNil(); + + [object performSelector:@selector(allObjects)]; + + expect(value).to.equal(@42); + expect(object.forwardedSelector).to.equal(@selector(allObjects)); + }); + + it(@"should not infinite recurse when KVO'd after RAC swizzled", ^{ + RACSubclassObject *object = [[RACSubclassObject alloc] init]; + + __block id value; + [[object rac_signalForSelector:@selector(lifeIsGood:)] subscribeNext:^(RACTuple *x) { + value = x.first; + }]; + + [[RACObserve(object, objectValue) publish] connect]; + + [object lifeIsGood:@42]; + expect(value).to.equal(@42); + + expect(object.forwardedSelector).to.beNil(); + [object performSelector:@selector(allObjects)]; + expect(object.forwardedSelector).to.equal(@selector(allObjects)); + }); +}); + +describe(@"two classes in the same hierarchy", ^{ + __block RACTestObject *superclassObj; + __block RACTuple *superclassTuple; + + __block RACSubclassObject *subclassObj; + __block RACTuple *subclassTuple; + + beforeEach(^{ + superclassObj = [[RACTestObject alloc] init]; + expect(superclassObj).notTo.beNil(); + + subclassObj = [[RACSubclassObject alloc] init]; + expect(subclassObj).notTo.beNil(); + }); + + it(@"should not collide", ^{ + [[superclassObj rac_signalForSelector:@selector(combineObjectValue:andIntegerValue:)] subscribeNext:^(RACTuple *t) { + superclassTuple = t; + }]; + + [[subclassObj rac_signalForSelector:@selector(combineObjectValue:andIntegerValue:)] subscribeNext:^(RACTuple *t) { + subclassTuple = t; + }]; + + expect([superclassObj combineObjectValue:@"foo" andIntegerValue:42]).to.equal(@"foo: 42"); + + NSArray *expectedValues = @[ @"foo", @42 ]; + expect(superclassTuple.allObjects).to.equal(expectedValues); + + expect([subclassObj combineObjectValue:@"foo" andIntegerValue:42]).to.equal(@"fooSUBCLASS: 42"); + + expectedValues = @[ @"foo", @42 ]; + expect(subclassTuple.allObjects).to.equal(expectedValues); + }); + + it(@"should not collide when the superclass is invoked asynchronously", ^{ + [[superclassObj rac_signalForSelector:@selector(setObjectValue:andSecondObjectValue:)] subscribeNext:^(RACTuple *t) { + superclassTuple = t; + }]; + + [[subclassObj rac_signalForSelector:@selector(setObjectValue:andSecondObjectValue:)] subscribeNext:^(RACTuple *t) { + subclassTuple = t; + }]; + + [superclassObj setObjectValue:@"foo" andSecondObjectValue:@"42"]; + expect(superclassObj.hasInvokedSetObjectValueAndSecondObjectValue).to.beTruthy(); + + NSArray *expectedValues = @[ @"foo", @"42" ]; + expect(superclassTuple.allObjects).to.equal(expectedValues); + + [subclassObj setObjectValue:@"foo" andSecondObjectValue:@"42"]; + expect(subclassObj.hasInvokedSetObjectValueAndSecondObjectValue).to.beFalsy(); + expect(subclassObj.hasInvokedSetObjectValueAndSecondObjectValue).will.beTruthy(); + + expectedValues = @[ @"foo", @"42" ]; + expect(subclassTuple.allObjects).to.equal(expectedValues); + }); +}); + +describe(@"-rac_signalForSelector:fromProtocol", ^{ + __block RACTestObject<TestProtocol> *object; + __block Protocol *protocol; + + beforeEach(^{ + object = (id)[[RACTestObject alloc] init]; + expect(object).notTo.beNil(); + + protocol = @protocol(TestProtocol); + expect(protocol).notTo.beNil(); + }); + + it(@"should not clobber a required method already implemented", ^{ + __block id value; + [[object rac_signalForSelector:@selector(lifeIsGood:) fromProtocol:protocol] subscribeNext:^(RACTuple *x) { + value = x.first; + }]; + + [object lifeIsGood:@42]; + expect(value).to.equal(@42); + }); + + it(@"should not clobber an optional method already implemented", ^{ + object.objectValue = @"foo"; + + __block id value; + [[object rac_signalForSelector:@selector(objectValue) fromProtocol:protocol] subscribeNext:^(RACTuple *x) { + value = x; + }]; + + expect([object objectValue]).to.equal(@"foo"); + expect(value).to.equal([RACTuple tupleWithObjectsFromArray:@[]]); + }); + + it(@"should inject a required method", ^{ + __block id value; + [[object rac_signalForSelector:@selector(requiredMethod:) fromProtocol:protocol] subscribeNext:^(RACTuple *x) { + value = x.first; + }]; + + expect([object requiredMethod:42]).to.beFalsy(); + expect(value).to.equal(42); + }); + + it(@"should inject an optional method", ^{ + __block id value; + [[object rac_signalForSelector:@selector(optionalMethodWithObject:flag:) fromProtocol:protocol] subscribeNext:^(RACTuple *x) { + value = x; + }]; + + expect([object optionalMethodWithObject:@"foo" flag:YES]).to.equal(0); + expect(value).to.equal(RACTuplePack(@"foo", @YES)); + }); +}); + +describe(@"class reporting", ^{ + __block RACTestObject *object; + __block Class originalClass; + + beforeEach(^{ + object = [[RACTestObject alloc] init]; + originalClass = object.class; + }); + + it(@"should report the original class", ^{ + [object rac_signalForSelector:@selector(lifeIsGood:)]; + expect(object.class).to.beIdenticalTo(originalClass); + }); + + it(@"should report the original class when it's KVO'd after dynamically subclassing", ^{ + [object rac_signalForSelector:@selector(lifeIsGood:)]; + [[RACObserve(object, objectValue) publish] connect]; + expect(object.class).to.beIdenticalTo(originalClass); + }); + + it(@"should report the original class when it's KVO'd before dynamically subclassing", ^{ + [[RACObserve(object, objectValue) publish] connect]; + [object rac_signalForSelector:@selector(lifeIsGood:)]; + expect(object.class).to.beIdenticalTo(originalClass); + }); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/NSStringRACKeyPathUtilitiesSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/NSStringRACKeyPathUtilitiesSpec.m new file mode 100644 index 0000000..72e743a --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/NSStringRACKeyPathUtilitiesSpec.m
@@ -0,0 +1,51 @@ +// +// NSStringRACKeyPathUtilitiesSpec.m +// ReactiveCocoa +// +// Created by Uri Baghin on 05/05/2013. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "NSString+RACKeyPathUtilities.h" + +SpecBegin(NSStringRACKeyPathUtilities) + +describe(@"-keyPathComponents", ^{ + it(@"should return components in the key path", ^{ + expect(@"self.test.key.path".rac_keyPathComponents).to.equal((@[@"self", @"test", @"key", @"path"])); + }); + + it(@"should return nil if given an empty string", ^{ + expect(@"".rac_keyPathComponents).to.beNil(); + }); +}); + +describe(@"-keyPathByDeletingLastKeyPathComponent", ^{ + it(@"should return the parent key path", ^{ + expect(@"grandparent.parent.child".rac_keyPathByDeletingLastKeyPathComponent).to.equal(@"grandparent.parent"); + }); + + it(@"should return nil if given an empty string", ^{ + expect(@"".rac_keyPathByDeletingLastKeyPathComponent).to.beNil(); + }); + + it(@"should return nil if given a key path with only one component", ^{ + expect(@"self".rac_keyPathByDeletingLastKeyPathComponent).to.beNil(); + }); +}); + +describe(@"-keyPathByDeletingFirstKeyPathComponent", ^{ + it(@"should return the remaining key path", ^{ + expect(@"first.second.third".rac_keyPathByDeletingFirstKeyPathComponent).to.equal(@"second.third"); + }); + + it(@"should return nil if given an empty string", ^{ + expect(@"".rac_keyPathByDeletingFirstKeyPathComponent).to.beNil(); + }); + + it(@"should return nil if given a key path with only one component", ^{ + expect(@"self".rac_keyPathByDeletingFirstKeyPathComponent).to.beNil(); + }); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/NSTextRACSupportSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/NSTextRACSupportSpec.m new file mode 100644 index 0000000..364d0e4 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/NSTextRACSupportSpec.m
@@ -0,0 +1,33 @@ +// +// NSTextRACSupportSpec.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-03-08. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "NSText+RACSignalSupport.h" +#import "RACSignal.h" + +SpecBegin(NSTextRACSupport) + +it(@"NSTextView should send changes on rac_textSignal", ^{ + NSTextView *textView = [[NSTextView alloc] initWithFrame:NSZeroRect]; + expect(textView).notTo.beNil(); + + NSMutableArray *strings = [NSMutableArray array]; + [textView.rac_textSignal subscribeNext:^(NSString *str) { + [strings addObject:str]; + }]; + + expect(strings).to.equal(@[ @"" ]); + + [textView insertText:@"f"]; + [textView insertText:@"o"]; + [textView insertText:@"b"]; + + NSArray *expected = @[ @"", @"f", @"fo", @"fob" ]; + expect(strings).to.equal(expected); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/NSURLConnectionRACSupportSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/NSURLConnectionRACSupportSpec.m new file mode 100644 index 0000000..e7bc8de --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/NSURLConnectionRACSupportSpec.m
@@ -0,0 +1,36 @@ +// +// NSURLConnectionRACSupportSpec.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-10-01. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "NSURLConnection+RACSupport.h" +#import "RACSignal+Operations.h" +#import "RACTuple.h" + +SpecBegin(NSURLConnectionRACSupport) + +it(@"should fetch a JSON file", ^{ + NSURL *fileURL = [[NSBundle bundleForClass:self.class] URLForResource:@"test-data" withExtension:@"json"]; + expect(fileURL).notTo.beNil(); + + NSURLRequest *request = [NSURLRequest requestWithURL:fileURL]; + + BOOL success = NO; + NSError *error = nil; + RACTuple *result = [[NSURLConnection rac_sendAsynchronousRequest:request] firstOrDefault:nil success:&success error:&error]; + expect(success).to.beTruthy(); + expect(error).to.beNil(); + expect(result).to.beKindOf(RACTuple.class); + + NSURLResponse *response = result.first; + expect(response).to.beKindOf(NSURLResponse.class); + + NSData *data = result.second; + expect(data).to.beKindOf(NSData.class); + expect(data).to.equal([NSData dataWithContentsOfURL:fileURL]); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/NSUserDefaultsRACSupportSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/NSUserDefaultsRACSupportSpec.m new file mode 100644 index 0000000..3f0866c --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/NSUserDefaultsRACSupportSpec.m
@@ -0,0 +1,133 @@ +// +// NSUserDefaultsRACSupportSpec.m +// ReactiveCocoa +// +// Created by Matt Diephouse on 12/19/13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "NSUserDefaults+RACSupport.h" + +#import "RACCompoundDisposable.h" +#import "RACDisposable.h" +#import "RACKVOChannel.h" +#import "NSObject+RACDeallocating.h" +#import "RACSignal+Operations.h" + +static NSString * const NSUserDefaultsRACSupportSpecStringDefault = @"NSUserDefaultsRACSupportSpecStringDefault"; +static NSString * const NSUserDefaultsRACSupportSpecBoolDefault = @"NSUserDefaultsRACSupportSpecBoolDefault"; + +@interface TestObserver : NSObject + +@property (copy, atomic) NSString *string1; +@property (copy, atomic) NSString *string2; + +@property (assign, atomic) BOOL bool1; + +@end + +@implementation TestObserver + +@end + +SpecBegin(NSUserDefaultsRACSupportSpec) + +__block NSUserDefaults *defaults = nil; +__block TestObserver *observer = nil; + +beforeEach(^{ + defaults = NSUserDefaults.standardUserDefaults; + [defaults removeObjectForKey:NSUserDefaultsRACSupportSpecStringDefault]; + [defaults removeObjectForKey:NSUserDefaultsRACSupportSpecBoolDefault]; + + observer = [TestObserver new]; +}); + +afterEach(^{ + observer = nil; +}); + +it(@"should set defaults", ^{ + RACChannelTo(observer, string1) = [defaults rac_channelTerminalForKey:NSUserDefaultsRACSupportSpecStringDefault]; + RACChannelTo(observer, bool1, @NO) = [defaults rac_channelTerminalForKey:NSUserDefaultsRACSupportSpecBoolDefault]; + + observer.string1 = @"A string"; + observer.bool1 = YES; + + expect([defaults objectForKey:NSUserDefaultsRACSupportSpecStringDefault]).will.equal(@"A string"); + expect([defaults objectForKey:NSUserDefaultsRACSupportSpecBoolDefault]).will.equal(@YES); +}); + +it(@"should read defaults", ^{ + RACChannelTo(observer, string1) = [defaults rac_channelTerminalForKey:NSUserDefaultsRACSupportSpecStringDefault]; + RACChannelTo(observer, bool1, @NO) = [defaults rac_channelTerminalForKey:NSUserDefaultsRACSupportSpecBoolDefault]; + + expect(observer.string1).to.beNil(); + expect(observer.bool1).to.equal(NO); + + [defaults setObject:@"Another string" forKey:NSUserDefaultsRACSupportSpecStringDefault]; + [defaults setBool:YES forKey:NSUserDefaultsRACSupportSpecBoolDefault]; + + expect(observer.string1).to.equal(@"Another string"); + expect(observer.bool1).to.equal(YES); +}); + +it(@"should be okay to create 2 terminals", ^{ + RACChannelTo(observer, string1) = [defaults rac_channelTerminalForKey:NSUserDefaultsRACSupportSpecStringDefault]; + RACChannelTo(observer, string2) = [defaults rac_channelTerminalForKey:NSUserDefaultsRACSupportSpecStringDefault]; + + [defaults setObject:@"String 3" forKey:NSUserDefaultsRACSupportSpecStringDefault]; + + expect(observer.string1).to.equal(@"String 3"); + expect(observer.string2).to.equal(@"String 3"); +}); + +it(@"should handle removed defaults", ^{ + observer.string1 = @"Some string"; + observer.bool1 = YES; + + RACChannelTo(observer, string1) = [defaults rac_channelTerminalForKey:NSUserDefaultsRACSupportSpecStringDefault]; + RACChannelTo(observer, bool1, @NO) = [defaults rac_channelTerminalForKey:NSUserDefaultsRACSupportSpecBoolDefault]; + + [defaults removeObjectForKey:NSUserDefaultsRACSupportSpecStringDefault]; + [defaults removeObjectForKey:NSUserDefaultsRACSupportSpecBoolDefault]; + + expect(observer.string1).to.beNil(); + expect(observer.bool1).to.equal(NO); +}); + +it(@"shouldn't resend values", ^{ + RACChannelTerminal *terminal = [defaults rac_channelTerminalForKey:NSUserDefaultsRACSupportSpecStringDefault]; + + RACChannelTo(observer, string1) = terminal; + + RACSignal *sentValue = [terminal replayLast]; + observer.string1 = @"Test value"; + id value = [sentValue asynchronousFirstOrDefault:nil success:NULL error:NULL]; + expect(value).to.beNil(); +}); + +it(@"should complete when the NSUserDefaults deallocates", ^{ + __block RACChannelTerminal *terminal; + __block BOOL deallocated = NO; + + @autoreleasepool { + NSUserDefaults *customDefaults __attribute__((objc_precise_lifetime)) = [NSUserDefaults new]; + [customDefaults.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + deallocated = YES; + }]]; + + terminal = [customDefaults rac_channelTerminalForKey:NSUserDefaultsRACSupportSpecStringDefault]; + } + + expect(deallocated).to.beTruthy(); + expect([terminal asynchronouslyWaitUntilCompleted:NULL]).to.beTruthy(); +}); + +it(@"should send an initial value", ^{ + [defaults setObject:@"Initial" forKey:NSUserDefaultsRACSupportSpecStringDefault]; + RACChannelTerminal *terminal = [defaults rac_channelTerminalForKey:NSUserDefaultsRACSupportSpecStringDefault]; + expect([terminal asynchronousFirstOrDefault:nil success:NULL error:NULL]).to.equal(@"Initial"); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACBacktraceSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACBacktraceSpec.m new file mode 100644 index 0000000..9ad4c3b --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACBacktraceSpec.m
@@ -0,0 +1,148 @@ +// +// RACBacktraceSpec.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-12-24. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACBacktrace.h" + +#import "NSArray+RACSequenceAdditions.h" +#import "RACReplaySubject.h" +#import "RACScheduler.h" +#import "RACSequence.h" +#import "RACSignal+Operations.h" + +#ifdef DEBUG + +static RACBacktrace *previousBacktrace; + +static void capturePreviousBacktrace(void *context) { + previousBacktrace = [RACBacktrace backtrace].previousThreadBacktrace; +} + +typedef struct { + dispatch_queue_t queue; + NSUInteger i; + __unsafe_unretained RACSubject *doneSubject; +} RACDeepRecursionContext; + +static void recurseDeeply(void *ptr) { + RACDeepRecursionContext *context = ptr; + + if (context->i++ < 10000) { + rac_dispatch_async_f(context->queue, context, recurseDeeply); + } else { + [context->doneSubject sendCompleted]; + } +} + +SpecBegin(RACBacktrace) + +__block dispatch_block_t block; + +beforeEach(^{ + expect([RACBacktrace backtrace].previousThreadBacktrace).to.beNil(); + previousBacktrace = nil; + + block = ^{ + capturePreviousBacktrace(NULL); + }; +}); + +it(@"should capture the current backtrace", ^{ + RACBacktrace *backtrace = [RACBacktrace backtrace]; + expect(backtrace).notTo.beNil(); +}); + +describe(@"with a GCD queue", ^{ + __block dispatch_queue_t queue; + + beforeEach(^{ + queue = dispatch_queue_create("com.github.ReactiveCocoa.RACBacktraceSpec", DISPATCH_QUEUE_SERIAL); + }); + + afterEach(^{ + dispatch_barrier_sync(queue, ^{}); + dispatch_release(queue); + }); + + it(@"should trace across dispatch_async", ^{ + rac_dispatch_async(queue, block); + expect(previousBacktrace).willNot.beNil(); + }); + + it(@"should trace across dispatch_async to the main thread", ^{ + rac_dispatch_async(queue, ^{ + rac_dispatch_async(dispatch_get_main_queue(), block); + }); + + expect(previousBacktrace).willNot.beNil(); + }); + + it(@"should trace across dispatch_async_f", ^{ + rac_dispatch_async_f(queue, NULL, &capturePreviousBacktrace); + expect(previousBacktrace).willNot.beNil(); + }); + + it(@"should trace across dispatch_barrier_async", ^{ + rac_dispatch_barrier_async(queue, block); + expect(previousBacktrace).willNot.beNil(); + }); + + it(@"should trace across dispatch_barrier_async_f", ^{ + rac_dispatch_barrier_async_f(queue, NULL, &capturePreviousBacktrace); + expect(previousBacktrace).willNot.beNil(); + }); + + it(@"should trace across dispatch_after", ^{ + rac_dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 1), queue, block); + expect(previousBacktrace).willNot.beNil(); + }); + + it(@"should trace across dispatch_after_f", ^{ + rac_dispatch_after_f(dispatch_time(DISPATCH_TIME_NOW, 1), queue, NULL, &capturePreviousBacktrace); + expect(previousBacktrace).willNot.beNil(); + }); + + it(@"shouldn't overflow the stack when deallocating a huge backtrace list", ^{ + RACSubject *doneSubject = [RACReplaySubject subject]; + RACDeepRecursionContext context = { + .queue = queue, + .i = 0, + .doneSubject = doneSubject + }; + + rac_dispatch_async_f(queue, &context, &recurseDeeply); + [doneSubject waitUntilCompleted:NULL]; + }); +}); + +it(@"should trace across a RACScheduler", ^{ + [[RACScheduler scheduler] schedule:block]; + expect(previousBacktrace).willNot.beNil(); +}); + +it(@"shouldn't go bonkers with RACScheduler", ^{ + NSMutableArray *a = [NSMutableArray array]; + for (NSUInteger i = 0; i < 5000; i++) { + [a addObject:@(i)]; + } + + [[a.rac_sequence signalWithScheduler:[RACScheduler scheduler]] subscribeCompleted:^{}]; +}); + +// Tracing across NSOperationQueue only works on OS X because it depends on +// interposing through dynamic linking +#ifndef __IPHONE_OS_VERSION_MIN_REQUIRED + it(@"should trace across an NSOperationQueue", ^{ + NSOperationQueue *queue = [[NSOperationQueue alloc] init]; + [queue addOperationWithBlock:block]; + expect(previousBacktrace).willNot.beNil(); + }); +#endif + +SpecEnd + +#endif
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACBlockTrampolineSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACBlockTrampolineSpec.m new file mode 100644 index 0000000..72570fe --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACBlockTrampolineSpec.m
@@ -0,0 +1,48 @@ +// +// RACBlockTrampolineSpec.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 10/28/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACBlockTrampoline.h" +#import "RACTuple.h" + +SpecBegin(RACBlockTrampoline) + +it(@"should invoke the block with the given arguments", ^{ + __block NSString *stringArg; + __block NSNumber *numberArg; + id (^block)(NSString *, NSNumber *) = ^ id (NSString *string, NSNumber *number) { + stringArg = string; + numberArg = number; + return nil; + }; + + [RACBlockTrampoline invokeBlock:block withArguments:RACTuplePack(@"hi", @1)]; + expect(stringArg).to.equal(@"hi"); + expect(numberArg).to.equal(@1); +}); + +it(@"should return the result of the block invocation", ^{ + NSString * (^block)(NSString *) = ^(NSString *string) { + return string.uppercaseString; + }; + + NSString *result = [RACBlockTrampoline invokeBlock:block withArguments:RACTuplePack(@"hi")]; + expect(result).to.equal(@"HI"); +}); + +it(@"should pass RACTupleNils as nil", ^{ + __block id arg; + id (^block)(id) = ^ id (id obj) { + arg = obj; + return nil; + }; + + [RACBlockTrampoline invokeBlock:block withArguments:RACTuplePack(nil)]; + expect(arg).to.beNil(); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACChannelExamples.h b/ReactiveCocoaFramework/ReactiveCocoaTests/RACChannelExamples.h new file mode 100644 index 0000000..0952fed --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACChannelExamples.h
@@ -0,0 +1,34 @@ +// +// RACChannelExamples.h +// ReactiveCocoa +// +// Created by Uri Baghin on 30/12/2012. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +// The name of the shared examples for RACChannel and its subclasses. +extern NSString * const RACChannelExamples; + +// A block of type `RACChannel * (^)(void)`, which should return a new +// RACChannel. +extern NSString * const RACChannelExampleCreateBlock; + +// The name of the shared examples for any RACChannel class that gets and sets +// a property. +extern NSString * const RACViewChannelExamples; + +// A block of type `NSObject * (^)(void)`, which should create a new test view +// and return it. +extern NSString * const RACViewChannelExampleCreateViewBlock; + +// A block of type `RACChannelTerminal * (^)(NSObject *view)`, which should +// create a new RACChannel to the given test view and return an terminal. +extern NSString * const RACViewChannelExampleCreateTerminalBlock; + +// The key path that will be read/written in RACViewChannelExamples. This +// must lead to an NSNumber or numeric primitive property. +extern NSString * const RACViewChannelExampleKeyPath; + +// A block of type `void (^)(NSObject *view, NSNumber *value)`, which should +// change the given test view's value to the given one. +extern NSString * const RACViewChannelExampleSetViewValueBlock;
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACChannelExamples.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACChannelExamples.m new file mode 100644 index 0000000..9fc77fc --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACChannelExamples.m
@@ -0,0 +1,298 @@ +// +// RACChannelExamples.m +// ReactiveCocoa +// +// Created by Uri Baghin on 30/12/2012. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACChannelExamples.h" + +#import "NSObject+RACDeallocating.h" +#import "NSObject+RACPropertySubscribing.h" +#import "RACChannel.h" +#import "RACCompoundDisposable.h" +#import "RACDisposable.h" +#import "RACSignal+Operations.h" + +NSString * const RACChannelExamples = @"RACChannelExamples"; +NSString * const RACChannelExampleCreateBlock = @"RACChannelExampleCreateBlock"; + +NSString * const RACViewChannelExamples = @"RACViewChannelExamples"; +NSString * const RACViewChannelExampleCreateViewBlock = @"RACViewChannelExampleCreateViewBlock"; +NSString * const RACViewChannelExampleCreateTerminalBlock = @"RACViewChannelExampleCreateTerminalBlock"; +NSString * const RACViewChannelExampleKeyPath = @"RACViewChannelExampleKeyPath"; +NSString * const RACViewChannelExampleSetViewValueBlock = @"RACViewChannelExampleSetViewValueBlock"; + +SharedExampleGroupsBegin(RACChannelExamples) + +sharedExamplesFor(RACChannelExamples, ^(NSDictionary *data) { + __block RACChannel * (^getChannel)(void); + __block RACChannel *channel; + + id value1 = @"test value 1"; + id value2 = @"test value 2"; + id value3 = @"test value 3"; + NSArray *values = @[ value1, value2, value3 ]; + + before(^{ + getChannel = data[RACChannelExampleCreateBlock]; + channel = getChannel(); + }); + + it(@"should not send any leadingTerminal value on subscription", ^{ + __block id receivedValue = nil; + + [channel.followingTerminal sendNext:value1]; + [channel.leadingTerminal subscribeNext:^(id x) { + receivedValue = x; + }]; + + expect(receivedValue).to.beNil(); + + [channel.followingTerminal sendNext:value2]; + expect(receivedValue).to.equal(value2); + }); + + it(@"should send the latest followingTerminal value on subscription", ^{ + __block id receivedValue = nil; + + [channel.leadingTerminal sendNext:value1]; + [[channel.followingTerminal take:1] subscribeNext:^(id x) { + receivedValue = x; + }]; + + expect(receivedValue).to.equal(value1); + + [channel.leadingTerminal sendNext:value2]; + [[channel.followingTerminal take:1] subscribeNext:^(id x) { + receivedValue = x; + }]; + + expect(receivedValue).to.equal(value2); + }); + + it(@"should send leadingTerminal values as they change", ^{ + NSMutableArray *receivedValues = [NSMutableArray array]; + [channel.leadingTerminal subscribeNext:^(id x) { + [receivedValues addObject:x]; + }]; + + [channel.followingTerminal sendNext:value1]; + [channel.followingTerminal sendNext:value2]; + [channel.followingTerminal sendNext:value3]; + expect(receivedValues).to.equal(values); + }); + + it(@"should send followingTerminal values as they change", ^{ + [channel.leadingTerminal sendNext:value1]; + + NSMutableArray *receivedValues = [NSMutableArray array]; + [channel.followingTerminal subscribeNext:^(id x) { + [receivedValues addObject:x]; + }]; + + [channel.leadingTerminal sendNext:value2]; + [channel.leadingTerminal sendNext:value3]; + expect(receivedValues).to.equal(values); + }); + + it(@"should complete both signals when the leadingTerminal is completed", ^{ + __block BOOL completedLeft = NO; + [channel.leadingTerminal subscribeCompleted:^{ + completedLeft = YES; + }]; + + __block BOOL completedRight = NO; + [channel.followingTerminal subscribeCompleted:^{ + completedRight = YES; + }]; + + [channel.leadingTerminal sendCompleted]; + expect(completedLeft).to.beTruthy(); + expect(completedRight).to.beTruthy(); + }); + + it(@"should complete both signals when the followingTerminal is completed", ^{ + __block BOOL completedLeft = NO; + [channel.leadingTerminal subscribeCompleted:^{ + completedLeft = YES; + }]; + + __block BOOL completedRight = NO; + [channel.followingTerminal subscribeCompleted:^{ + completedRight = YES; + }]; + + [channel.followingTerminal sendCompleted]; + expect(completedLeft).to.beTruthy(); + expect(completedRight).to.beTruthy(); + }); + + it(@"should replay completion to new subscribers", ^{ + [channel.leadingTerminal sendCompleted]; + + __block BOOL completedLeft = NO; + [channel.leadingTerminal subscribeCompleted:^{ + completedLeft = YES; + }]; + + __block BOOL completedRight = NO; + [channel.followingTerminal subscribeCompleted:^{ + completedRight = YES; + }]; + + expect(completedLeft).to.beTruthy(); + expect(completedRight).to.beTruthy(); + }); +}); + +SharedExampleGroupsEnd + +SharedExampleGroupsBegin(RACViewChannelExamples) + +sharedExamplesFor(RACViewChannelExamples, ^(NSDictionary *data) { + __block NSString *keyPath; + __block NSObject * (^getView)(void); + __block RACChannelTerminal * (^getTerminal)(NSObject *); + __block void (^setViewValue)(NSObject *view, NSNumber *value); + + __block NSObject *testView; + __block RACChannelTerminal *endpoint; + + beforeEach(^{ + keyPath = data[RACViewChannelExampleKeyPath]; + getTerminal = data[RACViewChannelExampleCreateTerminalBlock]; + getView = data[RACViewChannelExampleCreateViewBlock]; + setViewValue = data[RACViewChannelExampleSetViewValueBlock]; + + testView = getView(); + endpoint = getTerminal(testView); + }); + + it(@"should not send changes made by the channel itself", ^{ + __block BOOL receivedNext = NO; + [endpoint subscribeNext:^(id x) { + receivedNext = YES; + }]; + + expect(receivedNext).to.beFalsy(); + + [endpoint sendNext:@0.1]; + expect(receivedNext).to.beFalsy(); + + [endpoint sendNext:@0.2]; + expect(receivedNext).to.beFalsy(); + + [endpoint sendCompleted]; + expect(receivedNext).to.beFalsy(); + }); + + it(@"should not send progammatic changes made to the view", ^{ + __block BOOL receivedNext = NO; + [endpoint subscribeNext:^(id x) { + receivedNext = YES; + }]; + + expect(receivedNext).to.beFalsy(); + + [testView setValue:@0.1 forKeyPath:keyPath]; + expect(receivedNext).to.beFalsy(); + + [testView setValue:@0.2 forKeyPath:keyPath]; + expect(receivedNext).to.beFalsy(); + }); + + it(@"should not have a starting value", ^{ + __block BOOL receivedNext = NO; + [endpoint subscribeNext:^(id x) { + receivedNext = YES; + }]; + + expect(receivedNext).to.beFalsy(); + }); + + it(@"should send view changes", ^{ + __block NSString *received; + [endpoint subscribeNext:^(id x) { + received = x; + }]; + + setViewValue(testView, @0.1); + expect(received).to.equal(@0.1); + + setViewValue(testView, @0.2); + expect(received).to.equal(@0.2); + }); + + it(@"should set values on the view", ^{ + [endpoint sendNext:@0.1]; + expect([testView valueForKeyPath:keyPath]).to.equal(@0.1); + + [endpoint sendNext:@0.2]; + expect([testView valueForKeyPath:keyPath]).to.equal(@0.2); + }); + + it(@"should not echo changes back to the channel", ^{ + __block NSUInteger receivedCount = 0; + [endpoint subscribeNext:^(id _) { + receivedCount++; + }]; + + expect(receivedCount).to.equal(0); + + [endpoint sendNext:@0.1]; + expect(receivedCount).to.equal(0); + + setViewValue(testView, @0.2); + expect(receivedCount).to.equal(1); + }); + + it(@"should complete when the view deallocates", ^{ + __block BOOL deallocated = NO; + __block BOOL completed = NO; + + @autoreleasepool { + NSObject *view __attribute__((objc_precise_lifetime)) = getView(); + [view.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + deallocated = YES; + }]]; + + RACChannelTerminal *terminal = getTerminal(view); + [terminal subscribeCompleted:^{ + completed = YES; + }]; + + expect(deallocated).to.beFalsy(); + expect(completed).to.beFalsy(); + } + + expect(deallocated).to.beTruthy(); + expect(completed).to.beTruthy(); + }); + + it(@"should deallocate after the view deallocates", ^{ + __block BOOL viewDeallocated = NO; + __block BOOL terminalDeallocated = NO; + + @autoreleasepool { + NSObject *view __attribute__((objc_precise_lifetime)) = getView(); + [view.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + viewDeallocated = YES; + }]]; + + RACChannelTerminal *terminal = getTerminal(view); + [terminal.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + terminalDeallocated = YES; + }]]; + + expect(viewDeallocated).to.beFalsy(); + expect(terminalDeallocated).to.beFalsy(); + } + + expect(viewDeallocated).to.beTruthy(); + expect(terminalDeallocated).will.beTruthy(); + }); +}); + +SharedExampleGroupsEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACChannelSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACChannelSpec.m new file mode 100644 index 0000000..7bfe6af --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACChannelSpec.m
@@ -0,0 +1,71 @@ +// +// RACChannelSpec.m +// ReactiveCocoa +// +// Created by Uri Baghin on 30/12/2012. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACChannelExamples.h" + +#import "NSObject+RACDeallocating.h" +#import "RACChannel.h" +#import "RACCompoundDisposable.h" +#import "RACDisposable.h" +#import "RACSignal.h" + +SpecBegin(RACChannel) + +describe(@"RACChannel", ^{ + itShouldBehaveLike(RACChannelExamples, @{ + RACChannelExampleCreateBlock: [^{ + return [[RACChannel alloc] init]; + } copy] + }); + + describe(@"memory management", ^{ + it(@"should dealloc when its subscribers are disposed", ^{ + RACDisposable *leadingDisposable = nil; + RACDisposable *followingDisposable = nil; + + __block BOOL deallocated = NO; + + @autoreleasepool { + RACChannel *channel __attribute__((objc_precise_lifetime)) = [[RACChannel alloc] init]; + [channel.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + deallocated = YES; + }]]; + + leadingDisposable = [channel.leadingTerminal subscribeCompleted:^{}]; + followingDisposable = [channel.followingTerminal subscribeCompleted:^{}]; + } + + [leadingDisposable dispose]; + [followingDisposable dispose]; + expect(deallocated).will.beTruthy(); + }); + + it(@"should dealloc when its subscriptions are disposed", ^{ + RACDisposable *leadingDisposable = nil; + RACDisposable *followingDisposable = nil; + + __block BOOL deallocated = NO; + + @autoreleasepool { + RACChannel *channel __attribute__((objc_precise_lifetime)) = [[RACChannel alloc] init]; + [channel.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + deallocated = YES; + }]]; + + leadingDisposable = [[RACSignal never] subscribe:channel.leadingTerminal]; + followingDisposable = [[RACSignal never] subscribe:channel.followingTerminal]; + } + + [leadingDisposable dispose]; + [followingDisposable dispose]; + expect(deallocated).will.beTruthy(); + }); + }); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACCommandSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACCommandSpec.m new file mode 100644 index 0000000..b0c810b --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACCommandSpec.m
@@ -0,0 +1,526 @@ +// +// RACCommandSpec.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 8/31/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "NSArray+RACSequenceAdditions.h" +#import "NSObject+RACDeallocating.h" +#import "NSObject+RACPropertySubscribing.h" +#import "RACCommand.h" +#import "RACCompoundDisposable.h" +#import "RACDisposable.h" +#import "RACEvent.h" +#import "RACScheduler.h" +#import "RACSequence.h" +#import "RACSignal+Operations.h" +#import "RACSubject.h" +#import "RACUnit.h" + +SpecBegin(RACCommand) + +RACSignal * (^emptySignalBlock)(id) = ^(id _) { + return [RACSignal empty]; +}; + +describe(@"with a simple signal block", ^{ + __block RACCommand *command; + + beforeEach(^{ + command = [[RACCommand alloc] initWithSignalBlock:^(id value) { + return [RACSignal return:value]; + }]; + + expect(command).notTo.beNil(); + expect(command.allowsConcurrentExecution).to.beFalsy(); + }); + + it(@"should be enabled by default", ^{ + expect([command.enabled first]).to.equal(@YES); + }); + + it(@"should not be executing by default", ^{ + expect([command.executing first]).to.equal(@NO); + }); + + it(@"should create an execution signal", ^{ + __block NSUInteger signalsReceived = 0; + __block BOOL completed = NO; + + id value = NSNull.null; + [command.executionSignals subscribeNext:^(RACSignal *signal) { + signalsReceived++; + + [signal subscribeNext:^(id x) { + expect(x).to.equal(value); + } completed:^{ + completed = YES; + }]; + }]; + + expect(signalsReceived).to.equal(0); + + [command execute:value]; + expect(signalsReceived).will.equal(1); + expect(completed).to.beTruthy(); + }); + + it(@"should return the execution signal from -execute:", ^{ + __block BOOL completed = NO; + + id value = NSNull.null; + [[command + execute:value] + subscribeNext:^(id x) { + expect(x).to.equal(value); + } completed:^{ + completed = YES; + }]; + + expect(completed).will.beTruthy(); + }); + + it(@"should always send executionSignals on the main thread", ^{ + __block RACScheduler *receivedScheduler = nil; + [command.executionSignals subscribeNext:^(id _) { + receivedScheduler = RACScheduler.currentScheduler; + }]; + + [[RACScheduler scheduler] schedule:^{ + expect([[command execute:nil] waitUntilCompleted:NULL]).to.beTruthy(); + }]; + + expect(receivedScheduler).to.beNil(); + expect(receivedScheduler).will.equal(RACScheduler.mainThreadScheduler); + }); + + it(@"should not send anything on 'errors' by default", ^{ + __block BOOL receivedError = NO; + [command.errors subscribeNext:^(id _) { + receivedError = YES; + }]; + + expect([[command execute:nil] asynchronouslyWaitUntilCompleted:NULL]).to.beTruthy(); + expect(receivedError).to.beFalsy(); + }); + + it(@"should be executing while an execution signal is running", ^{ + [command.executionSignals subscribeNext:^(RACSignal *signal) { + [signal subscribeNext:^(id x) { + expect([command.executing first]).to.equal(@YES); + }]; + }]; + + expect([[command execute:nil] asynchronouslyWaitUntilCompleted:NULL]).to.beTruthy(); + expect([command.executing first]).to.equal(@NO); + }); + + it(@"should always update executing on the main thread", ^{ + __block RACScheduler *updatedScheduler = nil; + [[command.executing skip:1] subscribeNext:^(NSNumber *executing) { + if (!executing.boolValue) return; + + updatedScheduler = RACScheduler.currentScheduler; + }]; + + [[RACScheduler scheduler] schedule:^{ + expect([[command execute:nil] waitUntilCompleted:NULL]).to.beTruthy(); + }]; + + expect([command.executing first]).to.equal(@NO); + expect(updatedScheduler).will.equal(RACScheduler.mainThreadScheduler); + }); + + it(@"should dealloc without subscribers", ^{ + __block BOOL disposed = NO; + + @autoreleasepool { + RACCommand *command __attribute__((objc_precise_lifetime)) = [[RACCommand alloc] initWithSignalBlock:emptySignalBlock]; + [command.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + disposed = YES; + }]]; + } + + expect(disposed).will.beTruthy(); + }); + + it(@"should complete signals on the main thread when deallocated", ^{ + __block RACScheduler *executionSignalsScheduler = nil; + __block RACScheduler *executingScheduler = nil; + __block RACScheduler *enabledScheduler = nil; + __block RACScheduler *errorsScheduler = nil; + + [[RACScheduler scheduler] schedule:^{ + @autoreleasepool { + RACCommand *command __attribute__((objc_precise_lifetime)) = [[RACCommand alloc] initWithSignalBlock:emptySignalBlock]; + + [command.executionSignals subscribeCompleted:^{ + executionSignalsScheduler = RACScheduler.currentScheduler; + }]; + + [command.executing subscribeCompleted:^{ + executingScheduler = RACScheduler.currentScheduler; + }]; + + [command.enabled subscribeCompleted:^{ + enabledScheduler = RACScheduler.currentScheduler; + }]; + + [command.errors subscribeCompleted:^{ + errorsScheduler = RACScheduler.currentScheduler; + }]; + } + }]; + + expect(executionSignalsScheduler).will.equal(RACScheduler.mainThreadScheduler); + expect(executingScheduler).will.equal(RACScheduler.mainThreadScheduler); + expect(enabledScheduler).will.equal(RACScheduler.mainThreadScheduler); + expect(errorsScheduler).will.equal(RACScheduler.mainThreadScheduler); + }); +}); + +it(@"should invoke the signalBlock once per execution", ^{ + NSMutableArray *valuesReceived = [NSMutableArray array]; + RACCommand *command = [[RACCommand alloc] initWithSignalBlock:^(id x) { + [valuesReceived addObject:x]; + return [RACSignal empty]; + }]; + + expect([[command execute:@"foo"] asynchronouslyWaitUntilCompleted:NULL]).to.beTruthy(); + expect(valuesReceived).to.equal((@[ @"foo" ])); + + expect([[command execute:@"bar"] asynchronouslyWaitUntilCompleted:NULL]).to.beTruthy(); + expect(valuesReceived).to.equal((@[ @"foo", @"bar" ])); +}); + +it(@"should send on executionSignals in order of execution", ^{ + RACCommand *command = [[RACCommand alloc] initWithSignalBlock:^(RACSequence *seq) { + return [seq signalWithScheduler:RACScheduler.immediateScheduler]; + }]; + + NSMutableArray *valuesReceived = [NSMutableArray array]; + [[command.executionSignals + concat] + subscribeNext:^(id x) { + [valuesReceived addObject:x]; + }]; + + RACSequence *first = @[ @"foo", @"bar" ].rac_sequence; + expect([[command execute:first] asynchronouslyWaitUntilCompleted:NULL]).to.beTruthy(); + + RACSequence *second = @[ @"buzz", @"baz" ].rac_sequence; + expect([[command execute:second] asynchronouslyWaitUntilCompleted:NULL]).will.beTruthy(); + + NSArray *expectedValues = @[ @"foo", @"bar", @"buzz", @"baz" ]; + expect(valuesReceived).to.equal(expectedValues); +}); + +it(@"should wait for all signals to complete or error before executing sends NO", ^{ + RACCommand *command = [[RACCommand alloc] initWithSignalBlock:^(RACSignal *signal) { + return signal; + }]; + + command.allowsConcurrentExecution = YES; + + RACSubject *firstSubject = [RACSubject subject]; + expect([command execute:firstSubject]).notTo.beNil(); + + RACSubject *secondSubject = [RACSubject subject]; + expect([command execute:secondSubject]).notTo.beNil(); + + expect([command.executing first]).will.equal(@YES); + + [firstSubject sendError:nil]; + expect([command.executing first]).to.equal(@YES); + + [secondSubject sendNext:nil]; + expect([command.executing first]).to.equal(@YES); + + [secondSubject sendCompleted]; + expect([command.executing first]).will.equal(@NO); +}); + +it(@"should not deliver errors from executionSignals", ^{ + RACSubject *subject = [RACSubject subject]; + NSMutableArray *receivedEvents = [NSMutableArray array]; + + RACCommand *command = [[RACCommand alloc] initWithSignalBlock:^(id _) { + return subject; + }]; + + [[[command.executionSignals + flatten] + materialize] + subscribeNext:^(RACEvent *event) { + [receivedEvents addObject:event]; + }]; + + expect([command execute:nil]).notTo.beNil(); + expect([command.executing first]).will.equal(@YES); + + [subject sendNext:RACUnit.defaultUnit]; + + NSArray *expectedEvents = @[ [RACEvent eventWithValue:RACUnit.defaultUnit] ]; + expect(receivedEvents).will.equal(expectedEvents); + expect([command.executing first]).to.equal(@YES); + + [subject sendNext:@"foo"]; + + expectedEvents = @[ [RACEvent eventWithValue:RACUnit.defaultUnit], [RACEvent eventWithValue:@"foo"] ]; + expect(receivedEvents).will.equal(expectedEvents); + expect([command.executing first]).to.equal(@YES); + + NSError *error = [NSError errorWithDomain:@"" code:1 userInfo:nil]; + [subject sendError:error]; + + expect([command.executing first]).will.equal(@NO); + expect(receivedEvents).to.equal(expectedEvents); +}); + +it(@"should deliver errors from -execute:", ^{ + RACSubject *subject = [RACSubject subject]; + NSMutableArray *receivedEvents = [NSMutableArray array]; + + RACCommand *command = [[RACCommand alloc] initWithSignalBlock:^(id _) { + return subject; + }]; + + [[[command + execute:nil] + materialize] + subscribeNext:^(RACEvent *event) { + [receivedEvents addObject:event]; + }]; + + expect([command.executing first]).will.equal(@YES); + + [subject sendNext:RACUnit.defaultUnit]; + + NSArray *expectedEvents = @[ [RACEvent eventWithValue:RACUnit.defaultUnit] ]; + expect(receivedEvents).will.equal(expectedEvents); + expect([command.executing first]).to.equal(@YES); + + [subject sendNext:@"foo"]; + + expectedEvents = @[ [RACEvent eventWithValue:RACUnit.defaultUnit], [RACEvent eventWithValue:@"foo"] ]; + expect(receivedEvents).will.equal(expectedEvents); + expect([command.executing first]).to.equal(@YES); + + NSError *error = [NSError errorWithDomain:@"" code:1 userInfo:nil]; + [subject sendError:error]; + + expectedEvents = @[ [RACEvent eventWithValue:RACUnit.defaultUnit], [RACEvent eventWithValue:@"foo"], [RACEvent eventWithError:error] ]; + expect(receivedEvents).will.equal(expectedEvents); + expect([command.executing first]).will.equal(@NO); +}); + +it(@"should deliver errors onto 'errors'", ^{ + RACCommand *command = [[RACCommand alloc] initWithSignalBlock:^(RACSignal *signal) { + return signal; + }]; + + command.allowsConcurrentExecution = YES; + + RACSubject *firstSubject = [RACSubject subject]; + expect([command execute:firstSubject]).notTo.beNil(); + + RACSubject *secondSubject = [RACSubject subject]; + expect([command execute:secondSubject]).notTo.beNil(); + + NSError *firstError = [NSError errorWithDomain:@"" code:1 userInfo:nil]; + NSError *secondError = [NSError errorWithDomain:@"" code:2 userInfo:nil]; + + // We should receive errors from our previously-started executions. + NSMutableArray *receivedErrors = [NSMutableArray array]; + [command.errors subscribeNext:^(NSError *error) { + [receivedErrors addObject:error]; + }]; + + expect([command.executing first]).will.equal(@YES); + + [firstSubject sendError:firstError]; + expect([command.executing first]).will.equal(@YES); + + NSArray *expected = @[ firstError ]; + expect(receivedErrors).will.equal(expected); + + [secondSubject sendError:secondError]; + expect([command.executing first]).will.equal(@NO); + + expected = @[ firstError, secondError ]; + expect(receivedErrors).will.equal(expected); +}); + +it(@"should not deliver non-error events onto 'errors'", ^{ + RACSubject *subject = [RACSubject subject]; + RACCommand *command = [[RACCommand alloc] initWithSignalBlock:^(id _) { + return subject; + }]; + + __block BOOL receivedEvent = NO; + [command.errors subscribeNext:^(id _) { + receivedEvent = YES; + }]; + + expect([command execute:nil]).notTo.beNil(); + expect([command.executing first]).will.equal(@YES); + + [subject sendNext:RACUnit.defaultUnit]; + [subject sendCompleted]; + + expect([command.executing first]).will.equal(@NO); + expect(receivedEvent).to.beFalsy(); +}); + +it(@"should send errors on the main thread", ^{ + RACCommand *command = [[RACCommand alloc] initWithSignalBlock:^(RACSignal *signal) { + return signal; + }]; + + NSError *error = [NSError errorWithDomain:@"" code:1 userInfo:nil]; + + __block RACScheduler *receivedScheduler = nil; + [command.errors subscribeNext:^(NSError *e) { + expect(e).to.equal(error); + receivedScheduler = RACScheduler.currentScheduler; + }]; + + RACSignal *errorSignal = [RACSignal error:error]; + + [[RACScheduler scheduler] schedule:^{ + expect([[command execute:errorSignal] waitUntilCompleted:NULL]).to.beTruthy(); + }]; + + expect(receivedScheduler).to.beNil(); + expect(receivedScheduler).will.equal(RACScheduler.mainThreadScheduler); +}); + +describe(@"enabled signal", ^{ + __block RACSubject *enabledSubject; + __block RACCommand *command; + + beforeEach(^{ + enabledSubject = [RACSubject subject]; + command = [[RACCommand alloc] initWithEnabled:enabledSubject signalBlock:^(id _) { + return [RACSignal return:RACUnit.defaultUnit]; + }]; + }); + + it(@"should send YES by default", ^{ + expect([command.enabled first]).to.equal(@YES); + }); + + it(@"should send whatever the enabledSignal has sent most recently", ^{ + [enabledSubject sendNext:@NO]; + expect([command.enabled first]).will.equal(@NO); + + [enabledSubject sendNext:@YES]; + expect([command.enabled first]).will.equal(@YES); + + [enabledSubject sendNext:@NO]; + expect([command.enabled first]).will.equal(@NO); + }); + + it(@"should sample enabledSignal synchronously at initialization time", ^{ + RACCommand *command = [[RACCommand alloc] initWithEnabled:[RACSignal return:@NO] signalBlock:^(id _) { + return [RACSignal empty]; + }]; + expect([command.enabled first]).to.equal(@NO); + }); + + it(@"should send NO while executing is YES and allowsConcurrentExecution is NO", ^{ + [[command.executionSignals flatten] subscribeNext:^(id _) { + expect([command.executing first]).to.equal(@YES); + expect([command.enabled first]).to.equal(@NO); + }]; + + expect([command.enabled first]).to.equal(@YES); + expect([[command execute:nil] asynchronouslyWaitUntilCompleted:NULL]).to.beTruthy(); + expect([command.enabled first]).to.equal(@YES); + }); + + it(@"should send YES while executing is YES and allowsConcurrentExecution is YES", ^{ + command.allowsConcurrentExecution = YES; + + __block BOOL outerExecuted = NO; + __block BOOL innerExecuted = NO; + + // Prevent infinite recursion by only responding to the first value. + [[[command.executionSignals + take:1] + flatten] + subscribeNext:^(id _) { + outerExecuted = YES; + + expect([command.executing first]).to.equal(@YES); + expect([command.enabled first]).to.equal(@YES); + + [[command execute:nil] subscribeCompleted:^{ + innerExecuted = YES; + }]; + }]; + + expect([command.enabled first]).to.equal(@YES); + + expect([command execute:nil]).notTo.beNil(); + expect(outerExecuted).will.beTruthy(); + expect(innerExecuted).will.beTruthy(); + + expect([command.enabled first]).to.equal(@YES); + }); + + it(@"should send an error from -execute: when NO", ^{ + [enabledSubject sendNext:@NO]; + + RACSignal *signal = [command execute:nil]; + expect(signal).notTo.beNil(); + + __block BOOL success = NO; + __block NSError *error = nil; + expect([signal firstOrDefault:nil success:&success error:&error]).to.beNil(); + expect(success).to.beFalsy(); + + expect(error).notTo.beNil(); + expect(error.domain).to.equal(RACCommandErrorDomain); + expect(error.code).to.equal(RACCommandErrorNotEnabled); + expect(error.userInfo[RACUnderlyingCommandErrorKey]).to.beIdenticalTo(command); + }); + + it(@"should always update on the main thread", ^{ + __block RACScheduler *updatedScheduler = nil; + [[command.enabled skip:1] subscribeNext:^(id _) { + updatedScheduler = RACScheduler.currentScheduler; + }]; + + [[RACScheduler scheduler] schedule:^{ + [enabledSubject sendNext:@NO]; + }]; + + expect([command.enabled first]).to.equal(@YES); + expect([command.enabled first]).will.equal(@NO); + expect(updatedScheduler).to.equal(RACScheduler.mainThreadScheduler); + }); + + it(@"should complete when the command is deallocated even if the input signal hasn't", ^{ + __block BOOL deallocated = NO; + __block BOOL completed = NO; + + @autoreleasepool { + RACCommand *command __attribute__((objc_precise_lifetime)) = [[RACCommand alloc] initWithEnabled:enabledSubject signalBlock:emptySignalBlock]; + [command.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + deallocated = YES; + }]]; + + [command.enabled subscribeCompleted:^{ + completed = YES; + }]; + } + + expect(deallocated).will.beTruthy(); + expect(completed).will.beTruthy(); + }); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACCompoundDisposableSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACCompoundDisposableSpec.m new file mode 100644 index 0000000..faad3bb --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACCompoundDisposableSpec.m
@@ -0,0 +1,109 @@ +// +// RACCompoundDisposableSpec.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 11/30/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACCompoundDisposable.h" + +SpecBegin(RACCompoundDisposable) + +it(@"should dispose of all its contained disposables", ^{ + __block BOOL d1Disposed = NO; + RACDisposable *d1 = [RACDisposable disposableWithBlock:^{ + d1Disposed = YES; + }]; + + __block BOOL d2Disposed = NO; + RACDisposable *d2 = [RACDisposable disposableWithBlock:^{ + d2Disposed = YES; + }]; + + __block BOOL d3Disposed = NO; + RACDisposable *d3 = [RACDisposable disposableWithBlock:^{ + d3Disposed = YES; + }]; + + __block BOOL d4Disposed = NO; + RACDisposable *d4 = [RACDisposable disposableWithBlock:^{ + d4Disposed = YES; + }]; + + RACCompoundDisposable *disposable = [RACCompoundDisposable compoundDisposableWithDisposables:@[ d1, d2, d3 ]]; + [disposable addDisposable:d4]; + + expect(d1Disposed).to.beFalsy(); + expect(d2Disposed).to.beFalsy(); + expect(d3Disposed).to.beFalsy(); + expect(d4Disposed).to.beFalsy(); + expect(disposable.disposed).to.beFalsy(); + + [disposable dispose]; + + expect(d1Disposed).to.beTruthy(); + expect(d2Disposed).to.beTruthy(); + expect(d3Disposed).to.beTruthy(); + expect(d4Disposed).to.beTruthy(); + expect(disposable.disposed).to.beTruthy(); +}); + +it(@"should dispose of any added disposables immediately if it's already been disposed", ^{ + RACCompoundDisposable *disposable = [RACCompoundDisposable compoundDisposable]; + [disposable dispose]; + + RACDisposable *d = [[RACDisposable alloc] init]; + + expect(d.disposed).to.beFalsy(); + [disposable addDisposable:d]; + expect(d.disposed).to.beTruthy(); +}); + +it(@"should work when initialized with -init", ^{ + RACCompoundDisposable *disposable = [[RACCompoundDisposable alloc] init]; + + __block BOOL disposed = NO; + RACDisposable *d = [RACDisposable disposableWithBlock:^{ + disposed = YES; + }]; + + [disposable addDisposable:d]; + expect(disposed).to.beFalsy(); + + [disposable dispose]; + expect(disposed).to.beTruthy(); +}); + +it(@"should work when initialized with +disposableWithBlock:", ^{ + __block BOOL compoundDisposed = NO; + RACCompoundDisposable *disposable = [RACCompoundDisposable disposableWithBlock:^{ + compoundDisposed = YES; + }]; + + __block BOOL disposed = NO; + RACDisposable *d = [RACDisposable disposableWithBlock:^{ + disposed = YES; + }]; + + [disposable addDisposable:d]; + expect(disposed).to.beFalsy(); + expect(compoundDisposed).to.beFalsy(); + + [disposable dispose]; + expect(disposed).to.beTruthy(); + expect(compoundDisposed).to.beTruthy(); +}); + +it(@"should allow disposables to be removed", ^{ + RACCompoundDisposable *disposable = [[RACCompoundDisposable alloc] init]; + RACDisposable *d = [[RACDisposable alloc] init]; + + [disposable addDisposable:d]; + [disposable removeDisposable:d]; + + [disposable dispose]; + expect(d.disposed).to.beFalsy(); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACControlCommandExamples.h b/ReactiveCocoaFramework/ReactiveCocoaTests/RACControlCommandExamples.h new file mode 100644 index 0000000..3fbaa34 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACControlCommandExamples.h
@@ -0,0 +1,18 @@ +// +// RACControlCommandExamples.h +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-08-15. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +// The name of the shared examples for any control class that has +// `rac_command` and `isEnabled` properties. +extern NSString * const RACControlCommandExamples; + +// The control to test. +extern NSString * const RACControlCommandExampleControl; + +// A block of type `void (^)(id control)` which should activate the +// `rac_command` of the `control` by manipulating the control itself. +extern NSString * const RACControlCommandExampleActivateBlock;
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACControlCommandExamples.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACControlCommandExamples.m new file mode 100644 index 0000000..034cc81 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACControlCommandExamples.m
@@ -0,0 +1,81 @@ +// +// RACControlCommandExamples.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-08-15. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACControlCommandExamples.h" + +#import "RACCommand.h" +#import "RACSubject.h" +#import "RACUnit.h" + +NSString * const RACControlCommandExamples = @"RACControlCommandExamples"; +NSString * const RACControlCommandExampleControl = @"RACControlCommandExampleControl"; +NSString * const RACControlCommandExampleActivateBlock = @"RACControlCommandExampleActivateBlock"; + +// Methods used by the unit test that would otherwise require platform-specific +// imports. +@interface NSObject (RACControlCommandExamples) + +@property (nonatomic, strong) RACCommand *rac_command; + +- (BOOL)isEnabled; + +@end + +SharedExampleGroupsBegin(RACControlCommandExamples) + +sharedExamplesFor(RACControlCommandExamples, ^(NSDictionary *data) { + __block id control; + __block void (^activate)(id); + + __block RACSubject *enabledSubject; + __block RACCommand *command; + + beforeEach(^{ + control = data[RACControlCommandExampleControl]; + activate = [data[RACControlCommandExampleActivateBlock] copy]; + + enabledSubject = [RACSubject subject]; + command = [[RACCommand alloc] initWithEnabled:enabledSubject signalBlock:^(id sender) { + return [RACSignal return:sender]; + }]; + + [control setRac_command:command]; + }); + + it(@"should bind the control's enabledness to the command", ^{ + expect([control isEnabled]).will.beTruthy(); + + [enabledSubject sendNext:@NO]; + expect([control isEnabled]).will.beFalsy(); + + [enabledSubject sendNext:@YES]; + expect([control isEnabled]).will.beTruthy(); + }); + + it(@"should execute the control's command when activated", ^{ + __block BOOL executed = NO; + [[command.executionSignals flatten] subscribeNext:^(id sender) { + expect(sender).to.equal(control); + executed = YES; + }]; + + activate(control); + expect(executed).will.beTruthy(); + }); + + it(@"should overwrite an existing command when setting a new one", ^{ + RACCommand *secondCommand = [[RACCommand alloc] initWithSignalBlock:^(id _) { + return [RACSignal return:RACUnit.defaultUnit]; + }]; + + [control setRac_command:secondCommand]; + expect([control rac_command]).to.beIdenticalTo(secondCommand); + }); +}); + +SharedExampleGroupsEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACDelegateProxySpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACDelegateProxySpec.m new file mode 100644 index 0000000..831c3a3 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACDelegateProxySpec.m
@@ -0,0 +1,89 @@ +// +// RACDelegateProxySpec.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-06-22. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "NSObject+RACSelectorSignal.h" +#import "RACDelegateProxy.h" +#import "RACSignal.h" +#import "RACTuple.h" +#import "RACCompoundDisposable.h" +#import "NSObject+RACDeallocating.h" + +@protocol TestDelegateProtocol +- (NSUInteger)lengthOfString:(NSString *)str; +@end + +@interface TestDelegate : NSObject <TestDelegateProtocol> +@property (nonatomic, assign) BOOL lengthOfStringInvoked; +@end + +SpecBegin(RACDelegateProxy) + +__block id proxy; +__block TestDelegate *delegate; +__block Protocol *protocol; + +beforeEach(^{ + protocol = @protocol(TestDelegateProtocol); + expect(protocol).notTo.beNil(); + + proxy = [[RACDelegateProxy alloc] initWithProtocol:protocol]; + expect(proxy).notTo.beNil(); + expect([proxy rac_proxiedDelegate]).to.beNil(); + + delegate = [[TestDelegate alloc] init]; + expect(delegate).notTo.beNil(); +}); + +it(@"should not respond to selectors at first", ^{ + expect([proxy respondsToSelector:@selector(lengthOfString:)]).to.beFalsy(); +}); + +it(@"should send on a signal for a protocol method", ^{ + __block RACTuple *tuple; + [[proxy signalForSelector:@selector(lengthOfString:)] subscribeNext:^(RACTuple *t) { + tuple = t; + }]; + + expect([proxy respondsToSelector:@selector(lengthOfString:)]).to.beTruthy(); + expect([proxy lengthOfString:@"foo"]).to.equal(0); + expect(tuple).to.equal(RACTuplePack(@"foo")); +}); + +it(@"should forward to the proxied delegate", ^{ + [proxy setRac_proxiedDelegate:delegate]; + + expect([proxy respondsToSelector:@selector(lengthOfString:)]).to.beTruthy(); + expect([proxy lengthOfString:@"foo"]).to.equal(3); + expect(delegate.lengthOfStringInvoked).to.beTruthy(); +}); + +it(@"should not send to the delegate when signals are applied", ^{ + [proxy setRac_proxiedDelegate:delegate]; + + __block RACTuple *tuple; + [[proxy signalForSelector:@selector(lengthOfString:)] subscribeNext:^(RACTuple *t) { + tuple = t; + }]; + + expect([proxy respondsToSelector:@selector(lengthOfString:)]).to.beTruthy(); + expect([proxy lengthOfString:@"foo"]).to.equal(0); + + expect(tuple).to.equal(RACTuplePack(@"foo")); + expect(delegate.lengthOfStringInvoked).to.beFalsy(); +}); + +SpecEnd + +@implementation TestDelegate + +- (NSUInteger)lengthOfString:(NSString *)str { + self.lengthOfStringInvoked = YES; + return str.length; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACDisposableSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACDisposableSpec.m new file mode 100644 index 0000000..8cde917 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACDisposableSpec.m
@@ -0,0 +1,73 @@ +// +// RACDisposableSpec.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-06-13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACDisposable.h" +#import "RACScopedDisposable.h" + +SpecBegin(RACDisposable) + +it(@"should initialize without a block", ^{ + RACDisposable *disposable = [[RACDisposable alloc] init]; + expect(disposable).notTo.beNil(); + expect(disposable.disposed).to.beFalsy(); + + [disposable dispose]; + expect(disposable.disposed).to.beTruthy(); +}); + +it(@"should execute a block upon disposal", ^{ + __block BOOL disposed = NO; + RACDisposable *disposable = [RACDisposable disposableWithBlock:^{ + disposed = YES; + }]; + + expect(disposable).notTo.beNil(); + expect(disposed).to.beFalsy(); + expect(disposable.disposed).to.beFalsy(); + + [disposable dispose]; + expect(disposed).to.beTruthy(); + expect(disposable.disposed).to.beTruthy(); +}); + +it(@"should not dispose upon deallocation", ^{ + __block BOOL disposed = NO; + __weak RACDisposable *weakDisposable = nil; + + @autoreleasepool { + RACDisposable *disposable = [RACDisposable disposableWithBlock:^{ + disposed = YES; + }]; + + weakDisposable = disposable; + expect(weakDisposable).notTo.beNil(); + } + + expect(weakDisposable).to.beNil(); + expect(disposed).to.beFalsy(); +}); + +it(@"should create a scoped disposable", ^{ + __block BOOL disposed = NO; + __weak RACScopedDisposable *weakDisposable = nil; + + @autoreleasepool { + RACScopedDisposable *disposable __attribute__((objc_precise_lifetime)) = [RACScopedDisposable disposableWithBlock:^{ + disposed = YES; + }]; + + weakDisposable = disposable; + expect(weakDisposable).notTo.beNil(); + expect(disposed).to.beFalsy(); + } + + expect(weakDisposable).to.beNil(); + expect(disposed).to.beTruthy(); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACEventSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACEventSpec.m new file mode 100644 index 0000000..9545fb6 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACEventSpec.m
@@ -0,0 +1,80 @@ +// +// RACEventSpec.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-01-07. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACEvent.h" + +SpecBegin(RACEvent) + +it(@"should return the singleton completed event", ^{ + RACEvent *event = RACEvent.completedEvent; + expect(event).notTo.beNil(); + + expect(event).to.beIdenticalTo(RACEvent.completedEvent); + expect([event copy]).to.beIdenticalTo(event); + + expect(event.eventType).to.equal(RACEventTypeCompleted); + expect(event.finished).to.beTruthy(); + expect(event.error).to.beNil(); + expect(event.value).to.beNil(); +}); + +it(@"should return an error event", ^{ + NSError *error = [NSError errorWithDomain:@"foo" code:1 userInfo:nil]; + RACEvent *event = [RACEvent eventWithError:error]; + expect(event).notTo.beNil(); + + expect(event).to.equal([RACEvent eventWithError:error]); + expect([event copy]).to.equal(event); + + expect(event.eventType).to.equal(RACEventTypeError); + expect(event.finished).to.beTruthy(); + expect(event.error).to.equal(error); + expect(event.value).to.beNil(); +}); + +it(@"should return an error event with a nil error", ^{ + RACEvent *event = [RACEvent eventWithError:nil]; + expect(event).notTo.beNil(); + + expect(event).to.equal([RACEvent eventWithError:nil]); + expect([event copy]).to.equal(event); + + expect(event.eventType).to.equal(RACEventTypeError); + expect(event.finished).to.beTruthy(); + expect(event.error).to.beNil(); + expect(event.value).to.beNil(); +}); + +it(@"should return a next event", ^{ + NSString *value = @"foo"; + RACEvent *event = [RACEvent eventWithValue:value]; + expect(event).notTo.beNil(); + + expect(event).to.equal([RACEvent eventWithValue:value]); + expect([event copy]).to.equal(event); + + expect(event.eventType).to.equal(RACEventTypeNext); + expect(event.finished).to.beFalsy(); + expect(event.error).to.beNil(); + expect(event.value).to.equal(value); +}); + +it(@"should return a next event with a nil value", ^{ + RACEvent *event = [RACEvent eventWithValue:nil]; + expect(event).notTo.beNil(); + + expect(event).to.equal([RACEvent eventWithValue:nil]); + expect([event copy]).to.equal(event); + + expect(event.eventType).to.equal(RACEventTypeNext); + expect(event.finished).to.beFalsy(); + expect(event.error).to.beNil(); + expect(event.value).to.beNil(); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACKVOChannelSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACKVOChannelSpec.m new file mode 100644 index 0000000..8007511 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACKVOChannelSpec.m
@@ -0,0 +1,389 @@ +// +// RACKVOChannelSpec.m +// ReactiveCocoa +// +// Created by Uri Baghin on 16/12/2012. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACTestObject.h" +#import "RACChannelExamples.h" +#import "RACPropertySignalExamples.h" + +#import "NSObject+RACDeallocating.h" +#import "NSObject+RACKVOWrapper.h" +#import "RACCompoundDisposable.h" +#import "RACDisposable.h" +#import "RACKVOChannel.h" +#import "RACSignal+Operations.h" + +SpecBegin(RACKVOChannel) + +describe(@"RACKVOChannel", ^{ + __block RACTestObject *object; + __block RACKVOChannel *channel; + id value1 = @"test value 1"; + id value2 = @"test value 2"; + id value3 = @"test value 3"; + NSArray *values = @[ value1, value2, value3 ]; + + before(^{ + object = [[RACTestObject alloc] init]; + channel = [[RACKVOChannel alloc] initWithTarget:object keyPath:@keypath(object.stringValue) nilValue:nil]; + }); + + id setupBlock = ^(RACTestObject *testObject, NSString *keyPath, id nilValue, RACSignal *signal) { + RACKVOChannel *channel = [[RACKVOChannel alloc] initWithTarget:testObject keyPath:keyPath nilValue:nilValue]; + [signal subscribe:channel.followingTerminal]; + }; + + itShouldBehaveLike(RACPropertySignalExamples, ^{ + return @{ RACPropertySignalExamplesSetupBlock: setupBlock }; + }); + + itShouldBehaveLike(RACChannelExamples, @{ + RACChannelExampleCreateBlock: [^{ + return [[RACKVOChannel alloc] initWithTarget:object keyPath:@keypath(object.stringValue) nilValue:nil]; + } copy] + }); + + it(@"should send the object's current value when subscribed to followingTerminal", ^{ + __block id receivedValue = @"received value should not be this"; + [[channel.followingTerminal take:1] subscribeNext:^(id x) { + receivedValue = x; + }]; + + expect(receivedValue).to.beNil(); + + object.stringValue = value1; + [[channel.followingTerminal take:1] subscribeNext:^(id x) { + receivedValue = x; + }]; + + expect(receivedValue).to.equal(value1); + }); + + it(@"should send the object's new value on followingTerminal when it's changed", ^{ + object.stringValue = value1; + + NSMutableArray *receivedValues = [NSMutableArray array]; + [channel.followingTerminal subscribeNext:^(id x) { + [receivedValues addObject:x]; + }]; + + object.stringValue = value2; + object.stringValue = value3; + expect(receivedValues).to.equal(values); + }); + + it(@"should set the object's value using values sent to the followingTerminal", ^{ + expect(object.stringValue).to.beNil(); + + [channel.followingTerminal sendNext:value1]; + expect(object.stringValue).to.equal(value1); + + [channel.followingTerminal sendNext:value2]; + expect(object.stringValue).to.equal(value2); + }); + + it(@"should be able to subscribe to signals", ^{ + NSMutableArray *receivedValues = [NSMutableArray array]; + [object rac_observeKeyPath:@keypath(object.stringValue) options:0 observer:self block:^(id value, NSDictionary *change) { + [receivedValues addObject:value]; + }]; + + RACSignal *signal = [RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) { + [subscriber sendNext:value1]; + [subscriber sendNext:value2]; + [subscriber sendNext:value3]; + return nil; + }]; + + [signal subscribe:channel.followingTerminal]; + expect(receivedValues).to.equal(values); + }); + + it(@"should complete both terminals when the target deallocates", ^{ + __block BOOL leadingCompleted = NO; + __block BOOL followingCompleted = NO; + __block BOOL deallocated = NO; + + @autoreleasepool { + RACTestObject *object __attribute__((objc_precise_lifetime)) = [[RACTestObject alloc] init]; + [object.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + deallocated = YES; + }]]; + + RACKVOChannel *channel = [[RACKVOChannel alloc] initWithTarget:object keyPath:@keypath(object.stringValue) nilValue:nil]; + [channel.leadingTerminal subscribeCompleted:^{ + leadingCompleted = YES; + }]; + + [channel.followingTerminal subscribeCompleted:^{ + followingCompleted = YES; + }]; + + expect(deallocated).to.beFalsy(); + expect(leadingCompleted).to.beFalsy(); + expect(followingCompleted).to.beFalsy(); + } + + expect(deallocated).to.beTruthy(); + expect(leadingCompleted).to.beTruthy(); + expect(followingCompleted).to.beTruthy(); + }); + + it(@"should deallocate when the target deallocates", ^{ + __block BOOL targetDeallocated = NO; + __block BOOL channelDeallocated = NO; + + @autoreleasepool { + RACTestObject *object __attribute__((objc_precise_lifetime)) = [[RACTestObject alloc] init]; + [object.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + targetDeallocated = YES; + }]]; + + RACKVOChannel *channel = [[RACKVOChannel alloc] initWithTarget:object keyPath:@keypath(object.stringValue) nilValue:nil]; + [channel.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + channelDeallocated = YES; + }]]; + + expect(targetDeallocated).to.beFalsy(); + expect(channelDeallocated).to.beFalsy(); + } + + expect(targetDeallocated).to.beTruthy(); + expect(channelDeallocated).to.beTruthy(); + }); +}); + +describe(@"RACChannelTo", ^{ + __block RACTestObject *a; + __block RACTestObject *b; + __block RACTestObject *c; + __block NSString *testName1; + __block NSString *testName2; + __block NSString *testName3; + + before(^{ + a = [[RACTestObject alloc] init]; + b = [[RACTestObject alloc] init]; + c = [[RACTestObject alloc] init]; + testName1 = @"sync it!"; + testName2 = @"sync it again!"; + testName3 = @"sync it once more!"; + }); + + it(@"should keep objects' properties in sync", ^{ + RACChannelTo(a, stringValue) = RACChannelTo(b, stringValue); + expect(a.stringValue).to.beNil(); + expect(b.stringValue).to.beNil(); + + a.stringValue = testName1; + expect(a.stringValue).to.equal(testName1); + expect(b.stringValue).to.equal(testName1); + + b.stringValue = testName2; + expect(a.stringValue).to.equal(testName2); + expect(b.stringValue).to.equal(testName2); + + a.stringValue = nil; + expect(a.stringValue).to.beNil(); + expect(b.stringValue).to.beNil(); + }); + + it(@"should keep properties identified by keypaths in sync", ^{ + RACChannelTo(a, strongTestObjectValue.stringValue) = RACChannelTo(b, strongTestObjectValue.stringValue); + a.strongTestObjectValue = [[RACTestObject alloc] init]; + b.strongTestObjectValue = [[RACTestObject alloc] init]; + + a.strongTestObjectValue.stringValue = testName1; + expect(a.strongTestObjectValue.stringValue).to.equal(testName1); + expect(b.strongTestObjectValue.stringValue).to.equal(testName1); + expect(a.strongTestObjectValue).notTo.equal(b.strongTestObjectValue); + + b.strongTestObjectValue = nil; + expect(a.strongTestObjectValue.stringValue).to.beNil(); + + c.stringValue = testName2; + b.strongTestObjectValue = c; + expect(a.strongTestObjectValue.stringValue).to.equal(testName2); + expect(b.strongTestObjectValue.stringValue).to.equal(testName2); + expect(a.strongTestObjectValue).notTo.equal(b.strongTestObjectValue); + }); + + it(@"should update properties identified by keypaths when the intermediate values change", ^{ + RACChannelTo(a, strongTestObjectValue.stringValue) = RACChannelTo(b, strongTestObjectValue.stringValue); + a.strongTestObjectValue = [[RACTestObject alloc] init]; + b.strongTestObjectValue = [[RACTestObject alloc] init]; + c.stringValue = testName1; + b.strongTestObjectValue = c; + + expect(a.strongTestObjectValue.stringValue).to.equal(testName1); + expect(a.strongTestObjectValue).notTo.equal(b.strongTestObjectValue); + }); + + it(@"should update properties identified by keypaths when the channel was created when one of the two objects had an intermediate nil value", ^{ + RACChannelTo(a, strongTestObjectValue.stringValue) = RACChannelTo(b, strongTestObjectValue.stringValue); + b.strongTestObjectValue = [[RACTestObject alloc] init]; + c.stringValue = testName1; + a.strongTestObjectValue = c; + + expect(a.strongTestObjectValue.stringValue).to.equal(testName1); + expect(b.strongTestObjectValue.stringValue).to.equal(testName1); + expect(a.strongTestObjectValue).notTo.equal(b.strongTestObjectValue); + }); + + it(@"should take the value of the object being bound to at the start", ^{ + a.stringValue = testName1; + b.stringValue = testName2; + + RACChannelTo(a, stringValue) = RACChannelTo(b, stringValue); + expect(a.stringValue).to.equal(testName2); + expect(b.stringValue).to.equal(testName2); + }); + + it(@"should update the value even if it's the same value the object had before it was bound", ^{ + a.stringValue = testName1; + b.stringValue = testName2; + + RACChannelTo(a, stringValue) = RACChannelTo(b, stringValue); + expect(a.stringValue).to.equal(testName2); + expect(b.stringValue).to.equal(testName2); + + b.stringValue = testName1; + expect(a.stringValue).to.equal(testName1); + expect(b.stringValue).to.equal(testName1); + }); + + it(@"should bind transitively", ^{ + a.stringValue = testName1; + b.stringValue = testName2; + c.stringValue = testName3; + + RACChannelTo(a, stringValue) = RACChannelTo(b, stringValue); + RACChannelTo(b, stringValue) = RACChannelTo(c, stringValue); + expect(a.stringValue).to.equal(testName3); + expect(b.stringValue).to.equal(testName3); + expect(c.stringValue).to.equal(testName3); + + c.stringValue = testName1; + expect(a.stringValue).to.equal(testName1); + expect(b.stringValue).to.equal(testName1); + expect(c.stringValue).to.equal(testName1); + + b.stringValue = testName2; + expect(a.stringValue).to.equal(testName2); + expect(b.stringValue).to.equal(testName2); + expect(c.stringValue).to.equal(testName2); + + a.stringValue = testName3; + expect(a.stringValue).to.equal(testName3); + expect(b.stringValue).to.equal(testName3); + expect(c.stringValue).to.equal(testName3); + }); + + it(@"should bind changes made by KVC on arrays", ^{ + b.arrayValue = @[]; + RACChannelTo(a, arrayValue) = RACChannelTo(b, arrayValue); + + [[b mutableArrayValueForKeyPath:@keypath(b.arrayValue)] addObject:@1]; + expect(a.arrayValue).to.equal(b.arrayValue); + }); + + it(@"should bind changes made by KVC on sets", ^{ + b.setValue = [NSSet set]; + RACChannelTo(a, setValue) = RACChannelTo(b, setValue); + + [[b mutableSetValueForKeyPath:@keypath(b.setValue)] addObject:@1]; + expect(a.setValue).to.equal(b.setValue); + }); + + it(@"should bind changes made by KVC on ordered sets", ^{ + b.orderedSetValue = [NSOrderedSet orderedSet]; + RACChannelTo(a, orderedSetValue) = RACChannelTo(b, orderedSetValue); + + [[b mutableOrderedSetValueForKeyPath:@keypath(b.orderedSetValue)] addObject:@1]; + expect(a.orderedSetValue).to.equal(b.orderedSetValue); + }); + + it(@"should handle deallocation of intermediate objects correctly even without support from KVO", ^{ + __block BOOL wasDisposed = NO; + + RACChannelTo(a, weakTestObjectValue.stringValue) = RACChannelTo(b, strongTestObjectValue.stringValue); + b.strongTestObjectValue = [[RACTestObject alloc] init]; + + @autoreleasepool { + RACTestObject *object = [[RACTestObject alloc] init]; + [object.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + wasDisposed = YES; + }]]; + + a.weakTestObjectValue = object; + object.stringValue = testName1; + + expect(wasDisposed).to.beFalsy(); + expect(b.strongTestObjectValue.stringValue).to.equal(testName1); + } + + expect(wasDisposed).will.beTruthy(); + expect(b.strongTestObjectValue.stringValue).to.beNil(); + }); + + it(@"should stop binding when disposed", ^{ + RACChannelTerminal *aTerminal = RACChannelTo(a, stringValue); + RACChannelTerminal *bTerminal = RACChannelTo(b, stringValue); + + a.stringValue = testName1; + RACDisposable *disposable = [aTerminal subscribe:bTerminal]; + + expect(a.stringValue).to.equal(testName1); + expect(b.stringValue).to.equal(testName1); + + a.stringValue = testName2; + expect(a.stringValue).to.equal(testName2); + expect(b.stringValue).to.equal(testName2); + + [disposable dispose]; + + a.stringValue = testName3; + expect(a.stringValue).to.equal(testName3); + expect(b.stringValue).to.equal(testName2); + }); + + it(@"should use the nilValue when sent nil", ^{ + RACChannelTerminal *terminal = RACChannelTo(a, integerValue, @5); + expect(a.integerValue).to.equal(0); + + [terminal sendNext:@2]; + expect(a.integerValue).to.equal(2); + + [terminal sendNext:nil]; + expect(a.integerValue).to.equal(5); + }); + + it(@"should use the nilValue when an intermediate object is nil", ^{ + __block BOOL wasDisposed = NO; + + RACChannelTo(a, weakTestObjectValue.integerValue, @5) = RACChannelTo(b, strongTestObjectValue.integerValue, @5); + b.strongTestObjectValue = [[RACTestObject alloc] init]; + + @autoreleasepool { + RACTestObject *object = [[RACTestObject alloc] init]; + [object.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + wasDisposed = YES; + }]]; + + a.weakTestObjectValue = object; + object.integerValue = 2; + + expect(wasDisposed).to.beFalsy(); + expect(b.strongTestObjectValue.integerValue).to.equal(2); + } + + expect(wasDisposed).will.beTruthy(); + expect(b.strongTestObjectValue.integerValue).to.equal(5); + }); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACKVOWrapperSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACKVOWrapperSpec.m new file mode 100644 index 0000000..dc207ef --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACKVOWrapperSpec.m
@@ -0,0 +1,656 @@ +// +// RACKVOWrapperSpec.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-08-07. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "NSObject+RACKVOWrapper.h" + +#import "EXTKeyPathCoding.h" +#import "NSObject+RACDeallocating.h" +#import "RACCompoundDisposable.h" +#import "RACDisposable.h" +#import "RACKVOTrampoline.h" +#import "RACTestObject.h" + +@interface RACTestOperation : NSOperation +@end + +// The name of the examples. +static NSString * const RACKVOWrapperExamples = @"RACKVOWrapperExamples"; + +// A block that returns an object to observe in the examples. +static NSString * const RACKVOWrapperExamplesTargetBlock = @"RACKVOWrapperExamplesTargetBlock"; + +// The key path to observe in the examples. +// +// The key path must have at least one weak property in it. +static NSString * const RACKVOWrapperExamplesKeyPath = @"RACKVOWrapperExamplesKeyPath"; + +// A block that changes the value of a weak property in the observed key path. +// The block is passed the object the example is observing and the new value the +// weak property should be changed to. +static NSString * const RACKVOWrapperExamplesChangeBlock = @"RACKVOWrapperExamplesChangeBlock"; + +// A block that returns a valid value for the weak property changed by +// RACKVOWrapperExamplesChangeBlock. The value must deallocate +// normally. +static NSString * const RACKVOWrapperExamplesValueBlock = @"RACKVOWrapperExamplesValueBlock"; + +// Whether RACKVOWrapperExamplesChangeBlock changes the value +// of the last key path component in the key path directly. +static NSString * const RACKVOWrapperExamplesChangesValueDirectly = @"RACKVOWrapperExamplesChangesValueDirectly"; + +// The name of the examples. +static NSString * const RACKVOWrapperCollectionExamples = @"RACKVOWrapperCollectionExamples"; + +// A block that returns an object to observe in the examples. +static NSString * const RACKVOWrapperCollectionExamplesTargetBlock = @"RACKVOWrapperCollectionExamplesTargetBlock"; + +// The key path to observe in the examples. +// +// Must identify a property of type NSOrderedSet. +static NSString * const RACKVOWrapperCollectionExamplesKeyPath = @"RACKVOWrapperCollectionExamplesKeyPath"; + +SharedExampleGroupsBegin(RACKVOWrapperExamples) + +sharedExamplesFor(RACKVOWrapperExamples, ^(NSDictionary *data) { + __block NSObject *target = nil; + __block NSString *keyPath = nil; + __block void (^changeBlock)(NSObject *, id) = nil; + __block id (^valueBlock)(void) = nil; + __block BOOL changesValueDirectly = NO; + + __block NSUInteger priorCallCount = 0; + __block NSUInteger posteriorCallCount = 0; + __block BOOL priorTriggeredByLastKeyPathComponent = NO; + __block BOOL posteriorTriggeredByLastKeyPathComponent = NO; + __block BOOL posteriorTriggeredByDeallocation = NO; + __block void (^callbackBlock)(id, NSDictionary *) = nil; + + beforeEach(^{ + NSObject * (^targetBlock)(void) = data[RACKVOWrapperExamplesTargetBlock]; + target = targetBlock(); + keyPath = data[RACKVOWrapperExamplesKeyPath]; + changeBlock = data[RACKVOWrapperExamplesChangeBlock]; + valueBlock = data[RACKVOWrapperExamplesValueBlock]; + changesValueDirectly = [data[RACKVOWrapperExamplesChangesValueDirectly] boolValue]; + + priorCallCount = 0; + posteriorCallCount = 0; + + callbackBlock = [^(id value, NSDictionary *change) { + if ([change[NSKeyValueChangeNotificationIsPriorKey] boolValue]) { + priorTriggeredByLastKeyPathComponent = [change[RACKeyValueChangeAffectedOnlyLastComponentKey] boolValue]; + ++priorCallCount; + return; + } + posteriorTriggeredByLastKeyPathComponent = [change[RACKeyValueChangeAffectedOnlyLastComponentKey] boolValue]; + posteriorTriggeredByDeallocation = [change[RACKeyValueChangeCausedByDeallocationKey] boolValue]; + ++posteriorCallCount; + } copy]; + }); + + afterEach(^{ + target = nil; + keyPath = nil; + changeBlock = nil; + valueBlock = nil; + changesValueDirectly = NO; + + callbackBlock = nil; + }); + + it(@"should not call the callback block on add if called without NSKeyValueObservingOptionInitial", ^{ + [target rac_observeKeyPath:keyPath options:NSKeyValueObservingOptionPrior observer:nil block:callbackBlock]; + expect(priorCallCount).to.equal(0); + expect(posteriorCallCount).to.equal(0); + }); + + it(@"should call the callback block on add if called with NSKeyValueObservingOptionInitial", ^{ + [target rac_observeKeyPath:keyPath options:NSKeyValueObservingOptionPrior | NSKeyValueObservingOptionInitial observer:nil block:callbackBlock]; + expect(priorCallCount).to.equal(0); + expect(posteriorCallCount).to.equal(1); + }); + + it(@"should call the callback block twice per change, once prior and once posterior", ^{ + [target rac_observeKeyPath:keyPath options:NSKeyValueObservingOptionPrior observer:nil block:callbackBlock]; + priorCallCount = 0; + posteriorCallCount = 0; + + id value1 = valueBlock(); + changeBlock(target, value1); + expect(priorCallCount).to.equal(1); + expect(posteriorCallCount).to.equal(1); + expect(priorTriggeredByLastKeyPathComponent).to.equal(changesValueDirectly); + expect(posteriorTriggeredByLastKeyPathComponent).to.equal(changesValueDirectly); + expect(posteriorTriggeredByDeallocation).to.beFalsy(); + + id value2 = valueBlock(); + changeBlock(target, value2); + expect(priorCallCount).to.equal(2); + expect(posteriorCallCount).to.equal(2); + expect(priorTriggeredByLastKeyPathComponent).to.equal(changesValueDirectly); + expect(posteriorTriggeredByLastKeyPathComponent).to.equal(changesValueDirectly); + expect(posteriorTriggeredByDeallocation).to.beFalsy(); + }); + + it(@"should call the callback block with NSKeyValueChangeNotificationIsPriorKey set before the value is changed, and not set after the value is changed", ^{ + __block BOOL priorCalled = NO; + __block BOOL posteriorCalled = NO; + __block id priorValue = nil; + __block id posteriorValue = nil; + + id value1 = valueBlock(); + changeBlock(target, value1); + id oldValue = [target valueForKeyPath:keyPath]; + + [target rac_observeKeyPath:keyPath options:NSKeyValueObservingOptionPrior observer:nil block:^(id value, NSDictionary *change) { + if ([change[NSKeyValueChangeNotificationIsPriorKey] boolValue]) { + priorCalled = YES; + priorValue = value; + expect(posteriorCalled).to.beFalsy(); + return; + } + posteriorCalled = YES; + posteriorValue = value; + expect(priorCalled).to.beTruthy(); + }]; + + id value2 = valueBlock(); + changeBlock(target, value2); + id newValue = [target valueForKeyPath:keyPath]; + expect(priorCalled).to.beTruthy(); + expect(priorValue).to.equal(oldValue); + expect(posteriorCalled).to.beTruthy(); + expect(posteriorValue).to.equal(newValue); + }); + + it(@"should not call the callback block after it's been disposed", ^{ + RACDisposable *disposable = [target rac_observeKeyPath:keyPath options:NSKeyValueObservingOptionPrior observer:nil block:callbackBlock]; + priorCallCount = 0; + posteriorCallCount = 0; + + [disposable dispose]; + expect(priorCallCount).to.equal(0); + expect(posteriorCallCount).to.equal(0); + + id value = valueBlock(); + changeBlock(target, value); + expect(priorCallCount).to.equal(0); + expect(posteriorCallCount).to.equal(0); + }); + + it(@"should call the callback block only once with NSKeyValueChangeNotificationIsPriorKey not set when the value is deallocated", ^{ + __block BOOL valueDidDealloc = NO; + + [target rac_observeKeyPath:keyPath options:NSKeyValueObservingOptionPrior observer:nil block:callbackBlock]; + + @autoreleasepool { + NSObject *value __attribute__((objc_precise_lifetime)) = valueBlock(); + [value.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + valueDidDealloc = YES; + }]]; + + changeBlock(target, value); + priorCallCount = 0; + posteriorCallCount = 0; + } + + expect(valueDidDealloc).to.beTruthy(); + expect(priorCallCount).to.equal(0); + expect(posteriorCallCount).to.equal(1); + expect(posteriorTriggeredByDeallocation).to.beTruthy(); + }); +}); + +sharedExamplesFor(RACKVOWrapperCollectionExamples, ^(NSDictionary *data) { + __block NSObject *target = nil; + __block NSString *keyPath = nil; + __block NSMutableOrderedSet *mutableKeyPathProxy = nil; + __block void (^callbackBlock)(id, NSDictionary *) = nil; + + __block id priorValue = nil; + __block id posteriorValue = nil; + __block NSDictionary *priorChange = nil; + __block NSDictionary *posteriorChange = nil; + + beforeEach(^{ + NSObject * (^targetBlock)(void) = data[RACKVOWrapperCollectionExamplesTargetBlock]; + target = targetBlock(); + keyPath = data[RACKVOWrapperCollectionExamplesKeyPath]; + + callbackBlock = [^(id value, NSDictionary *change) { + if ([change[NSKeyValueChangeNotificationIsPriorKey] boolValue]) { + priorValue = value; + priorChange = change; + return; + } + posteriorValue = value; + posteriorChange = change; + } copy]; + + [target setValue:[NSOrderedSet orderedSetWithObject:@0] forKeyPath:keyPath]; + [target rac_observeKeyPath:keyPath options:NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld | NSKeyValueObservingOptionPrior observer:nil block:callbackBlock]; + mutableKeyPathProxy = [target mutableOrderedSetValueForKeyPath:keyPath]; + }); + + afterEach(^{ + target = nil; + keyPath = nil; + callbackBlock = nil; + + priorValue = nil; + priorChange = nil; + posteriorValue = nil; + posteriorChange = nil; + }); + + it(@"should support inserting elements into ordered collections", ^{ + [mutableKeyPathProxy insertObject:@1 atIndex:0]; + + expect(priorValue).to.equal([NSOrderedSet orderedSetWithArray:@[ @0 ]]); + expect(posteriorValue).to.equal([NSOrderedSet orderedSetWithArray:(@[ @1, @0 ])]); + expect(priorChange[NSKeyValueChangeKindKey]).to.equal(NSKeyValueChangeInsertion); + expect(posteriorChange[NSKeyValueChangeKindKey]).to.equal(NSKeyValueChangeInsertion); + expect(priorChange[NSKeyValueChangeOldKey]).to.beNil(); + expect(posteriorChange[NSKeyValueChangeNewKey]).to.equal(@[ @1 ]); + expect(priorChange[NSKeyValueChangeIndexesKey]).to.equal([NSIndexSet indexSetWithIndex:0]); + expect(posteriorChange[NSKeyValueChangeIndexesKey]).to.equal([NSIndexSet indexSetWithIndex:0]); + }); + + it(@"should support removing elements from ordered collections", ^{ + [mutableKeyPathProxy removeObjectAtIndex:0]; + + expect(priorValue).to.equal([NSOrderedSet orderedSetWithArray:@[ @0 ]]); + expect(posteriorValue).to.equal([NSOrderedSet orderedSetWithArray:@[]]); + expect(priorChange[NSKeyValueChangeKindKey]).to.equal(NSKeyValueChangeRemoval); + expect(posteriorChange[NSKeyValueChangeKindKey]).to.equal(NSKeyValueChangeRemoval); + expect(priorChange[NSKeyValueChangeOldKey]).to.equal(@[ @0 ]); + expect(posteriorChange[NSKeyValueChangeNewKey]).to.beNil(); + expect(priorChange[NSKeyValueChangeIndexesKey]).to.equal([NSIndexSet indexSetWithIndex:0]); + expect(posteriorChange[NSKeyValueChangeIndexesKey]).to.equal([NSIndexSet indexSetWithIndex:0]); + }); + + it(@"should support replacing elements in ordered collections", ^{ + [mutableKeyPathProxy replaceObjectAtIndex:0 withObject:@1]; + + expect(priorValue).to.equal([NSOrderedSet orderedSetWithArray:@[ @0 ]]); + expect(posteriorValue).to.equal([NSOrderedSet orderedSetWithArray:@[ @1 ]]); + expect(priorChange[NSKeyValueChangeKindKey]).to.equal(NSKeyValueChangeReplacement); + expect(posteriorChange[NSKeyValueChangeKindKey]).to.equal(NSKeyValueChangeReplacement); + expect(priorChange[NSKeyValueChangeOldKey]).to.equal(@[ @0 ]); + expect(posteriorChange[NSKeyValueChangeNewKey]).to.equal(@[ @1 ]); + expect(priorChange[NSKeyValueChangeIndexesKey]).to.equal([NSIndexSet indexSetWithIndex:0]); + expect(posteriorChange[NSKeyValueChangeIndexesKey]).to.equal([NSIndexSet indexSetWithIndex:0]); + }); + + it(@"should support adding elements to unordered collections", ^{ + [mutableKeyPathProxy unionOrderedSet:[NSOrderedSet orderedSetWithObject:@1]]; + + expect(priorValue).to.equal([NSOrderedSet orderedSetWithArray:@[ @0 ]]); + expect(posteriorValue).to.equal([NSOrderedSet orderedSetWithArray:(@[ @0, @1 ])]); + expect(priorChange[NSKeyValueChangeKindKey]).to.equal(NSKeyValueChangeInsertion); + expect(posteriorChange[NSKeyValueChangeKindKey]).to.equal(NSKeyValueChangeInsertion); + expect(priorChange[NSKeyValueChangeOldKey]).to.beNil(); + expect(posteriorChange[NSKeyValueChangeNewKey]).to.equal(@[ @1 ]); + }); + + it(@"should support removing elements from unordered collections", ^{ + [mutableKeyPathProxy minusOrderedSet:[NSOrderedSet orderedSetWithObject:@0]]; + + expect(priorValue).to.equal([NSOrderedSet orderedSetWithArray:@[ @0 ]]); + expect(posteriorValue).to.equal([NSOrderedSet orderedSetWithArray:@[]]); + expect(priorChange[NSKeyValueChangeKindKey]).to.equal(NSKeyValueChangeRemoval); + expect(posteriorChange[NSKeyValueChangeKindKey]).to.equal(NSKeyValueChangeRemoval); + expect(priorChange[NSKeyValueChangeOldKey]).to.equal(@[ @0 ]); + expect(posteriorChange[NSKeyValueChangeNewKey]).to.beNil(); + }); +}); + +SharedExampleGroupsEnd + +SpecBegin(RACKVOWrapper) + +describe(@"-rac_observeKeyPath:options:observer:block:", ^{ + describe(@"on simple keys", ^{ + NSObject * (^targetBlock)(void) = ^{ + return [[RACTestObject alloc] init]; + }; + + void (^changeBlock)(RACTestObject *, id) = ^(RACTestObject *target, id value) { + target.weakTestObjectValue = value; + }; + + id (^valueBlock)(void) = ^{ + return [[RACTestObject alloc] init]; + }; + + itShouldBehaveLike(RACKVOWrapperExamples, @{ + RACKVOWrapperExamplesTargetBlock: targetBlock, + RACKVOWrapperExamplesKeyPath: @keypath(RACTestObject.new, weakTestObjectValue), + RACKVOWrapperExamplesChangeBlock: changeBlock, + RACKVOWrapperExamplesValueBlock: valueBlock, + RACKVOWrapperExamplesChangesValueDirectly: @YES + }); + + itShouldBehaveLike(RACKVOWrapperCollectionExamples, @{ + RACKVOWrapperCollectionExamplesTargetBlock: targetBlock, + RACKVOWrapperCollectionExamplesKeyPath: @keypath(RACTestObject.new, orderedSetValue) + }); + }); + + describe(@"on composite key paths'", ^{ + describe(@"last key path components", ^{ + NSObject *(^targetBlock)(void) = ^{ + RACTestObject *object = [[RACTestObject alloc] init]; + object.strongTestObjectValue = [[RACTestObject alloc] init]; + return object; + }; + + void (^changeBlock)(RACTestObject *, id) = ^(RACTestObject *target, id value) { + target.strongTestObjectValue.weakTestObjectValue = value; + }; + + id (^valueBlock)(void) = ^{ + return [[RACTestObject alloc] init]; + }; + + itShouldBehaveLike(RACKVOWrapperExamples, @{ + RACKVOWrapperExamplesTargetBlock: targetBlock, + RACKVOWrapperExamplesKeyPath: @keypath(RACTestObject.new, strongTestObjectValue.weakTestObjectValue), + RACKVOWrapperExamplesChangeBlock: changeBlock, + RACKVOWrapperExamplesValueBlock: valueBlock, + RACKVOWrapperExamplesChangesValueDirectly: @YES + }); + + itShouldBehaveLike(RACKVOWrapperCollectionExamples, @{ + RACKVOWrapperCollectionExamplesTargetBlock: targetBlock, + RACKVOWrapperCollectionExamplesKeyPath: @keypath(RACTestObject.new, strongTestObjectValue.orderedSetValue) + }); + }); + + describe(@"intermediate key path components", ^{ + NSObject *(^targetBlock)(void) = ^{ + return [[RACTestObject alloc] init]; + }; + + void (^changeBlock)(RACTestObject *, id) = ^(RACTestObject *target, id value) { + target.weakTestObjectValue = value; + }; + + id (^valueBlock)(void) = ^{ + RACTestObject *object = [[RACTestObject alloc] init]; + object.strongTestObjectValue = [[RACTestObject alloc] init]; + return object; + }; + + itShouldBehaveLike(RACKVOWrapperExamples, @{ + RACKVOWrapperExamplesTargetBlock: targetBlock, + RACKVOWrapperExamplesKeyPath: @keypath([[RACTestObject alloc] init], weakTestObjectValue.strongTestObjectValue), + RACKVOWrapperExamplesChangeBlock: changeBlock, + RACKVOWrapperExamplesValueBlock: valueBlock, + RACKVOWrapperExamplesChangesValueDirectly: @NO + }); + }); + + it(@"should not notice deallocation of the object returned by a dynamic final property", ^{ + RACTestObject *object = [[RACTestObject alloc] init]; + + __block id lastValue = nil; + @autoreleasepool { + [object rac_observeKeyPath:@keypath(object.dynamicObjectProperty) options:NSKeyValueObservingOptionInitial observer:nil block:^(id value, NSDictionary *change) { + lastValue = value; + }]; + + expect(lastValue).to.beKindOf(RACTestObject.class); + } + + expect(lastValue).to.beKindOf(RACTestObject.class); + }); + + it(@"should not notice deallocation of the object returned by a dynamic intermediate property", ^{ + RACTestObject *object = [[RACTestObject alloc] init]; + + __block id lastValue = nil; + @autoreleasepool { + [object rac_observeKeyPath:@keypath(object.dynamicObjectProperty.integerValue) options:NSKeyValueObservingOptionInitial observer:nil block:^(id value, NSDictionary *change) { + lastValue = value; + }]; + + expect(lastValue).to.equal(@42); + } + + expect(lastValue).to.equal(@42); + }); + + it(@"should not notice deallocation of the object returned by a dynamic method", ^{ + RACTestObject *object = [[RACTestObject alloc] init]; + + __block id lastValue = nil; + @autoreleasepool { + [object rac_observeKeyPath:@keypath(object.dynamicObjectMethod) options:NSKeyValueObservingOptionInitial observer:nil block:^(id value, NSDictionary *change) { + lastValue = value; + }]; + + expect(lastValue).to.beKindOf(RACTestObject.class); + } + + expect(lastValue).to.beKindOf(RACTestObject.class); + }); + }); + + it(@"should not call the callback block when the value is the observer", ^{ + __block BOOL observerDisposed = NO; + __block BOOL observerDeallocationTriggeredChange = NO; + __block BOOL targetDisposed = NO; + __block BOOL targetDeallocationTriggeredChange = NO; + + @autoreleasepool { + RACTestObject *observer __attribute__((objc_precise_lifetime)) = [RACTestObject new]; + [observer.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + observerDisposed = YES; + }]]; + + RACTestObject *target __attribute__((objc_precise_lifetime)) = [RACTestObject new]; + [target.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + targetDisposed = YES; + }]]; + + observer.weakTestObjectValue = observer; + target.weakTestObjectValue = target; + + // These observations can only result in dealloc triggered callbacks. + [observer rac_observeKeyPath:@keypath(target.weakTestObjectValue) options:0 observer:observer block:^(id _, NSDictionary *__) { + observerDeallocationTriggeredChange = YES; + }]; + + [target rac_observeKeyPath:@keypath(target.weakTestObjectValue) options:0 observer:observer block:^(id _, NSDictionary *__) { + targetDeallocationTriggeredChange = YES; + }]; + } + + expect(observerDisposed).to.beTruthy(); + expect(observerDeallocationTriggeredChange).to.beFalsy(); + + expect(targetDisposed).to.beTruthy(); + expect(targetDeallocationTriggeredChange).to.beTruthy(); + }); + + it(@"should call the callback block for deallocation of the initial value of a single-key key path", ^{ + RACTestObject *target = [RACTestObject new]; + __block BOOL objectDisposed = NO; + __block BOOL objectDeallocationTriggeredChange = NO; + + @autoreleasepool { + RACTestObject *object __attribute__((objc_precise_lifetime)) = [RACTestObject new]; + target.weakTestObjectValue = object; + [object.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + objectDisposed = YES; + }]]; + + [target rac_observeKeyPath:@keypath(target.weakTestObjectValue) options:0 observer:target block:^(id _, NSDictionary *__) { + objectDeallocationTriggeredChange = YES; + }]; + } + + expect(objectDisposed).to.beTruthy(); + expect(objectDeallocationTriggeredChange).to.beTruthy(); + }); + + it(@"should call the callback block for deallocation of an object conforming to protocol property", ^{ + RACTestObject *target = [RACTestObject new]; + __block BOOL objectDisposed = NO; + __block BOOL objectDeallocationTriggeredChange = NO; + + @autoreleasepool { + RACTestObject *object __attribute__((objc_precise_lifetime)) = [RACTestObject new]; + target.weakObjectWithProtocol = object; + [object.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + objectDisposed = YES; + }]]; + + [target rac_observeKeyPath:@keypath(target.weakObjectWithProtocol) options:0 observer:target block:^(id _, NSDictionary *__) { + objectDeallocationTriggeredChange = YES; + }]; + } + + expect(objectDisposed).to.beTruthy(); + expect(objectDeallocationTriggeredChange).to.beTruthy(); + }); +}); + +describe(@"rac_addObserver:forKeyPath:options:block:", ^{ + it(@"should add and remove an observer", ^{ + NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{}]; + expect(operation).notTo.beNil(); + + __block BOOL notified = NO; + RACDisposable *disposable = [operation rac_observeKeyPath:@"isFinished" options:NSKeyValueObservingOptionNew observer:self block:^(id value, NSDictionary *change) { + expect([change objectForKey:NSKeyValueChangeNewKey]).to.equal(@YES); + + expect(notified).to.beFalsy(); + notified = YES; + }]; + + expect(disposable).notTo.beNil(); + + [operation start]; + [operation waitUntilFinished]; + + expect(notified).will.beTruthy(); + }); + + it(@"should accept a nil observer", ^{ + NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{}]; + RACDisposable *disposable = [operation rac_observeKeyPath:@"isFinished" options:NSKeyValueObservingOptionNew observer:nil block:^(id value, NSDictionary *change) {}]; + + expect(disposable).notTo.beNil(); + }); + + it(@"automatically stops KVO on subclasses when the target deallocates", ^{ + void (^testKVOOnSubclass)(Class targetClass, id observer) = ^(Class targetClass, id observer) { + __weak id weakTarget = nil; + __weak id identifier = nil; + + @autoreleasepool { + // Create an observable target that we control the memory management of. + CFTypeRef target = CFBridgingRetain([[targetClass alloc] init]); + expect(target).notTo.beNil(); + + weakTarget = (__bridge id)target; + expect(weakTarget).notTo.beNil(); + + identifier = [(__bridge id)target rac_observeKeyPath:@"isFinished" options:0 observer:observer block:^(id value, NSDictionary *change) {}]; + expect(identifier).notTo.beNil(); + + CFRelease(target); + } + + expect(weakTarget).to.beNil(); + expect(identifier).to.beNil(); + }; + + it (@"stops KVO on NSObject subclasses", ^{ + testKVOOnSubclass(NSOperation.class, self); + }); + + it(@"stops KVO on subclasses of already-swizzled classes", ^{ + testKVOOnSubclass(RACTestOperation.class, self); + }); + + it (@"stops KVO on NSObject subclasses even with a nil observer", ^{ + testKVOOnSubclass(NSOperation.class, nil); + }); + + it(@"stops KVO on subclasses of already-swizzled classes even with a nil observer", ^{ + testKVOOnSubclass(RACTestOperation.class, nil); + }); + }); + + it(@"should automatically stop KVO when the observer deallocates", ^{ + __weak id weakObserver = nil; + __weak id identifier = nil; + + NSOperation *operation = [[NSOperation alloc] init]; + + @autoreleasepool { + // Create an observer that we control the memory management of. + CFTypeRef observer = CFBridgingRetain([[NSOperation alloc] init]); + expect(observer).notTo.beNil(); + + weakObserver = (__bridge id)observer; + expect(weakObserver).notTo.beNil(); + + identifier = [operation rac_observeKeyPath:@"isFinished" options:0 observer:(__bridge id)observer block:^(id value, NSDictionary *change) {}]; + expect(identifier).notTo.beNil(); + + CFRelease(observer); + } + + expect(weakObserver).to.beNil(); + }); + + it(@"should stop KVO when the observer is disposed", ^{ + NSOperationQueue *queue = [[NSOperationQueue alloc] init]; + __block NSString *name = nil; + + RACDisposable *disposable = [queue rac_observeKeyPath:@"name" options:0 observer:self block:^(id value, NSDictionary *change) { + name = queue.name; + }]; + + queue.name = @"1"; + expect(name).to.equal(@"1"); + [disposable dispose]; + queue.name = @"2"; + expect(name).to.equal(@"1"); + }); + + it(@"should distinguish between observers being disposed", ^{ + NSOperationQueue *queue = [[NSOperationQueue alloc] init]; + __block NSString *name1 = nil; + __block NSString *name2 = nil; + + RACDisposable *disposable = [queue rac_observeKeyPath:@"name" options:0 observer:self block:^(id value, NSDictionary *change) { + name1 = queue.name; + }]; + [queue rac_observeKeyPath:@"name" options:0 observer:self block:^(id value, NSDictionary *change) { + name2 = queue.name; + }]; + + queue.name = @"1"; + expect(name1).to.equal(@"1"); + expect(name2).to.equal(@"1"); + [disposable dispose]; + queue.name = @"2"; + expect(name1).to.equal(@"1"); + expect(name2).to.equal(@"2"); + }); +}); + +SpecEnd + +@implementation RACTestOperation +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACMulticastConnectionSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACMulticastConnectionSpec.m new file mode 100644 index 0000000..b043beb --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACMulticastConnectionSpec.m
@@ -0,0 +1,142 @@ +// +// RACMulticastConnectionSpec.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 10/8/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACMulticastConnection.h" +#import "RACDisposable.h" +#import "RACSignal+Operations.h" +#import "RACSubscriber.h" +#import "RACReplaySubject.h" +#import "RACScheduler.h" +#import <libkern/OSAtomic.h> + +SpecBegin(RACMulticastConnection) + +__block NSUInteger subscriptionCount = 0; +__block RACMulticastConnection *connection; +__block BOOL disposed = NO; + +beforeEach(^{ + subscriptionCount = 0; + disposed = NO; + connection = [[RACSignal createSignal:^(id<RACSubscriber> subscriber) { + subscriptionCount++; + return [RACDisposable disposableWithBlock:^{ + disposed = YES; + }]; + }] publish]; + expect(subscriptionCount).to.equal(0); +}); + +describe(@"-connect", ^{ + it(@"should subscribe to the underlying signal", ^{ + [connection connect]; + expect(subscriptionCount).to.equal(1); + }); + + it(@"should return the same disposable for each invocation", ^{ + RACDisposable *d1 = [connection connect]; + RACDisposable *d2 = [connection connect]; + expect(d1).to.equal(d2); + expect(subscriptionCount).to.equal(1); + }); + + it(@"shouldn't reconnect after disposal", ^{ + RACDisposable *disposable1 = [connection connect]; + expect(subscriptionCount).to.equal(1); + + [disposable1 dispose]; + + RACDisposable *disposable2 = [connection connect]; + expect(subscriptionCount).to.equal(1); + expect(disposable1).to.equal(disposable2); + }); + + it(@"shouldn't race when connecting", ^{ + dispatch_semaphore_t semaphore = dispatch_semaphore_create(0); + + RACMulticastConnection *connection = [[RACSignal + defer:^ id { + dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER); + return nil; + }] + publish]; + + __block RACDisposable *disposable; + [RACScheduler.scheduler schedule:^{ + disposable = [connection connect]; + dispatch_semaphore_signal(semaphore); + }]; + + expect([connection connect]).notTo.beNil(); + dispatch_semaphore_signal(semaphore); + + expect(disposable).willNot.beNil(); + + dispatch_release(semaphore); + }); +}); + +describe(@"-autoconnect", ^{ + __block RACSignal *autoconnectedSignal; + + beforeEach(^{ + autoconnectedSignal = [connection autoconnect]; + }); + + it(@"should subscribe to the multicasted signal on the first subscription", ^{ + expect(subscriptionCount).to.equal(0); + + [autoconnectedSignal subscribeNext:^(id x) {}]; + expect(subscriptionCount).to.equal(1); + + [autoconnectedSignal subscribeNext:^(id x) {}]; + expect(subscriptionCount).to.equal(1); + }); + + it(@"should dispose of the multicasted subscription when the signal has no subscribers", ^{ + RACDisposable *disposable = [autoconnectedSignal subscribeNext:^(id x) {}]; + + expect(disposed).to.beFalsy(); + [disposable dispose]; + expect(disposed).to.beTruthy(); + }); + + it(@"shouldn't reconnect after disposal", ^{ + RACDisposable *disposable = [autoconnectedSignal subscribeNext:^(id x) {}]; + expect(subscriptionCount).to.equal(1); + [disposable dispose]; + + disposable = [autoconnectedSignal subscribeNext:^(id x) {}]; + expect(subscriptionCount).to.equal(1); + [disposable dispose]; + }); + + it(@"should replay values after disposal when multicasted to a replay subject", ^{ + RACSubject *subject = [RACSubject subject]; + RACSignal *signal = [[subject multicast:[RACReplaySubject subject]] autoconnect]; + + NSMutableArray *results1 = [NSMutableArray array]; + RACDisposable *disposable = [signal subscribeNext:^(id x) { + [results1 addObject:x]; + }]; + + [subject sendNext:@1]; + [subject sendNext:@2]; + + expect(results1).to.equal((@[ @1, @2 ])); + [disposable dispose]; + + NSMutableArray *results2 = [NSMutableArray array]; + [signal subscribeNext:^(id x) { + [results2 addObject:x]; + }]; + expect(results2).will.equal((@[ @1, @2 ])); + }); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACPropertySignalExamples.h b/ReactiveCocoaFramework/ReactiveCocoaTests/RACPropertySignalExamples.h new file mode 100644 index 0000000..59a2b43 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACPropertySignalExamples.h
@@ -0,0 +1,18 @@ +// +// RACPropertySignalExamples.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 9/28/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +// The name of the shared examples for a signal-driven property. +extern NSString * const RACPropertySignalExamples; + +// The block should have the signature: +// +// void (^)(RACTestObject *testObject, NSString *keyPath, id nilValue, RACSignal *signal) +// +// and should tie the value of the key path on testObject to signal. `nilValue` +// will be used when the signal sends a `nil` value. +extern NSString * const RACPropertySignalExamplesSetupBlock;
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACPropertySignalExamples.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACPropertySignalExamples.m new file mode 100644 index 0000000..627d634 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACPropertySignalExamples.m
@@ -0,0 +1,180 @@ +// +// RACPropertySignalExamples.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 9/28/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACTestObject.h" + +#import "EXTKeyPathCoding.h" +#import "NSObject+RACDeallocating.h" +#import "NSObject+RACPropertySubscribing.h" +#import "NSObject+RACSelectorSignal.h" +#import "RACCompoundDisposable.h" +#import "RACDisposable.h" +#import "RACSubject.h" + +NSString * const RACPropertySignalExamples = @"RACPropertySignalExamples"; +NSString * const RACPropertySignalExamplesSetupBlock = @"RACPropertySignalExamplesSetupBlock"; + +SharedExampleGroupsBegin(RACPropertySignalExamples) + +sharedExamplesFor(RACPropertySignalExamples, ^(NSDictionary *data) { + __block RACTestObject *testObject = nil; + __block void (^setupBlock)(RACTestObject *, NSString *keyPath, id nilValue, RACSignal *); + + beforeEach(^{ + setupBlock = data[RACPropertySignalExamplesSetupBlock]; + testObject = [[RACTestObject alloc] init]; + }); + + it(@"should set the value of the property with the latest value from the signal", ^{ + RACSubject *subject = [RACSubject subject]; + setupBlock(testObject, @keypath(testObject.objectValue), nil, subject); + expect(testObject.objectValue).to.beNil(); + + [subject sendNext:@1]; + expect(testObject.objectValue).to.equal(@1); + + [subject sendNext:@2]; + expect(testObject.objectValue).to.equal(@2); + + [subject sendNext:nil]; + expect(testObject.objectValue).to.beNil(); + }); + + it(@"should set the given nilValue for an object property", ^{ + RACSubject *subject = [RACSubject subject]; + setupBlock(testObject, @keypath(testObject.objectValue), @"foo", subject); + expect(testObject.objectValue).to.beNil(); + + [subject sendNext:@1]; + expect(testObject.objectValue).to.equal(@1); + + [subject sendNext:@2]; + expect(testObject.objectValue).to.equal(@2); + + [subject sendNext:nil]; + expect(testObject.objectValue).to.equal(@"foo"); + }); + + it(@"should leave the value of the property alone after the signal completes", ^{ + RACSubject *subject = [RACSubject subject]; + setupBlock(testObject, @keypath(testObject.objectValue), nil, subject); + expect(testObject.objectValue).to.beNil(); + + [subject sendNext:@1]; + expect(testObject.objectValue).to.equal(@1); + + [subject sendCompleted]; + expect(testObject.objectValue).to.equal(@1); + }); + + it(@"should set the value of a non-object property with the latest value from the signal", ^{ + RACSubject *subject = [RACSubject subject]; + setupBlock(testObject, @keypath(testObject.integerValue), nil, subject); + expect(testObject.integerValue).to.equal(0); + + [subject sendNext:@1]; + expect(testObject.integerValue).to.equal(1); + + [subject sendNext:@2]; + expect(testObject.integerValue).to.equal(2); + + [subject sendNext:@0]; + expect(testObject.integerValue).to.equal(0); + }); + + it(@"should set the given nilValue for a non-object property", ^{ + RACSubject *subject = [RACSubject subject]; + setupBlock(testObject, @keypath(testObject.integerValue), @42, subject); + expect(testObject.integerValue).to.equal(0); + + [subject sendNext:@1]; + expect(testObject.integerValue).to.equal(@1); + + [subject sendNext:@2]; + expect(testObject.integerValue).to.equal(@2); + + [subject sendNext:nil]; + expect(testObject.integerValue).to.equal(@42); + }); + + it(@"should not invoke -setNilValueForKey: with a nilValue", ^{ + RACSubject *subject = [RACSubject subject]; + setupBlock(testObject, @keypath(testObject.integerValue), @42, subject); + + __block BOOL setNilValueForKeyInvoked = NO; + [[testObject rac_signalForSelector:@selector(setNilValueForKey:)] subscribeNext:^(NSString *key) { + setNilValueForKeyInvoked = YES; + }]; + + [subject sendNext:nil]; + expect(testObject.integerValue).to.equal(@42); + expect(setNilValueForKeyInvoked).to.beFalsy(); + }); + + it(@"should invoke -setNilValueForKey: without a nilValue", ^{ + RACSubject *subject = [RACSubject subject]; + setupBlock(testObject, @keypath(testObject.integerValue), nil, subject); + + [subject sendNext:@1]; + expect(testObject.integerValue).to.equal(@1); + + testObject.catchSetNilValueForKey = YES; + + __block BOOL setNilValueForKeyInvoked = NO; + [[testObject rac_signalForSelector:@selector(setNilValueForKey:)] subscribeNext:^(NSString *key) { + setNilValueForKeyInvoked = YES; + }]; + + [subject sendNext:nil]; + expect(testObject.integerValue).to.equal(@1); + expect(setNilValueForKeyInvoked).to.beTruthy(); + }); + + it(@"should retain intermediate signals when binding", ^{ + RACSubject *subject = [RACSubject subject]; + expect(subject).notTo.beNil(); + + __block BOOL deallocd = NO; + + @autoreleasepool { + @autoreleasepool { + RACSignal *intermediateSignal = [subject map:^(NSNumber *num) { + return @(num.integerValue + 1); + }]; + + expect(intermediateSignal).notTo.beNil(); + + [intermediateSignal.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + deallocd = YES; + }]]; + + setupBlock(testObject, @keypath(testObject.integerValue), nil, intermediateSignal); + } + + // Spin the run loop to account for RAC magic that retains the + // signal for a single iteration. + [NSRunLoop.mainRunLoop runMode:NSDefaultRunLoopMode beforeDate:[NSDate date]]; + } + + expect(deallocd).to.beFalsy(); + + [subject sendNext:@5]; + expect(testObject.integerValue).to.equal(6); + + [subject sendNext:@6]; + expect(testObject.integerValue).to.equal(7); + + expect(deallocd).to.beFalsy(); + [subject sendCompleted]; + + // Can't test deallocd again, because it's legal for the chain to be + // retained until the object or the original signal is destroyed. + }); +}); + +SharedExampleGroupsEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACSchedulerSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSchedulerSpec.m new file mode 100644 index 0000000..738eff8 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSchedulerSpec.m
@@ -0,0 +1,424 @@ +// +// RACSchedulerSpec.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 11/29/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACScheduler.h" +#import "RACScheduler+Private.h" +#import "RACQueueScheduler+Subclass.h" +#import "RACDisposable.h" +#import "EXTScope.h" +#import "RACTestExampleScheduler.h" +#import <libkern/OSAtomic.h> + +// This shouldn't be used directly. Use the `expectCurrentSchedulers` block +// below instead. +static void expectCurrentSchedulersInner(NSArray *schedulers, NSMutableArray *currentSchedulerArray) { + if (schedulers.count > 0) { + RACScheduler *topScheduler = schedulers[0]; + [topScheduler schedule:^{ + RACScheduler *currentScheduler = RACScheduler.currentScheduler; + if (currentScheduler != nil) [currentSchedulerArray addObject:currentScheduler]; + expectCurrentSchedulersInner([schedulers subarrayWithRange:NSMakeRange(1, schedulers.count - 1)], currentSchedulerArray); + }]; + } +} + +SpecBegin(RACScheduler) + +it(@"should know its current scheduler", ^{ + // Recursively schedules a block in each of the given schedulers and records + // the +currentScheduler at each step. It then expects the array of + // +currentSchedulers and the expected array to be equal. + // + // schedulers - The array of schedulers to recursively schedule. + // expectedCurrentSchedulers - The array of +currentSchedulers to expect. + void (^expectCurrentSchedulers)(NSArray *, NSArray *) = ^(NSArray *schedulers, NSArray *expectedCurrentSchedulers) { + NSMutableArray *currentSchedulerArray = [NSMutableArray array]; + expectCurrentSchedulersInner(schedulers, currentSchedulerArray); + expect(currentSchedulerArray).will.equal(expectedCurrentSchedulers); + }; + + RACScheduler *backgroundScheduler = [RACScheduler scheduler]; + + expectCurrentSchedulers(@[ backgroundScheduler, RACScheduler.immediateScheduler ], @[ backgroundScheduler, backgroundScheduler ]); + expectCurrentSchedulers(@[ backgroundScheduler, RACScheduler.subscriptionScheduler ], @[ backgroundScheduler, backgroundScheduler ]); + + NSArray *mainThreadJumper = @[ RACScheduler.mainThreadScheduler, backgroundScheduler, RACScheduler.mainThreadScheduler ]; + expectCurrentSchedulers(mainThreadJumper, mainThreadJumper); + + NSArray *backgroundJumper = @[ backgroundScheduler, RACScheduler.mainThreadScheduler, backgroundScheduler ]; + expectCurrentSchedulers(backgroundJumper, backgroundJumper); +}); + +describe(@"+mainThreadScheduler", ^{ + it(@"should cancel scheduled blocks when disposed", ^{ + __block BOOL firstBlockRan = NO; + __block BOOL secondBlockRan = NO; + + RACDisposable *disposable = [RACScheduler.mainThreadScheduler schedule:^{ + firstBlockRan = YES; + }]; + + expect(disposable).notTo.beNil(); + + [RACScheduler.mainThreadScheduler schedule:^{ + secondBlockRan = YES; + }]; + + [disposable dispose]; + + expect(secondBlockRan).to.beFalsy(); + expect(secondBlockRan).will.beTruthy(); + expect(firstBlockRan).to.beFalsy(); + }); + + it(@"should schedule future blocks", ^{ + __block BOOL done = NO; + + [RACScheduler.mainThreadScheduler after:[NSDate date] schedule:^{ + done = YES; + }]; + + expect(done).to.beFalsy(); + expect(done).will.beTruthy(); + }); + + it(@"should cancel future blocks when disposed", ^{ + __block BOOL firstBlockRan = NO; + __block BOOL secondBlockRan = NO; + + RACDisposable *disposable = [RACScheduler.mainThreadScheduler after:[NSDate date] schedule:^{ + firstBlockRan = YES; + }]; + + expect(disposable).notTo.beNil(); + + [RACScheduler.mainThreadScheduler after:[NSDate date] schedule:^{ + secondBlockRan = YES; + }]; + + [disposable dispose]; + + expect(secondBlockRan).to.beFalsy(); + expect(secondBlockRan).will.beTruthy(); + expect(firstBlockRan).to.beFalsy(); + }); + + it(@"should schedule recurring blocks", ^{ + __block NSUInteger count = 0; + + RACDisposable *disposable = [RACScheduler.mainThreadScheduler after:[NSDate date] repeatingEvery:0.05 withLeeway:0 schedule:^{ + count++; + }]; + + expect(count).to.equal(0); + expect(count).will.equal(1); + expect(count).will.equal(2); + expect(count).will.equal(3); + + [disposable dispose]; + [NSRunLoop.mainRunLoop runUntilDate:[NSDate dateWithTimeIntervalSinceNow:0.1]]; + + expect(count).to.equal(3); + }); +}); + +describe(@"+scheduler", ^{ + __block RACScheduler *scheduler; + __block NSDate * (^futureDate)(void); + + beforeEach(^{ + scheduler = [RACScheduler scheduler]; + + futureDate = ^{ + return [NSDate dateWithTimeIntervalSinceNow:0.01]; + }; + }); + + it(@"should cancel scheduled blocks when disposed", ^{ + __block BOOL firstBlockRan = NO; + __block BOOL secondBlockRan = NO; + + // Start off on the scheduler so the enqueued blocks won't run until we + // return. + [scheduler schedule:^{ + RACDisposable *disposable = [scheduler schedule:^{ + firstBlockRan = YES; + }]; + + expect(disposable).notTo.beNil(); + + [scheduler schedule:^{ + secondBlockRan = YES; + }]; + + [disposable dispose]; + }]; + + expect(secondBlockRan).will.beTruthy(); + expect(firstBlockRan).to.beFalsy(); + }); + + it(@"should schedule future blocks", ^{ + __block BOOL done = NO; + + [scheduler after:futureDate() schedule:^{ + done = YES; + }]; + + expect(done).to.beFalsy(); + expect(done).will.beTruthy(); + }); + + it(@"should cancel future blocks when disposed", ^{ + __block BOOL firstBlockRan = NO; + __block BOOL secondBlockRan = NO; + + NSDate *date = futureDate(); + RACDisposable *disposable = [scheduler after:date schedule:^{ + firstBlockRan = YES; + }]; + + expect(disposable).notTo.beNil(); + [disposable dispose]; + + [scheduler after:date schedule:^{ + secondBlockRan = YES; + }]; + + expect(secondBlockRan).to.beFalsy(); + expect(secondBlockRan).will.beTruthy(); + expect(firstBlockRan).to.beFalsy(); + }); + + it(@"should schedule recurring blocks", ^{ + __block NSUInteger count = 0; + + RACDisposable *disposable = [scheduler after:[NSDate date] repeatingEvery:0.05 withLeeway:0 schedule:^{ + count++; + }]; + + expect(count).to.equal(0); + expect(count).will.equal(1); + expect(count).will.equal(2); + expect(count).will.equal(3); + + [disposable dispose]; + [NSThread sleepForTimeInterval:0.1]; + + expect(count).to.equal(3); + }); +}); + +describe(@"+subscriptionScheduler", ^{ + describe(@"setting +currentScheduler", ^{ + __block RACScheduler *currentScheduler; + + beforeEach(^{ + currentScheduler = nil; + }); + + it(@"should be the +mainThreadScheduler when scheduled from the main queue", ^{ + dispatch_async(dispatch_get_main_queue(), ^{ + [RACScheduler.subscriptionScheduler schedule:^{ + currentScheduler = RACScheduler.currentScheduler; + }]; + }); + + expect(currentScheduler).will.equal(RACScheduler.mainThreadScheduler); + }); + + it(@"should be a +scheduler when scheduled from an unknown queue", ^{ + dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ + [RACScheduler.subscriptionScheduler schedule:^{ + currentScheduler = RACScheduler.currentScheduler; + }]; + }); + + expect(currentScheduler).willNot.beNil(); + expect(currentScheduler).notTo.equal(RACScheduler.mainThreadScheduler); + }); + + it(@"should equal the background scheduler from which the block was scheduled", ^{ + RACScheduler *backgroundScheduler = [RACScheduler scheduler]; + [backgroundScheduler schedule:^{ + [RACScheduler.subscriptionScheduler schedule:^{ + currentScheduler = RACScheduler.currentScheduler; + }]; + }]; + + expect(currentScheduler).will.equal(backgroundScheduler); + }); + }); + + it(@"should execute scheduled blocks immediately if it's in a scheduler already", ^{ + __block BOOL done = NO; + __block BOOL executedImmediately = NO; + + [[RACScheduler scheduler] schedule:^{ + [RACScheduler.subscriptionScheduler schedule:^{ + executedImmediately = YES; + }]; + + done = YES; + }]; + + expect(done).will.beTruthy(); + expect(executedImmediately).to.beTruthy(); + }); +}); + +describe(@"+immediateScheduler", ^{ + it(@"should immediately execute scheduled blocks", ^{ + __block BOOL executed = NO; + RACDisposable *disposable = [RACScheduler.immediateScheduler schedule:^{ + executed = YES; + }]; + + expect(disposable).to.beNil(); + expect(executed).to.beTruthy(); + }); + + it(@"should block for future scheduled blocks", ^{ + __block BOOL executed = NO; + RACDisposable *disposable = [RACScheduler.immediateScheduler after:[NSDate dateWithTimeIntervalSinceNow:0.01] schedule:^{ + executed = YES; + }]; + + expect(executed).to.beTruthy(); + expect(disposable).to.beNil(); + }); +}); + +describe(@"-scheduleRecursiveBlock:", ^{ + describe(@"with a synchronous scheduler", ^{ + it(@"should behave like a normal block when it doesn't invoke itself", ^{ + __block BOOL executed = NO; + [RACScheduler.immediateScheduler scheduleRecursiveBlock:^(void (^recurse)(void)) { + expect(executed).to.beFalsy(); + executed = YES; + }]; + + expect(executed).to.beTruthy(); + }); + + it(@"should reschedule itself after the caller completes", ^{ + __block NSUInteger count = 0; + [RACScheduler.immediateScheduler scheduleRecursiveBlock:^(void (^recurse)(void)) { + NSUInteger thisCount = ++count; + if (thisCount < 3) { + recurse(); + + // The block shouldn't have been invoked again yet, only + // scheduled. + expect(count).to.equal(thisCount); + } + }]; + + expect(count).to.equal(3); + }); + }); + + describe(@"with an asynchronous scheduler", ^{ + it(@"should behave like a normal block when it doesn't invoke itself", ^{ + __block BOOL executed = NO; + [RACScheduler.mainThreadScheduler scheduleRecursiveBlock:^(void (^recurse)(void)) { + expect(executed).to.beFalsy(); + executed = YES; + }]; + + expect(executed).will.beTruthy(); + }); + + it(@"should reschedule itself after the caller completes", ^{ + __block NSUInteger count = 0; + [RACScheduler.mainThreadScheduler scheduleRecursiveBlock:^(void (^recurse)(void)) { + NSUInteger thisCount = ++count; + if (thisCount < 3) { + recurse(); + + // The block shouldn't have been invoked again yet, only + // scheduled. + expect(count).to.equal(thisCount); + } + }]; + + expect(count).will.equal(3); + }); + + it(@"should reschedule when invoked asynchronously", ^{ + __block NSUInteger count = 0; + + RACScheduler *asynchronousScheduler = [RACScheduler scheduler]; + [RACScheduler.immediateScheduler scheduleRecursiveBlock:^(void (^recurse)(void)) { + [asynchronousScheduler after:[NSDate dateWithTimeIntervalSinceNow:0.01] schedule:^{ + NSUInteger thisCount = ++count; + if (thisCount < 3) { + recurse(); + + // The block shouldn't have been invoked again yet, only + // scheduled. + expect(count).to.equal(thisCount); + } + }]; + }]; + + expect(count).will.equal(3); + }); + + it(@"shouldn't reschedule itself when disposed", ^{ + __block NSUInteger count = 0; + __block RACDisposable *disposable = [RACScheduler.mainThreadScheduler scheduleRecursiveBlock:^(void (^recurse)(void)) { + ++count; + + expect(disposable).notTo.beNil(); + [disposable dispose]; + + recurse(); + }]; + + expect(count).will.equal(1); + }); + }); +}); + +describe(@"subclassing", ^{ + __block RACTestExampleScheduler *scheduler; + + beforeEach(^{ + scheduler = [[RACTestExampleScheduler alloc] initWithQueue:dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)]; + }); + + it(@"should invoke blocks scheduled with -schedule:", ^{ + __block BOOL invoked = NO; + [scheduler schedule:^{ + invoked = YES; + }]; + + expect(invoked).will.beTruthy(); + }); + + it(@"should invoke blocks scheduled with -after:schedule:", ^{ + __block BOOL invoked = NO; + [scheduler after:[NSDate dateWithTimeIntervalSinceNow:0.01] schedule:^{ + invoked = YES; + }]; + + expect(invoked).will.beTruthy(); + }); + + it(@"should set a valid current scheduler", ^{ + __block RACScheduler *currentScheduler; + [scheduler schedule:^{ + currentScheduler = RACScheduler.currentScheduler; + }]; + + expect(currentScheduler).will.equal(scheduler); + }); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACSequenceAdditionsSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSequenceAdditionsSpec.m new file mode 100644 index 0000000..e5b5834 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSequenceAdditionsSpec.m
@@ -0,0 +1,338 @@ +// +// RACSequenceAdditionsSpec.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-11-01. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACSequenceExamples.h" + +#import "NSArray+RACSequenceAdditions.h" +#import "NSDictionary+RACSequenceAdditions.h" +#import "NSOrderedSet+RACSequenceAdditions.h" +#import "NSSet+RACSequenceAdditions.h" +#import "NSString+RACSequenceAdditions.h" +#import "NSIndexSet+RACSequenceAdditions.h" +#import "RACSequence.h" +#import "RACTuple.h" + +SpecBegin(RACSequenceAdditions) + +__block NSArray *numbers; + +beforeEach(^{ + NSMutableArray *mutableNumbers = [NSMutableArray array]; + for (NSUInteger i = 0; i < 100; i++) { + [mutableNumbers addObject:@(i)]; + } + + numbers = [mutableNumbers copy]; +}); + +describe(@"NSArray sequences", ^{ + __block NSMutableArray *values; + __block RACSequence *sequence; + + beforeEach(^{ + values = [numbers mutableCopy]; + sequence = values.rac_sequence; + expect(sequence).notTo.beNil(); + }); + + itShouldBehaveLike(RACSequenceExamples, ^{ + return @{ + RACSequenceExampleSequence: sequence, + RACSequenceExampleExpectedValues: values + }; + }); + + describe(@"should be immutable", ^{ + __block NSArray *unchangedValues; + + beforeEach(^{ + unchangedValues = [values copy]; + [values addObject:@6]; + }); + + itShouldBehaveLike(RACSequenceExamples, ^{ + return @{ + RACSequenceExampleSequence: sequence, + RACSequenceExampleExpectedValues: unchangedValues + }; + }); + }); + + it(@"should fast enumerate after zipping", ^{ + // This certain list of values causes issues, for some reason. + NSArray *values = @[ @0, @0, @0, @0, @0, @0, @0, @0, @0, @0, @0, @0, @0, @0, @0, @0 ]; + RACSequence *zippedSequence = [RACSequence zip:@[ values.rac_sequence, values.rac_sequence ] reduce:^(id obj1, id obj2) { + return obj1; + }]; + + NSMutableArray *collectedValues = [NSMutableArray array]; + for (id value in zippedSequence) { + [collectedValues addObject:value]; + } + + expect(collectedValues).to.equal(values); + }); +}); + +describe(@"NSDictionary sequences", ^{ + __block NSMutableDictionary *dict; + + __block NSMutableArray *tuples; + __block RACSequence *tupleSequence; + + __block NSArray *keys; + __block RACSequence *keySequence; + + __block NSArray *values; + __block RACSequence *valueSequence; + + beforeEach(^{ + dict = [@{ + @"foo": @"bar", + @"baz": @"buzz", + @5: NSNull.null + } mutableCopy]; + + tuples = [NSMutableArray array]; + for (id key in dict) { + RACTuple *tuple = [RACTuple tupleWithObjects:key, dict[key], nil]; + [tuples addObject:tuple]; + } + + tupleSequence = dict.rac_sequence; + expect(tupleSequence).notTo.beNil(); + + keys = [dict.allKeys copy]; + keySequence = dict.rac_keySequence; + expect(keySequence).notTo.beNil(); + + values = [dict.allValues copy]; + valueSequence = dict.rac_valueSequence; + expect(valueSequence).notTo.beNil(); + }); + + itShouldBehaveLike(RACSequenceExamples, ^{ + return @{ + RACSequenceExampleSequence: tupleSequence, + RACSequenceExampleExpectedValues: tuples + }; + }); + + itShouldBehaveLike(RACSequenceExamples, ^{ + return @{ + RACSequenceExampleSequence: keySequence, + RACSequenceExampleExpectedValues: keys + }; + }); + + itShouldBehaveLike(RACSequenceExamples, ^{ + return @{ + RACSequenceExampleSequence: valueSequence, + RACSequenceExampleExpectedValues: values + }; + }); + + describe(@"should be immutable", ^{ + beforeEach(^{ + dict[@"foo"] = @"rab"; + dict[@6] = @7; + }); + + itShouldBehaveLike(RACSequenceExamples, ^{ + return @{ + RACSequenceExampleSequence: tupleSequence, + RACSequenceExampleExpectedValues: tuples + }; + }); + + itShouldBehaveLike(RACSequenceExamples, ^{ + return @{ + RACSequenceExampleSequence: keySequence, + RACSequenceExampleExpectedValues: keys + }; + }); + + itShouldBehaveLike(RACSequenceExamples, ^{ + return @{ + RACSequenceExampleSequence: valueSequence, + RACSequenceExampleExpectedValues: values + }; + }); + }); +}); + +describe(@"NSOrderedSet sequences", ^{ + __block NSMutableOrderedSet *values; + __block RACSequence *sequence; + + beforeEach(^{ + values = [NSMutableOrderedSet orderedSetWithArray:numbers]; + sequence = values.rac_sequence; + expect(sequence).notTo.beNil(); + }); + + itShouldBehaveLike(RACSequenceExamples, ^{ + return @{ + RACSequenceExampleSequence: sequence, + RACSequenceExampleExpectedValues: values.array + }; + }); + + describe(@"should be immutable", ^{ + __block NSArray *unchangedValues; + + beforeEach(^{ + unchangedValues = [values.array copy]; + [values addObject:@6]; + }); + + itShouldBehaveLike(RACSequenceExamples, ^{ + return @{ + RACSequenceExampleSequence: sequence, + RACSequenceExampleExpectedValues: unchangedValues + }; + }); + }); +}); + +describe(@"NSSet sequences", ^{ + __block NSMutableSet *values; + __block RACSequence *sequence; + + beforeEach(^{ + values = [NSMutableSet setWithArray:numbers]; + sequence = values.rac_sequence; + expect(sequence).notTo.beNil(); + }); + + itShouldBehaveLike(RACSequenceExamples, ^{ + return @{ + RACSequenceExampleSequence: sequence, + RACSequenceExampleExpectedValues: values.allObjects + }; + }); + + describe(@"should be immutable", ^{ + __block NSArray *unchangedValues; + + beforeEach(^{ + unchangedValues = [values.allObjects copy]; + [values addObject:@6]; + }); + + itShouldBehaveLike(RACSequenceExamples, ^{ + return @{ + RACSequenceExampleSequence: sequence, + RACSequenceExampleExpectedValues: unchangedValues + }; + }); + }); +}); + +describe(@"NSString sequences", ^{ + __block NSMutableString *string; + __block NSArray *values; + __block RACSequence *sequence; + + beforeEach(^{ + string = [@"foobar" mutableCopy]; + values = @[ @"f", @"o", @"o", @"b", @"a", @"r" ]; + sequence = string.rac_sequence; + expect(sequence).notTo.beNil(); + }); + + itShouldBehaveLike(RACSequenceExamples, ^{ + return @{ + RACSequenceExampleSequence: sequence, + RACSequenceExampleExpectedValues: values + }; + }); + + describe(@"should be immutable", ^{ + beforeEach(^{ + [string appendString:@"buzz"]; + }); + + itShouldBehaveLike(RACSequenceExamples, ^{ + return @{ + RACSequenceExampleSequence: sequence, + RACSequenceExampleExpectedValues: values + }; + }); + }); + + it(@"should work with composed characters", ^{ + NSString *string = @"\u2665\uFE0F\u2666\uFE0F"; + NSArray *expectedSequence = @[ @"\u2665\uFE0F", @"\u2666\uFE0F" ]; + expect(string.rac_sequence.array).to.equal(expectedSequence); + }); +}); + +describe(@"RACTuple sequences", ^{ + __block RACTuple *tuple; + __block RACSequence *sequence; + + beforeEach(^{ + tuple = RACTuplePack(@"foo", nil, @"bar", NSNull.null, RACTupleNil.tupleNil); + + sequence = tuple.rac_sequence; + expect(sequence).notTo.beNil(); + }); + + itShouldBehaveLike(RACSequenceExamples, ^{ + return @{ + RACSequenceExampleSequence: sequence, + RACSequenceExampleExpectedValues: @[ @"foo", NSNull.null, @"bar", NSNull.null, NSNull.null ] + }; + }); +}); + +describe(@"NSIndexSet sequences", ^{ + __block NSMutableIndexSet *values; + __block RACSequence *sequence; + + NSArray * (^valuesFromIndexSet)(NSIndexSet *indexSet) = ^NSArray *(NSIndexSet *indexSet) { + NSMutableArray *arr = [NSMutableArray array]; + [values enumerateIndexesUsingBlock:^(NSUInteger idx, BOOL *stop) { + [arr addObject:@(idx)]; + }]; + + return [arr copy]; + }; + + beforeEach(^{ + values = [NSMutableIndexSet indexSetWithIndexesInRange:NSMakeRange(0, 10)]; + sequence = values.rac_sequence; + expect(sequence).notTo.beNil(); + }); + + itShouldBehaveLike(RACSequenceExamples, ^{ + return @{ + RACSequenceExampleSequence: sequence, + RACSequenceExampleExpectedValues: valuesFromIndexSet(values) + }; + }); + + describe(@"should be immutable", ^{ + __block NSArray *unchangedValues; + + beforeEach(^{ + unchangedValues = valuesFromIndexSet(values); + [values addIndex:20]; + }); + + itShouldBehaveLike(RACSequenceExamples, ^{ + return @{ + RACSequenceExampleSequence: sequence, + RACSequenceExampleExpectedValues: unchangedValues + }; + }); + }); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACSequenceExamples.h b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSequenceExamples.h new file mode 100644 index 0000000..922b056 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSequenceExamples.h
@@ -0,0 +1,16 @@ +// +// RACSequenceExamples.h +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-11-01. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +// The name of the shared examples for RACSequence instances. +extern NSString * const RACSequenceExamples; + +// RACSequence * +extern NSString * const RACSequenceExampleSequence; + +// NSArray * +extern NSString * const RACSequenceExampleExpectedValues;
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACSequenceExamples.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSequenceExamples.m new file mode 100644 index 0000000..5ca3923 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSequenceExamples.m
@@ -0,0 +1,125 @@ +// +// RACSequenceExamples.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-11-01. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACSequenceExamples.h" + +#import "RACScheduler.h" +#import "RACSequence.h" +#import "RACSignal+Operations.h" + +NSString * const RACSequenceExamples = @"RACSequenceExamples"; +NSString * const RACSequenceExampleSequence = @"RACSequenceExampleSequence"; +NSString * const RACSequenceExampleExpectedValues = @"RACSequenceExampleExpectedValues"; + +SharedExampleGroupsBegin(RACSequenceExamples); + +sharedExamplesFor(RACSequenceExamples, ^(NSDictionary *data) { + __block RACSequence *sequence; + __block NSArray *values; + + beforeEach(^{ + sequence = data[RACSequenceExampleSequence]; + values = [data[RACSequenceExampleExpectedValues] copy]; + }); + + it(@"should implement <NSFastEnumeration>", ^{ + NSMutableArray *collectedValues = [NSMutableArray array]; + for (id value in sequence) { + [collectedValues addObject:value]; + } + + expect(collectedValues).to.equal(values); + }); + + it(@"should return an array", ^{ + expect(sequence.array).to.equal(values); + }); + + describe(@"-signalWithScheduler:", ^{ + it(@"should return an immediately scheduled signal", ^{ + RACSignal *signal = [sequence signalWithScheduler:RACScheduler.immediateScheduler]; + expect(signal.toArray).to.equal(values); + }); + + it(@"should return a background scheduled signal", ^{ + RACSignal *signal = [sequence signalWithScheduler:[RACScheduler scheduler]]; + expect(signal.toArray).to.equal(values); + }); + + it(@"should only evaluate one value per scheduling", ^{ + RACSignal *signal = [sequence signalWithScheduler:RACScheduler.mainThreadScheduler]; + + __block BOOL flag = YES; + __block BOOL completed = NO; + [signal subscribeNext:^(id x) { + expect(flag).to.beTruthy(); + flag = NO; + + [RACScheduler.mainThreadScheduler schedule:^{ + // This should get executed before the next value (which + // verifies that it's YES). + flag = YES; + }]; + } completed:^{ + completed = YES; + }]; + + expect(completed).will.beTruthy(); + }); + }); + + it(@"should be equal to itself", ^{ + expect(sequence).to.equal(sequence); + }); + + it(@"should be equal to the same sequence of values", ^{ + RACSequence *newSequence = RACSequence.empty; + for (id value in values) { + RACSequence *valueSeq = [RACSequence return:value]; + expect(valueSeq).notTo.beNil(); + + newSequence = [newSequence concat:valueSeq]; + } + + expect(sequence).to.equal(newSequence); + expect(sequence.hash).to.equal(newSequence.hash); + }); + + it(@"should not be equal to a different sequence of values", ^{ + RACSequence *anotherSequence = [RACSequence return:@(-1)]; + expect(sequence).notTo.equal(anotherSequence); + }); + + it(@"should return an identical object for -copy", ^{ + expect([sequence copy]).to.beIdenticalTo(sequence); + }); + + it(@"should archive", ^{ + NSData *data = [NSKeyedArchiver archivedDataWithRootObject:sequence]; + expect(data).notTo.beNil(); + + RACSequence *unarchived = [NSKeyedUnarchiver unarchiveObjectWithData:data]; + expect(unarchived).to.equal(sequence); + }); + + it(@"should fold right", ^{ + RACSequence *result = [sequence foldRightWithStart:[RACSequence empty] reduce:^(id first, RACSequence *rest) { + return [rest.head startWith:first]; + }]; + expect(result.array).to.equal(values); + }); + + it(@"should fold left", ^{ + RACSequence *result = [sequence foldLeftWithStart:[RACSequence empty] reduce:^(RACSequence *first, id rest) { + return [first concat:[RACSequence return:rest]]; + }]; + expect(result.array).to.equal(values); + }); +}); + +SharedExampleGroupsEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACSequenceSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSequenceSpec.m new file mode 100644 index 0000000..3bf7dca --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSequenceSpec.m
@@ -0,0 +1,443 @@ +// +// RACSequenceSpec.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-11-01. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACSequenceExamples.h" +#import "RACStreamExamples.h" + +#import "NSArray+RACSequenceAdditions.h" +#import "NSObject+RACDeallocating.h" +#import "NSObject+RACPropertySubscribing.h" +#import "RACCompoundDisposable.h" +#import "RACDisposable.h" +#import "RACSequence.h" +#import "RACUnit.h" + +SpecBegin(RACSequence) + +describe(@"RACStream", ^{ + id verifyValues = ^(RACSequence *sequence, NSArray *expectedValues) { + NSMutableArray *collectedValues = [NSMutableArray array]; + while (sequence.head != nil) { + [collectedValues addObject:sequence.head]; + sequence = sequence.tail; + } + + expect(collectedValues).to.equal(expectedValues); + }; + + __block RACSequence *infiniteSequence = [RACSequence sequenceWithHeadBlock:^{ + return RACUnit.defaultUnit; + } tailBlock:^{ + return infiniteSequence; + }]; + + itShouldBehaveLike(RACStreamExamples, ^{ + return @{ + RACStreamExamplesClass: RACSequence.class, + RACStreamExamplesVerifyValuesBlock: verifyValues, + RACStreamExamplesInfiniteStream: infiniteSequence + }; + }); +}); + +describe(@"+sequenceWithHeadBlock:tailBlock:", ^{ + __block RACSequence *sequence; + __block BOOL headInvoked; + __block BOOL tailInvoked; + + before(^{ + headInvoked = NO; + tailInvoked = NO; + + sequence = [RACSequence sequenceWithHeadBlock:^{ + headInvoked = YES; + return @0; + } tailBlock:^{ + tailInvoked = YES; + return [RACSequence return:@1]; + }]; + + expect(sequence).notTo.beNil(); + }); + + it(@"should use the values from the head and tail blocks", ^{ + expect(sequence.head).to.equal(@0); + expect(sequence.tail.head).to.equal(@1); + expect(sequence.tail.tail).to.beNil(); + }); + + it(@"should lazily invoke head and tail blocks", ^{ + expect(headInvoked).to.beFalsy(); + expect(tailInvoked).to.beFalsy(); + + expect(sequence.head).to.equal(@0); + expect(headInvoked).to.beTruthy(); + expect(tailInvoked).to.beFalsy(); + + expect(sequence.tail).notTo.beNil(); + expect(tailInvoked).to.beTruthy(); + }); + + after(^{ + itShouldBehaveLike(RACSequenceExamples, ^{ + return @{ + RACSequenceExampleSequence: sequence, + RACSequenceExampleExpectedValues: @[ @0, @1 ] + }; + }); + }); +}); + +describe(@"empty sequences", ^{ + itShouldBehaveLike(RACSequenceExamples, ^{ + return @{ + RACSequenceExampleSequence: [RACSequence empty], + RACSequenceExampleExpectedValues: @[] + }; + }); +}); + +describe(@"non-empty sequences", ^{ + itShouldBehaveLike(RACSequenceExamples, ^{ + return @{ + RACSequenceExampleSequence: [[[RACSequence return:@0] concat:[RACSequence return:@1]] concat:[RACSequence return:@2]], + RACSequenceExampleExpectedValues: @[ @0, @1, @2 ] + }; + }); +}); + +describe(@"eager sequences", ^{ + __block RACSequence *lazySequence; + __block BOOL headInvoked; + __block BOOL tailInvoked; + + NSArray *values = @[ @0, @1 ]; + + before(^{ + headInvoked = NO; + tailInvoked = NO; + + lazySequence = [RACSequence sequenceWithHeadBlock:^{ + headInvoked = YES; + return @0; + } tailBlock:^{ + tailInvoked = YES; + return [RACSequence return:@1]; + }]; + + expect(lazySequence).notTo.beNil(); + }); + + itShouldBehaveLike(RACSequenceExamples, ^{ + return @{ + RACSequenceExampleSequence: lazySequence.eagerSequence, + RACSequenceExampleExpectedValues: values + }; + }); + + it(@"should evaluate all values immediately", ^{ + RACSequence *eagerSequence = lazySequence.eagerSequence; + expect(headInvoked).to.beTruthy(); + expect(tailInvoked).to.beTruthy(); + expect(eagerSequence.array).to.equal(values); + }); +}); + +describe(@"-take:", ^{ + it(@"should complete take: without needing the head of the second item in the sequence", ^{ + __block NSUInteger valuesTaken = 0; + + __block RACSequence *sequence = [RACSequence sequenceWithHeadBlock:^{ + ++valuesTaken; + return RACUnit.defaultUnit; + } tailBlock:^{ + return sequence; + }]; + + NSArray *values = [sequence take:1].array; + expect(values).to.equal(@[ RACUnit.defaultUnit ]); + expect(valuesTaken).to.equal(1); + }); +}); + +describe(@"-bind:", ^{ + it(@"should only evaluate head when the resulting sequence is evaluated", ^{ + __block BOOL headInvoked = NO; + + RACSequence *original = [RACSequence sequenceWithHeadBlock:^{ + headInvoked = YES; + return RACUnit.defaultUnit; + } tailBlock:^ id { + return nil; + }]; + + RACSequence *bound = [original bind:^{ + return ^(id value, BOOL *stop) { + return [RACSequence return:value]; + }; + }]; + + expect(bound).notTo.beNil(); + expect(headInvoked).to.beFalsy(); + + expect(bound.head).to.equal(RACUnit.defaultUnit); + expect(headInvoked).to.beTruthy(); + }); +}); + +describe(@"-objectEnumerator", ^{ + it(@"should only evaluate head as it's enumerated", ^{ + __block BOOL firstHeadInvoked = NO; + __block BOOL secondHeadInvoked = NO; + __block BOOL thirdHeadInvoked = NO; + + RACSequence *sequence = [RACSequence sequenceWithHeadBlock:^id{ + firstHeadInvoked = YES; + return @1; + } tailBlock:^RACSequence *{ + return [RACSequence sequenceWithHeadBlock:^id{ + secondHeadInvoked = YES; + return @2; + } tailBlock:^RACSequence *{ + return [RACSequence sequenceWithHeadBlock:^id{ + thirdHeadInvoked = YES; + return @3; + } tailBlock:^RACSequence *{ + return RACSequence.empty; + }]; + }]; + }]; + NSEnumerator *enumerator = sequence.objectEnumerator; + + expect(firstHeadInvoked).to.beFalsy(); + expect(secondHeadInvoked).to.beFalsy(); + expect(thirdHeadInvoked).to.beFalsy(); + + expect([enumerator nextObject]).to.equal(@1); + + expect(firstHeadInvoked).to.beTruthy(); + expect(secondHeadInvoked).to.beFalsy(); + expect(thirdHeadInvoked).to.beFalsy(); + + expect([enumerator nextObject]).to.equal(@2); + + expect(secondHeadInvoked).to.beTruthy(); + expect(thirdHeadInvoked).to.beFalsy(); + + expect([enumerator nextObject]).to.equal(@3); + + expect(thirdHeadInvoked).to.beTruthy(); + + expect([enumerator nextObject]).to.beNil(); + }); + + it(@"should let the sequence dealloc as it's enumerated", ^{ + __block BOOL firstSequenceDeallocd = NO; + __block BOOL secondSequenceDeallocd = NO; + __block BOOL thirdSequenceDeallocd = NO; + + NSEnumerator *enumerator = nil; + + @autoreleasepool { + RACSequence *thirdSequence __attribute__((objc_precise_lifetime)) = [RACSequence sequenceWithHeadBlock:^id{ + return @3; + } tailBlock:^RACSequence *{ + return RACSequence.empty; + }]; + [thirdSequence.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + thirdSequenceDeallocd = YES; + }]]; + + RACSequence *secondSequence __attribute__((objc_precise_lifetime)) = [RACSequence sequenceWithHeadBlock:^id{ + return @2; + } tailBlock:^RACSequence *{ + return thirdSequence; + }]; + [secondSequence.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + secondSequenceDeallocd = YES; + }]]; + + RACSequence *firstSequence __attribute__((objc_precise_lifetime)) = [RACSequence sequenceWithHeadBlock:^id{ + return @1; + } tailBlock:^RACSequence *{ + return secondSequence; + }]; + [firstSequence.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + firstSequenceDeallocd = YES; + }]]; + + enumerator = firstSequence.objectEnumerator; + } + + @autoreleasepool { + expect([enumerator nextObject]).to.equal(@1); + } + + @autoreleasepool { + expect([enumerator nextObject]).to.equal(@2); + } + expect(firstSequenceDeallocd).will.beTruthy(); + + @autoreleasepool { + expect([enumerator nextObject]).to.equal(@3); + } + expect(secondSequenceDeallocd).will.beTruthy(); + + @autoreleasepool { + expect([enumerator nextObject]).to.beNil(); + } + expect(thirdSequenceDeallocd).will.beTruthy(); + }); +}); + +it(@"shouldn't overflow the stack when deallocated on a background queue", ^{ + NSUInteger length = 10000; + NSMutableArray *values = [NSMutableArray arrayWithCapacity:length]; + for (NSUInteger i = 0; i < length; ++i) { + [values addObject:@(i)]; + } + + __block BOOL finished = NO; + dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ + @autoreleasepool { + [[values.rac_sequence map:^(id value) { + return value; + }] array]; + } + + finished = YES; + }); + + NSTimeInterval oldTimeout = Expecta.asynchronousTestTimeout; + Expecta.asynchronousTestTimeout = DBL_MAX; + expect(finished).will.beTruthy(); + Expecta.asynchronousTestTimeout = oldTimeout; +}); + +describe(@"-foldLeftWithStart:reduce:", ^{ + it(@"should reduce with start first", ^{ + RACSequence *sequence = [[[RACSequence return:@0] concat:[RACSequence return:@1]] concat:[RACSequence return:@2]]; + NSNumber *result = [sequence foldLeftWithStart:@3 reduce:^(NSNumber *first, NSNumber *rest) { + return first; + }]; + expect(result).to.equal(@3); + }); + + it(@"should be left associative", ^{ + RACSequence *sequence = [[[RACSequence return:@1] concat:[RACSequence return:@2]] concat:[RACSequence return:@3]]; + NSNumber *result = [sequence foldLeftWithStart:@0 reduce:^(NSNumber *first, NSNumber *rest) { + int difference = first.intValue - rest.intValue; + return @(difference); + }]; + expect(result).to.equal(@-6); + }); +}); + +describe(@"-foldRightWithStart:reduce:", ^{ + it(@"should be lazy", ^{ + __block BOOL headInvoked = NO; + __block BOOL tailInvoked = NO; + RACSequence *sequence = [RACSequence sequenceWithHeadBlock:^{ + headInvoked = YES; + return @0; + } tailBlock:^{ + tailInvoked = YES; + return [RACSequence return:@1]; + }]; + + NSNumber *result = [sequence foldRightWithStart:@2 reduce:^(NSNumber *first, RACSequence *rest) { + return first; + }]; + + expect(result).to.equal(@0); + expect(headInvoked).to.beTruthy(); + expect(tailInvoked).to.beFalsy(); + }); + + it(@"should reduce with start last", ^{ + RACSequence *sequence = [[[RACSequence return:@0] concat:[RACSequence return:@1]] concat:[RACSequence return:@2]]; + NSNumber *result = [sequence foldRightWithStart:@3 reduce:^(NSNumber *first, RACSequence *rest) { + return rest.head; + }]; + expect(result).to.equal(@3); + }); + + it(@"should be right associative", ^{ + RACSequence *sequence = [[[RACSequence return:@1] concat:[RACSequence return:@2]] concat:[RACSequence return:@3]]; + NSNumber *result = [sequence foldRightWithStart:@0 reduce:^(NSNumber *first, RACSequence *rest) { + int difference = first.intValue - [rest.head intValue]; + return @(difference); + }]; + expect(result).to.equal(@2); + }); +}); + +describe(@"-any", ^{ + __block RACSequence *sequence; + beforeEach(^{ + sequence = [[[RACSequence return:@0] concat:[RACSequence return:@1]] concat:[RACSequence return:@2]]; + }); + + it(@"should return true when at least one exists", ^{ + BOOL result = [sequence any:^ BOOL (NSNumber *value) { + return value.integerValue > 0; + }]; + expect(result).to.beTruthy(); + }); + + it(@"should return false when no such thing exists", ^{ + BOOL result = [sequence any:^ BOOL (NSNumber *value) { + return value.integerValue == 3; + }]; + expect(result).to.beFalsy(); + }); +}); + +describe(@"-all", ^{ + __block RACSequence *sequence; + beforeEach(^{ + sequence = [[[RACSequence return:@0] concat:[RACSequence return:@1]] concat:[RACSequence return:@2]]; + }); + + it(@"should return true when all values pass", ^{ + BOOL result = [sequence all:^ BOOL (NSNumber *value) { + return value.integerValue >= 0; + }]; + expect(result).to.beTruthy(); + }); + + it(@"should return false when at least one value fails", ^{ + BOOL result = [sequence all:^ BOOL (NSNumber *value) { + return value.integerValue < 2; + }]; + expect(result).to.beFalsy(); + }); +}); + +describe(@"-objectPassingTest:", ^{ + __block RACSequence *sequence; + beforeEach(^{ + sequence = [[[RACSequence return:@0] concat:[RACSequence return:@1]] concat:[RACSequence return:@2]]; + }); + + it(@"should return leftmost object that passes the test", ^{ + NSNumber *result = [sequence objectPassingTest:^ BOOL (NSNumber *value) { + return value.intValue > 0; + }]; + expect(result).to.equal(@1); + }); + + it(@"should return nil if no objects pass the test", ^{ + NSNumber *result = [sequence objectPassingTest:^ BOOL (NSNumber *value) { + return value.intValue < 0; + }]; + expect(result).to.beNil(); + }); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACSerialDisposableSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSerialDisposableSpec.m new file mode 100644 index 0000000..cdf35f5 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSerialDisposableSpec.m
@@ -0,0 +1,137 @@ +// +// RACSerialDisposableSpec.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-07-22. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACSerialDisposable.h" + +SpecBegin(RACSerialDisposable) + +it(@"should initialize with -init", ^{ + RACSerialDisposable *serial = [[RACSerialDisposable alloc] init]; + expect(serial).notTo.beNil(); + expect(serial.disposable).to.beNil(); +}); + +it(@"should initialize an inner disposable with -initWithBlock:", ^{ + __block BOOL disposed = NO; + RACSerialDisposable *serial = [RACSerialDisposable disposableWithBlock:^{ + disposed = YES; + }]; + + expect(serial).notTo.beNil(); + expect(serial.disposable).notTo.beNil(); + + [serial.disposable dispose]; + expect(serial.disposed).to.beFalsy(); + expect(disposed).to.beTruthy(); +}); + +it(@"should initialize with a disposable", ^{ + RACDisposable *inner = [[RACDisposable alloc] init]; + RACSerialDisposable *serial = [RACSerialDisposable serialDisposableWithDisposable:inner]; + expect(serial).notTo.beNil(); + expect(serial.disposable).to.equal(inner); +}); + +it(@"should dispose of the inner disposable", ^{ + __block BOOL disposed = NO; + RACDisposable *inner = [RACDisposable disposableWithBlock:^{ + disposed = YES; + }]; + + RACSerialDisposable *serial = [RACSerialDisposable serialDisposableWithDisposable:inner]; + expect(serial.disposed).to.beFalsy(); + expect(disposed).to.beFalsy(); + + [serial dispose]; + expect(serial.disposed).to.beTruthy(); + expect(serial.disposable).to.beNil(); + expect(disposed).to.beTruthy(); +}); + +it(@"should dispose of a new inner disposable if it's already been disposed", ^{ + __block BOOL disposed = NO; + RACDisposable *inner = [RACDisposable disposableWithBlock:^{ + disposed = YES; + }]; + + RACSerialDisposable *serial = [[RACSerialDisposable alloc] init]; + expect(serial.disposed).to.beFalsy(); + + [serial dispose]; + expect(serial.disposed).to.beTruthy(); + expect(disposed).to.beFalsy(); + + serial.disposable = inner; + expect(disposed).to.beTruthy(); + expect(serial.disposable).to.beNil(); +}); + +it(@"should allow the inner disposable to be set to nil", ^{ + __block BOOL disposed = NO; + RACDisposable *inner = [RACDisposable disposableWithBlock:^{ + disposed = YES; + }]; + + RACSerialDisposable *serial = [RACSerialDisposable serialDisposableWithDisposable:inner]; + expect(disposed).to.beFalsy(); + + serial.disposable = nil; + expect(serial.disposable).to.beNil(); + + serial.disposable = inner; + expect(serial.disposable).to.equal(inner); + + [serial dispose]; + expect(disposed).to.beTruthy(); + expect(serial.disposable).to.beNil(); +}); + +it(@"should swap inner disposables", ^{ + __block BOOL firstDisposed = NO; + RACDisposable *first = [RACDisposable disposableWithBlock:^{ + firstDisposed = YES; + }]; + + __block BOOL secondDisposed = NO; + RACDisposable *second = [RACDisposable disposableWithBlock:^{ + secondDisposed = YES; + }]; + + RACSerialDisposable *serial = [RACSerialDisposable serialDisposableWithDisposable:first]; + expect([serial swapInDisposable:second]).to.equal(first); + + expect(serial.disposed).to.beFalsy(); + expect(firstDisposed).to.beFalsy(); + expect(secondDisposed).to.beFalsy(); + + [serial dispose]; + expect(serial.disposed).to.beTruthy(); + expect(serial.disposable).to.beNil(); + + expect(firstDisposed).to.beFalsy(); + expect(secondDisposed).to.beTruthy(); +}); + +it(@"should release the inner disposable upon deallocation", ^{ + __weak RACDisposable *weakInnerDisposable; + __weak RACSerialDisposable *weakSerialDisposable; + + @autoreleasepool { + RACDisposable *innerDisposable __attribute__((objc_precise_lifetime)) = [[RACDisposable alloc] init]; + weakInnerDisposable = innerDisposable; + + RACSerialDisposable *serialDisposable __attribute__((objc_precise_lifetime)) = [[RACSerialDisposable alloc] init]; + serialDisposable.disposable = innerDisposable; + weakSerialDisposable = serialDisposable; + } + + expect(weakSerialDisposable).to.beNil(); + expect(weakInnerDisposable).to.beNil(); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACSignalSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSignalSpec.m new file mode 100644 index 0000000..21b50dd --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSignalSpec.m
@@ -0,0 +1,3877 @@ +// +// RACSignalSpec.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 3/2/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACPropertySignalExamples.h" +#import "RACSequenceExamples.h" +#import "RACStreamExamples.h" +#import "RACTestObject.h" + +#import "EXTKeyPathCoding.h" +#import "NSObject+RACDeallocating.h" +#import "NSObject+RACPropertySubscribing.h" +#import "RACBehaviorSubject.h" +#import "RACCommand.h" +#import "RACCompoundDisposable.h" +#import "RACDisposable.h" +#import "RACEvent.h" +#import "RACGroupedSignal.h" +#import "RACMulticastConnection.h" +#import "RACReplaySubject.h" +#import "RACScheduler.h" +#import "RACSignal+Operations.h" +#import "RACSignalStartExamples.h" +#import "RACSubject.h" +#import "RACSubscriber+Private.h" +#import "RACSubscriber.h" +#import "RACTestScheduler.h" +#import "RACTuple.h" +#import "RACUnit.h" +#import <libkern/OSAtomic.h> + +// Set in a beforeAll below. +static NSError *RACSignalTestError; + +static NSString * const RACSignalMergeConcurrentCompletionExampleGroup = @"RACSignalMergeConcurrentCompletionExampleGroup"; +static NSString * const RACSignalMaxConcurrent = @"RACSignalMaxConcurrent"; +SharedExampleGroupsBegin(mergeConcurrentCompletionName); + +sharedExamplesFor(RACSignalMergeConcurrentCompletionExampleGroup, ^(NSDictionary *data) { + it(@"should complete only after the source and all its signals have completed", ^{ + RACSubject *subject1 = [RACSubject subject]; + RACSubject *subject2 = [RACSubject subject]; + RACSubject *subject3 = [RACSubject subject]; + + RACSubject *signalsSubject = [RACSubject subject]; + __block BOOL completed = NO; + [[signalsSubject flatten:[data[RACSignalMaxConcurrent] unsignedIntegerValue]] subscribeCompleted:^{ + completed = YES; + }]; + + [signalsSubject sendNext:subject1]; + [subject1 sendCompleted]; + + expect(completed).to.beFalsy(); + + [signalsSubject sendNext:subject2]; + [signalsSubject sendNext:subject3]; + + [signalsSubject sendCompleted]; + + expect(completed).to.beFalsy(); + + [subject2 sendCompleted]; + + expect(completed).to.beFalsy(); + + [subject3 sendCompleted]; + + expect(completed).to.beTruthy(); + }); +}); + +SharedExampleGroupsEnd + +SpecBegin(RACSignal) + +beforeAll(^{ + // We do this instead of a macro to ensure that to.equal() will work + // correctly (by matching identity), even if -[NSError isEqual:] is broken. + RACSignalTestError = [NSError errorWithDomain:@"foo" code:100 userInfo:nil]; +}); + +describe(@"RACStream", ^{ + id verifyValues = ^(RACSignal *signal, NSArray *expectedValues) { + expect(signal).notTo.beNil(); + + NSMutableArray *collectedValues = [NSMutableArray array]; + + __block BOOL success = NO; + __block NSError *error = nil; + [signal subscribeNext:^(id value) { + [collectedValues addObject:value]; + } error:^(NSError *receivedError) { + error = receivedError; + } completed:^{ + success = YES; + }]; + + expect(success).will.beTruthy(); + expect(error).to.beNil(); + expect(collectedValues).to.equal(expectedValues); + }; + + RACSignal *infiniteSignal = [RACSignal createSignal:^(id<RACSubscriber> subscriber) { + __block volatile int32_t done = 0; + + [RACScheduler.mainThreadScheduler schedule:^{ + while (!done) { + [subscriber sendNext:RACUnit.defaultUnit]; + } + }]; + + return [RACDisposable disposableWithBlock:^{ + OSAtomicIncrement32Barrier(&done); + }]; + }]; + + itShouldBehaveLike(RACStreamExamples, ^{ + return @{ + RACStreamExamplesClass: RACSignal.class, + RACStreamExamplesVerifyValuesBlock: verifyValues, + RACStreamExamplesInfiniteStream: infiniteSignal + }; + }); +}); + +describe(@"-bind:", ^{ + __block RACSubject *signals; + __block BOOL disposed; + __block id lastValue; + __block RACSubject *values; + + beforeEach(^{ + // Tests send a (RACSignal, BOOL) pair that are used below in -bind:. + signals = [RACSubject subject]; + + disposed = NO; + RACSignal *source = [RACSignal createSignal:^(id<RACSubscriber> subscriber) { + [signals subscribe:subscriber]; + + return [RACDisposable disposableWithBlock:^{ + disposed = YES; + }]; + }]; + + RACSignal *bind = [source bind:^{ + return ^(RACTuple *x, BOOL *stop) { + RACTupleUnpack(RACSignal *signal, NSNumber *stopValue) = x; + *stop = stopValue.boolValue; + return signal; + }; + }]; + + lastValue = nil; + [bind subscribeNext:^(id x) { + lastValue = x; + }]; + + // Send `bind` an open ended subject to subscribe to. These tests make + // use of this in two ways: + // 1. Used to test a regression bug where -bind: would not actually + // stop when instructed to. This bug manifested itself only when + // there were subscriptions that lived on past the point at which + // -bind: was stopped. This subject represents such a subscription. + // 2. Test that values sent by this subject are received by `bind`'s + // subscriber, even *after* -bind: has been instructed to stop. + values = [RACSubject subject]; + [signals sendNext:RACTuplePack(values, @NO)]; + expect(disposed).to.beFalsy(); + }); + + it(@"should dispose source signal when stopped with nil signal", ^{ + // Tell -bind: to stop by sending it a `nil` signal. + [signals sendNext:RACTuplePack(nil, @NO)]; + expect(disposed).to.beTruthy(); + + // Should still receive values sent after stopping. + expect(lastValue).to.beNil(); + [values sendNext:RACUnit.defaultUnit]; + expect(lastValue).to.equal(RACUnit.defaultUnit); + }); + + it(@"should dispose source signal when stop flag set to YES", ^{ + // Tell -bind: to stop by setting the stop flag to YES. + [signals sendNext:RACTuplePack([RACSignal return:@1], @YES)]; + expect(disposed).to.beTruthy(); + + // Should still recieve last signal sent at the time of setting stop to YES. + expect(lastValue).to.equal(@1); + + // Should still receive values sent after stopping. + [values sendNext:@2]; + expect(lastValue).to.equal(@2); + }); +}); + +describe(@"subscribing", ^{ + __block RACSignal *signal = nil; + id nextValueSent = @"1"; + + beforeEach(^{ + signal = [RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) { + [subscriber sendNext:nextValueSent]; + [subscriber sendCompleted]; + return nil; + }]; + }); + + it(@"should get next values", ^{ + __block id nextValueReceived = nil; + [signal subscribeNext:^(id x) { + nextValueReceived = x; + } error:^(NSError *error) { + + } completed:^{ + + }]; + + expect(nextValueReceived).to.equal(nextValueSent); + }); + + it(@"should get completed", ^{ + __block BOOL didGetCompleted = NO; + [signal subscribeNext:^(id x) { + + } error:^(NSError *error) { + + } completed:^{ + didGetCompleted = YES; + }]; + + expect(didGetCompleted).to.beTruthy(); + }); + + it(@"should not get an error", ^{ + __block BOOL didGetError = NO; + [signal subscribeNext:^(id x) { + + } error:^(NSError *error) { + didGetError = YES; + } completed:^{ + + }]; + + expect(didGetError).to.beFalsy(); + }); + + it(@"shouldn't get anything after dispose", ^{ + RACTestScheduler *scheduler = [[RACTestScheduler alloc] init]; + NSMutableArray *receivedValues = [NSMutableArray array]; + + RACSignal *signal = [RACSignal createSignal:^ id (id<RACSubscriber> subscriber) { + [subscriber sendNext:@0]; + + [scheduler afterDelay:0 schedule:^{ + [subscriber sendNext:@1]; + }]; + + return nil; + }]; + + RACDisposable *disposable = [signal subscribeNext:^(id x) { + [receivedValues addObject:x]; + }]; + + NSArray *expectedValues = @[ @0 ]; + expect(receivedValues).to.equal(expectedValues); + + [disposable dispose]; + [scheduler stepAll]; + + expect(receivedValues).to.equal(expectedValues); + }); + + it(@"should have a current scheduler in didSubscribe block", ^{ + __block RACScheduler *currentScheduler; + RACSignal *signal = [RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) { + currentScheduler = RACScheduler.currentScheduler; + [subscriber sendCompleted]; + return nil; + }]; + + [signal subscribeNext:^(id x) {}]; + expect(currentScheduler).notTo.beNil(); + + currentScheduler = nil; + dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ + [signal subscribeNext:^(id x) {}]; + }); + expect(currentScheduler).willNot.beNil(); + }); + + it(@"should automatically dispose of other subscriptions from +createSignal:", ^{ + __block BOOL innerDisposed = NO; + + RACSignal *innerSignal = [RACSignal createSignal:^(id<RACSubscriber> subscriber) { + return [RACDisposable disposableWithBlock:^{ + innerDisposed = YES; + }]; + }]; + + RACSignal *outerSignal = [RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) { + [innerSignal subscribe:subscriber]; + return nil; + }]; + + RACDisposable *disposable = [outerSignal subscribeCompleted:^{}]; + expect(disposable).notTo.beNil(); + expect(innerDisposed).to.beFalsy(); + + [disposable dispose]; + expect(innerDisposed).to.beTruthy(); + }); +}); + +describe(@"-takeUntil:", ^{ + it(@"should support value as trigger", ^{ + __block BOOL shouldBeGettingItems = YES; + RACSubject *subject = [RACSubject subject]; + RACSubject *cutOffSubject = [RACSubject subject]; + [[subject takeUntil:cutOffSubject] subscribeNext:^(id x) { + expect(shouldBeGettingItems).to.beTruthy(); + }]; + + shouldBeGettingItems = YES; + [subject sendNext:@"test 1"]; + [subject sendNext:@"test 2"]; + + [cutOffSubject sendNext:[RACUnit defaultUnit]]; + + shouldBeGettingItems = NO; + [subject sendNext:@"test 3"]; + }); + + it(@"should support completion as trigger", ^{ + __block BOOL shouldBeGettingItems = YES; + RACSubject *subject = [RACSubject subject]; + RACSubject *cutOffSubject = [RACSubject subject]; + [[subject takeUntil:cutOffSubject] subscribeNext:^(id x) { + expect(shouldBeGettingItems).to.beTruthy(); + }]; + + [cutOffSubject sendCompleted]; + + shouldBeGettingItems = NO; + [subject sendNext:@"should not go through"]; + }); + + it(@"should squelch any values sent immediately upon subscription", ^{ + RACSignal *valueSignal = [RACSignal return:RACUnit.defaultUnit]; + RACSignal *cutOffSignal = [RACSignal empty]; + + __block BOOL gotNext = NO; + __block BOOL completed = NO; + + [[valueSignal takeUntil:cutOffSignal] subscribeNext:^(id _) { + gotNext = YES; + } completed:^{ + completed = YES; + }]; + + expect(gotNext).to.beFalsy(); + expect(completed).to.beTruthy(); + }); +}); + +describe(@"-takeUntilReplacement:", ^{ + it(@"should forward values from the receiver until it's replaced", ^{ + RACSubject *receiver = [RACSubject subject]; + RACSubject *replacement = [RACSubject subject]; + + NSMutableArray *receivedValues = [NSMutableArray array]; + + [[receiver takeUntilReplacement:replacement] subscribeNext:^(id x) { + [receivedValues addObject:x]; + }]; + + expect(receivedValues).to.equal(@[]); + + [receiver sendNext:@1]; + expect(receivedValues).to.equal(@[ @1 ]); + + [receiver sendNext:@2]; + expect(receivedValues).to.equal((@[ @1, @2 ])); + + [replacement sendNext:@3]; + expect(receivedValues).to.equal((@[ @1, @2, @3 ])); + + [receiver sendNext:@4]; + expect(receivedValues).to.equal((@[ @1, @2, @3 ])); + + [replacement sendNext:@5]; + expect(receivedValues).to.equal((@[ @1, @2, @3, @5 ])); + }); + + it(@"should forward error from the receiver", ^{ + RACSubject *receiver = [RACSubject subject]; + __block BOOL receivedError = NO; + + [[receiver takeUntilReplacement:RACSignal.never] subscribeError:^(NSError *error) { + receivedError = YES; + }]; + + [receiver sendError:nil]; + expect(receivedError).to.beTruthy(); + }); + + it(@"should not forward completed from the receiver", ^{ + RACSubject *receiver = [RACSubject subject]; + __block BOOL receivedCompleted = NO; + + [[receiver takeUntilReplacement:RACSignal.never] subscribeCompleted: ^{ + receivedCompleted = YES; + }]; + + [receiver sendCompleted]; + expect(receivedCompleted).to.beFalsy(); + }); + + it(@"should forward error from the replacement signal", ^{ + RACSubject *replacement = [RACSubject subject]; + __block BOOL receivedError = NO; + + [[RACSignal.never takeUntilReplacement:replacement] subscribeError:^(NSError *error) { + receivedError = YES; + }]; + + [replacement sendError:nil]; + expect(receivedError).to.beTruthy(); + }); + + it(@"should forward completed from the replacement signal", ^{ + RACSubject *replacement = [RACSubject subject]; + __block BOOL receivedCompleted = NO; + + [[RACSignal.never takeUntilReplacement:replacement] subscribeCompleted: ^{ + receivedCompleted = YES; + }]; + + [replacement sendCompleted]; + expect(receivedCompleted).to.beTruthy(); + }); + + it(@"should not forward values from the receiver if both send synchronously", ^{ + RACSignal *receiver = [RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) { + [subscriber sendNext:@1]; + [subscriber sendNext:@2]; + [subscriber sendNext:@3]; + return nil; + }]; + RACSignal *replacement = [RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) { + [subscriber sendNext:@4]; + [subscriber sendNext:@5]; + [subscriber sendNext:@6]; + return nil; + }]; + + NSMutableArray *receivedValues = [NSMutableArray array]; + + [[receiver takeUntilReplacement:replacement] subscribeNext:^(id x) { + [receivedValues addObject:x]; + }]; + + expect(receivedValues).to.equal((@[ @4, @5, @6 ])); + }); + + it(@"should dispose of the receiver when it's disposed of", ^{ + __block BOOL receiverDisposed = NO; + RACSignal *receiver = [RACSignal createSignal:^(id<RACSubscriber> subscriber) { + return [RACDisposable disposableWithBlock:^{ + receiverDisposed = YES; + }]; + }]; + + [[[receiver takeUntilReplacement:RACSignal.never] subscribeCompleted:^{}] dispose]; + + expect(receiverDisposed).to.beTruthy(); + }); + + it(@"should dispose of the replacement signal when it's disposed of", ^{ + __block BOOL replacementDisposed = NO; + RACSignal *replacement = [RACSignal createSignal:^(id<RACSubscriber> subscriber) { + return [RACDisposable disposableWithBlock:^{ + replacementDisposed = YES; + }]; + }]; + + [[[RACSignal.never takeUntilReplacement:replacement] subscribeCompleted:^{}] dispose]; + + expect(replacementDisposed).to.beTruthy(); + }); + + it(@"should dispose of the receiver when the replacement signal sends an event", ^{ + __block BOOL receiverDisposed = NO; + RACSignal *receiver = [RACSignal createSignal:^(id<RACSubscriber> subscriber) { + return [RACDisposable disposableWithBlock:^{ + receiverDisposed = YES; + }]; + }]; + RACSubject *replacement = [RACSubject subject]; + + [[receiver takeUntilReplacement:replacement] subscribeCompleted:^{}]; + + expect(receiverDisposed).to.beFalsy(); + + [replacement sendNext:nil]; + + expect(receiverDisposed).to.beTruthy(); + }); +}); + +describe(@"disposal", ^{ + it(@"should dispose of the didSubscribe disposable", ^{ + __block BOOL innerDisposed = NO; + RACSignal *signal = [RACSignal createSignal:^(id<RACSubscriber> subscriber) { + return [RACDisposable disposableWithBlock:^{ + innerDisposed = YES; + }]; + }]; + + expect(innerDisposed).to.beFalsy(); + + RACDisposable *disposable = [signal subscribeNext:^(id x) {}]; + expect(disposable).notTo.beNil(); + + [disposable dispose]; + expect(innerDisposed).to.beTruthy(); + }); + + it(@"should dispose of the didSubscribe disposable asynchronously", ^{ + __block BOOL innerDisposed = NO; + RACSignal *signal = [RACSignal createSignal:^(id<RACSubscriber> subscriber) { + return [RACDisposable disposableWithBlock:^{ + innerDisposed = YES; + }]; + }]; + + [[RACScheduler scheduler] schedule:^{ + RACDisposable *disposable = [signal subscribeNext:^(id x) {}]; + [disposable dispose]; + }]; + + expect(innerDisposed).will.beTruthy(); + }); +}); + +describe(@"querying", ^{ + __block RACSignal *signal = nil; + id nextValueSent = @"1"; + + beforeEach(^{ + signal = [RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) { + [subscriber sendNext:nextValueSent]; + [subscriber sendNext:@"other value"]; + [subscriber sendCompleted]; + return nil; + }]; + }); + + it(@"should return first 'next' value with -firstOrDefault:success:error:", ^{ + RACSignal *signal = [RACSignal createSignal:^ id (id<RACSubscriber> subscriber) { + [subscriber sendNext:@1]; + [subscriber sendNext:@2]; + [subscriber sendNext:@3]; + [subscriber sendCompleted]; + return nil; + }]; + + expect(signal).notTo.beNil(); + + __block BOOL success = NO; + __block NSError *error = nil; + expect([signal firstOrDefault:@5 success:&success error:&error]).to.equal(@1); + expect(success).to.beTruthy(); + expect(error).to.beNil(); + }); + + it(@"should return first default value with -firstOrDefault:success:error:", ^{ + RACSignal *signal = [RACSignal createSignal:^ id (id<RACSubscriber> subscriber) { + [subscriber sendCompleted]; + return nil; + }]; + + expect(signal).notTo.beNil(); + + __block BOOL success = NO; + __block NSError *error = nil; + expect([signal firstOrDefault:@5 success:&success error:&error]).to.equal(@5); + expect(success).to.beTruthy(); + expect(error).to.beNil(); + }); + + it(@"should return error with -firstOrDefault:success:error:", ^{ + RACSignal *signal = [RACSignal createSignal:^ id (id<RACSubscriber> subscriber) { + [subscriber sendError:RACSignalTestError]; + return nil; + }]; + + expect(signal).notTo.beNil(); + + __block BOOL success = NO; + __block NSError *error = nil; + expect([signal firstOrDefault:@5 success:&success error:&error]).to.equal(@5); + expect(success).to.beFalsy(); + expect(error).to.equal(RACSignalTestError); + }); + + it(@"shouldn't crash when returning an error from a background scheduler", ^{ + RACSignal *signal = [RACSignal createSignal:^ id (id<RACSubscriber> subscriber) { + [[RACScheduler scheduler] schedule:^{ + [subscriber sendError:RACSignalTestError]; + }]; + + return nil; + }]; + + expect(signal).notTo.beNil(); + + __block BOOL success = NO; + __block NSError *error = nil; + expect([signal firstOrDefault:@5 success:&success error:&error]).to.equal(@5); + expect(success).to.beFalsy(); + expect(error).to.equal(RACSignalTestError); + }); + + it(@"should terminate the subscription after returning from -firstOrDefault:success:error:", ^{ + __block BOOL disposed = NO; + RACSignal *signal = [RACSignal createSignal:^(id<RACSubscriber> subscriber) { + [subscriber sendNext:RACUnit.defaultUnit]; + + return [RACDisposable disposableWithBlock:^{ + disposed = YES; + }]; + }]; + + expect(signal).notTo.beNil(); + expect(disposed).to.beFalsy(); + + expect([signal firstOrDefault:nil success:NULL error:NULL]).to.equal(RACUnit.defaultUnit); + expect(disposed).to.beTruthy(); + }); + + it(@"should return YES from -waitUntilCompleted: when successful", ^{ + RACSignal *signal = [RACSignal createSignal:^ id (id<RACSubscriber> subscriber) { + [subscriber sendNext:RACUnit.defaultUnit]; + [subscriber sendCompleted]; + return nil; + }]; + + __block NSError *error = nil; + expect([signal waitUntilCompleted:&error]).to.beTruthy(); + expect(error).to.beNil(); + }); + + it(@"should return NO from -waitUntilCompleted: upon error", ^{ + RACSignal *signal = [RACSignal createSignal:^ id (id<RACSubscriber> subscriber) { + [subscriber sendNext:RACUnit.defaultUnit]; + [subscriber sendError:RACSignalTestError]; + return nil; + }]; + + __block NSError *error = nil; + expect([signal waitUntilCompleted:&error]).to.beFalsy(); + expect(error).to.equal(RACSignalTestError); + }); + + it(@"should return a delayed value from -asynchronousFirstOrDefault:success:error:", ^{ + RACSignal *signal = [[RACSignal return:RACUnit.defaultUnit] delay:0]; + + __block BOOL scheduledBlockRan = NO; + [RACScheduler.mainThreadScheduler schedule:^{ + scheduledBlockRan = YES; + }]; + + expect(scheduledBlockRan).to.beFalsy(); + + BOOL success = NO; + NSError *error = nil; + id value = [signal asynchronousFirstOrDefault:nil success:&success error:&error]; + + expect(scheduledBlockRan).to.beTruthy(); + + expect(value).to.equal(RACUnit.defaultUnit); + expect(success).to.beTruthy(); + expect(error).to.beNil(); + }); + + it(@"should return a default value from -asynchronousFirstOrDefault:success:error:", ^{ + RACSignal *signal = [[RACSignal error:RACSignalTestError] delay:0]; + + __block BOOL scheduledBlockRan = NO; + [RACScheduler.mainThreadScheduler schedule:^{ + scheduledBlockRan = YES; + }]; + + expect(scheduledBlockRan).to.beFalsy(); + + BOOL success = NO; + NSError *error = nil; + id value = [signal asynchronousFirstOrDefault:RACUnit.defaultUnit success:&success error:&error]; + + expect(scheduledBlockRan).to.beTruthy(); + + expect(value).to.equal(RACUnit.defaultUnit); + expect(success).to.beFalsy(); + expect(error).to.equal(RACSignalTestError); + }); + + it(@"should return a delayed error from -asynchronousFirstOrDefault:success:error:", ^{ + RACSignal *signal = [[RACSignal + createSignal:^(id<RACSubscriber> subscriber) { + return [[RACScheduler scheduler] schedule:^{ + [subscriber sendError:RACSignalTestError]; + }]; + }] + deliverOn:RACScheduler.mainThreadScheduler]; + + __block NSError *error = nil; + __block BOOL success = NO; + expect([signal asynchronousFirstOrDefault:nil success:&success error:&error]).to.beNil(); + + expect(success).to.beFalsy(); + expect(error).to.equal(RACSignalTestError); + }); + + it(@"should terminate the subscription after returning from -asynchronousFirstOrDefault:success:error:", ^{ + __block BOOL disposed = NO; + RACSignal *signal = [RACSignal createSignal:^(id<RACSubscriber> subscriber) { + [[RACScheduler scheduler] schedule:^{ + [subscriber sendNext:RACUnit.defaultUnit]; + }]; + + return [RACDisposable disposableWithBlock:^{ + disposed = YES; + }]; + }]; + + expect(signal).notTo.beNil(); + expect(disposed).to.beFalsy(); + + expect([signal asynchronousFirstOrDefault:nil success:NULL error:NULL]).to.equal(RACUnit.defaultUnit); + expect(disposed).will.beTruthy(); + }); + + it(@"should return a delayed success from -asynchronouslyWaitUntilCompleted:", ^{ + RACSignal *signal = [[RACSignal return:RACUnit.defaultUnit] delay:0]; + + __block BOOL scheduledBlockRan = NO; + [RACScheduler.mainThreadScheduler schedule:^{ + scheduledBlockRan = YES; + }]; + + expect(scheduledBlockRan).to.beFalsy(); + + NSError *error = nil; + BOOL success = [signal asynchronouslyWaitUntilCompleted:&error]; + + expect(scheduledBlockRan).to.beTruthy(); + + expect(success).to.beTruthy(); + expect(error).to.beNil(); + }); +}); + +describe(@"continuation", ^{ + it(@"should repeat after completion", ^{ + __block NSUInteger numberOfSubscriptions = 0; + RACScheduler *scheduler = [RACScheduler scheduler]; + + RACSignal *signal = [RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) { + return [scheduler schedule:^{ + if (numberOfSubscriptions == 3) { + [subscriber sendError:RACSignalTestError]; + return; + } + + numberOfSubscriptions++; + + [subscriber sendNext:@"1"]; + [subscriber sendCompleted]; + [subscriber sendError:RACSignalTestError]; + }]; + }]; + + __block NSUInteger nextCount = 0; + __block BOOL gotCompleted = NO; + [[signal repeat] subscribeNext:^(id x) { + nextCount++; + } error:^(NSError *error) { + + } completed:^{ + gotCompleted = YES; + }]; + + expect(nextCount).will.equal(3); + expect(gotCompleted).to.beFalsy(); + }); + + it(@"should stop repeating when disposed", ^{ + RACSignal *signal = [RACSignal createSignal:^ id (id<RACSubscriber> subscriber) { + [subscriber sendNext:@1]; + [subscriber sendCompleted]; + return nil; + }]; + + NSMutableArray *values = [NSMutableArray array]; + + __block BOOL completed = NO; + __block RACDisposable *disposable = [[signal repeat] subscribeNext:^(id x) { + [values addObject:x]; + [disposable dispose]; + } completed:^{ + completed = YES; + }]; + + expect(values).will.equal(@[ @1 ]); + expect(completed).to.beFalsy(); + }); + + it(@"should stop repeating when disposed by -take:", ^{ + RACSignal *signal = [RACSignal createSignal:^ id (id<RACSubscriber> subscriber) { + [subscriber sendNext:@1]; + [subscriber sendCompleted]; + return nil; + }]; + + NSMutableArray *values = [NSMutableArray array]; + + __block BOOL completed = NO; + [[[signal repeat] take:1] subscribeNext:^(id x) { + [values addObject:x]; + } completed:^{ + completed = YES; + }]; + + expect(values).will.equal(@[ @1 ]); + expect(completed).to.beTruthy(); + }); +}); + +describe(@"+combineLatestWith:", ^{ + __block RACSubject *subject1 = nil; + __block RACSubject *subject2 = nil; + __block RACSignal *combined = nil; + + beforeEach(^{ + subject1 = [RACSubject subject]; + subject2 = [RACSubject subject]; + combined = [RACSignal combineLatest:@[ subject1, subject2 ]]; + }); + + it(@"should send next only once both signals send next", ^{ + __block RACTuple *tuple; + + [combined subscribeNext:^(id x) { + tuple = x; + }]; + + expect(tuple).to.beNil(); + + [subject1 sendNext:@"1"]; + expect(tuple).to.beNil(); + + [subject2 sendNext:@"2"]; + expect(tuple).to.equal(RACTuplePack(@"1", @"2")); + }); + + it(@"should send nexts when either signal sends multiple times", ^{ + NSMutableArray *results = [NSMutableArray array]; + [combined subscribeNext:^(id x) { + [results addObject:x]; + }]; + + [subject1 sendNext:@"1"]; + [subject2 sendNext:@"2"]; + + [subject1 sendNext:@"3"]; + [subject2 sendNext:@"4"]; + + expect(results[0]).to.equal(RACTuplePack(@"1", @"2")); + expect(results[1]).to.equal(RACTuplePack(@"3", @"2")); + expect(results[2]).to.equal(RACTuplePack(@"3", @"4")); + }); + + it(@"should complete when only both signals complete", ^{ + __block BOOL completed = NO; + + [combined subscribeCompleted:^{ + completed = YES; + }]; + + expect(completed).to.beFalsy(); + + [subject1 sendCompleted]; + expect(completed).to.beFalsy(); + + [subject2 sendCompleted]; + expect(completed).to.beTruthy(); + }); + + it(@"should error when either signal errors", ^{ + __block NSError *receivedError = nil; + [combined subscribeError:^(NSError *error) { + receivedError = error; + }]; + + [subject1 sendError:RACSignalTestError]; + expect(receivedError).to.equal(RACSignalTestError); + }); + + it(@"shouldn't create a retain cycle", ^{ + __block BOOL subjectDeallocd = NO; + __block BOOL signalDeallocd = NO; + + @autoreleasepool { + RACSubject *subject __attribute__((objc_precise_lifetime)) = [RACSubject subject]; + [subject.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + subjectDeallocd = YES; + }]]; + + RACSignal *signal __attribute__((objc_precise_lifetime)) = [RACSignal combineLatest:@[ subject ]]; + [signal.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + signalDeallocd = YES; + }]]; + + [signal subscribeCompleted:^{}]; + [subject sendCompleted]; + } + + expect(subjectDeallocd).will.beTruthy(); + expect(signalDeallocd).will.beTruthy(); + }); + + it(@"should combine the same signal", ^{ + RACSignal *combined = [subject1 combineLatestWith:subject1]; + + __block RACTuple *tuple; + [combined subscribeNext:^(id x) { + tuple = x; + }]; + + [subject1 sendNext:@"foo"]; + expect(tuple).to.equal(RACTuplePack(@"foo", @"foo")); + + [subject1 sendNext:@"bar"]; + expect(tuple).to.equal(RACTuplePack(@"bar", @"bar")); + }); + + it(@"should combine the same side-effecting signal", ^{ + __block NSUInteger counter = 0; + RACSignal *sideEffectingSignal = [RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) { + [subscriber sendNext:@(++counter)]; + [subscriber sendCompleted]; + return nil; + }]; + + RACSignal *combined = [sideEffectingSignal combineLatestWith:sideEffectingSignal]; + expect(counter).to.equal(0); + + NSMutableArray *receivedValues = [NSMutableArray array]; + [combined subscribeNext:^(id x) { + [receivedValues addObject:x]; + }]; + + expect(counter).to.equal(2); + + NSArray *expected = @[ RACTuplePack(@1, @2) ]; + expect(receivedValues).to.equal(expected); + }); +}); + +describe(@"+combineLatest:", ^{ + it(@"should return tuples even when only combining one signal", ^{ + RACSubject *subject = [RACSubject subject]; + + __block RACTuple *tuple; + [[RACSignal combineLatest:@[ subject ]] subscribeNext:^(id x) { + tuple = x; + }]; + + [subject sendNext:@"foo"]; + expect(tuple).to.equal(RACTuplePack(@"foo")); + }); + + it(@"should complete immediately when not given any signals", ^{ + RACSignal *signal = [RACSignal combineLatest:@[]]; + + __block BOOL completed = NO; + [signal subscribeCompleted:^{ + completed = YES; + }]; + + expect(completed).to.beTruthy(); + }); + + it(@"should only complete after all its signals complete", ^{ + RACSubject *subject1 = [RACSubject subject]; + RACSubject *subject2 = [RACSubject subject]; + RACSubject *subject3 = [RACSubject subject]; + RACSignal *combined = [RACSignal combineLatest:@[ subject1, subject2, subject3 ]]; + + __block BOOL completed = NO; + [combined subscribeCompleted:^{ + completed = YES; + }]; + + expect(completed).to.beFalsy(); + + [subject1 sendCompleted]; + expect(completed).to.beFalsy(); + + [subject2 sendCompleted]; + expect(completed).to.beFalsy(); + + [subject3 sendCompleted]; + expect(completed).to.beTruthy(); + }); +}); + +describe(@"+combineLatest:reduce:", ^{ + __block RACSubject *subject1; + __block RACSubject *subject2; + __block RACSubject *subject3; + + beforeEach(^{ + subject1 = [RACSubject subject]; + subject2 = [RACSubject subject]; + subject3 = [RACSubject subject]; + }); + + it(@"should send nils for nil values", ^{ + __block id receivedVal1; + __block id receivedVal2; + __block id receivedVal3; + + RACSignal *combined = [RACSignal combineLatest:@[ subject1, subject2, subject3 ] reduce:^ id (id val1, id val2, id val3) { + receivedVal1 = val1; + receivedVal2 = val2; + receivedVal3 = val3; + return nil; + }]; + + __block BOOL gotValue = NO; + [combined subscribeNext:^(id x) { + gotValue = YES; + }]; + + [subject1 sendNext:nil]; + [subject2 sendNext:nil]; + [subject3 sendNext:nil]; + + expect(gotValue).to.beTruthy(); + expect(receivedVal1).to.beNil(); + expect(receivedVal2).to.beNil(); + expect(receivedVal3).to.beNil(); + }); + + it(@"should send the return result of the reduce block", ^{ + RACSignal *combined = [RACSignal combineLatest:@[ subject1, subject2, subject3 ] reduce:^(NSString *string1, NSString *string2, NSString *string3) { + return [NSString stringWithFormat:@"%@: %@%@", string1, string2, string3]; + }]; + + __block id received; + [combined subscribeNext:^(id x) { + received = x; + }]; + + [subject1 sendNext:@"hello"]; + [subject2 sendNext:@"world"]; + [subject3 sendNext:@"!!1"]; + + expect(received).to.equal(@"hello: world!!1"); + }); + + it(@"should handle multiples of the same signals", ^{ + RACSignal *combined = [RACSignal combineLatest:@[ subject1, subject2, subject1, subject3 ] reduce:^(NSString *string1, NSString *string2, NSString *string3, NSString *string4) { + return [NSString stringWithFormat:@"%@ : %@ = %@ : %@", string1, string2, string3, string4]; + }]; + + NSMutableArray *receivedValues = NSMutableArray.array; + + [combined subscribeNext:^(id x) { + [receivedValues addObject:x]; + }]; + + [subject1 sendNext:@"apples"]; + expect(receivedValues.lastObject).to.beNil(); + + [subject2 sendNext:@"oranges"]; + expect(receivedValues.lastObject).to.beNil(); + + [subject3 sendNext:@"cattle"]; + expect(receivedValues.lastObject).to.equal(@"apples : oranges = apples : cattle"); + + [subject1 sendNext:@"horses"]; + expect(receivedValues.lastObject).to.equal(@"horses : oranges = horses : cattle"); + }); + + it(@"should handle multiples of the same side-effecting signal", ^{ + __block NSUInteger counter = 0; + RACSignal *sideEffectingSignal = [RACSignal createSignal:^ id (id<RACSubscriber> subscriber) { + [subscriber sendNext:@(++counter)]; + [subscriber sendCompleted]; + return nil; + }]; + + RACSignal *combined = [RACSignal combineLatest:@[ sideEffectingSignal, sideEffectingSignal, sideEffectingSignal ] reduce:^(id x, id y, id z) { + return [NSString stringWithFormat:@"%@%@%@", x, y, z]; + }]; + + NSMutableArray *receivedValues = [NSMutableArray array]; + expect(counter).to.equal(0); + + [combined subscribeNext:^(id x) { + [receivedValues addObject:x]; + }]; + + expect(counter).to.equal(3); + expect(receivedValues).to.equal(@[ @"123" ]); + }); +}); + +describe(@"distinctUntilChanged", ^{ + it(@"should only send values that are distinct from the previous value", ^{ + RACSignal *sub = [[RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) { + [subscriber sendNext:@1]; + [subscriber sendNext:@2]; + [subscriber sendNext:@2]; + [subscriber sendNext:@1]; + [subscriber sendNext:@1]; + [subscriber sendCompleted]; + return nil; + }] distinctUntilChanged]; + + NSArray *values = sub.toArray; + NSArray *expected = @[ @1, @2, @1 ]; + expect(values).to.equal(expected); + }); + + it(@"shouldn't consider nils to always be distinct", ^{ + RACSignal *sub = [[RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) { + [subscriber sendNext:@1]; + [subscriber sendNext:nil]; + [subscriber sendNext:nil]; + [subscriber sendNext:nil]; + [subscriber sendNext:@1]; + [subscriber sendCompleted]; + return nil; + }] distinctUntilChanged]; + + NSArray *values = sub.toArray; + NSArray *expected = @[ @1, [NSNull null], @1 ]; + expect(values).to.equal(expected); + }); + + it(@"should consider initial nil to be distinct", ^{ + RACSignal *sub = [[RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) { + [subscriber sendNext:nil]; + [subscriber sendNext:nil]; + [subscriber sendNext:@1]; + [subscriber sendCompleted]; + return nil; + }] distinctUntilChanged]; + + NSArray *values = sub.toArray; + NSArray *expected = @[ [NSNull null], @1 ]; + expect(values).to.equal(expected); + }); +}); + +describe(@"RACObserve", ^{ + __block RACTestObject *testObject; + + beforeEach(^{ + testObject = [[RACTestObject alloc] init]; + }); + + it(@"should work with object properties", ^{ + NSArray *expected = @[ @"hello", @"world" ]; + testObject.objectValue = expected[0]; + + NSMutableArray *valuesReceived = [NSMutableArray array]; + [RACObserve(testObject, objectValue) subscribeNext:^(id x) { + [valuesReceived addObject:x]; + }]; + + testObject.objectValue = expected[1]; + + expect(valuesReceived).to.equal(expected); + }); + + it(@"should work with non-object properties", ^{ + NSArray *expected = @[ @42, @43 ]; + testObject.integerValue = [expected[0] integerValue]; + + NSMutableArray *valuesReceived = [NSMutableArray array]; + [RACObserve(testObject, integerValue) subscribeNext:^(id x) { + [valuesReceived addObject:x]; + }]; + + testObject.integerValue = [expected[1] integerValue]; + + expect(valuesReceived).to.equal(expected); + }); + + it(@"should read the initial value upon subscription", ^{ + testObject.objectValue = @"foo"; + + RACSignal *signal = RACObserve(testObject, objectValue); + testObject.objectValue = @"bar"; + + expect([signal first]).to.equal(@"bar"); + }); +}); + +describe(@"-setKeyPath:onObject:", ^{ + id setupBlock = ^(RACTestObject *testObject, NSString *keyPath, id nilValue, RACSignal *signal) { + [signal setKeyPath:keyPath onObject:testObject nilValue:nilValue]; + }; + + itShouldBehaveLike(RACPropertySignalExamples, ^{ + return @{ RACPropertySignalExamplesSetupBlock: setupBlock }; + }); + + it(@"shouldn't send values to dealloc'd objects", ^{ + RACSubject *subject = [RACSubject subject]; + @autoreleasepool { + RACTestObject *testObject __attribute__((objc_precise_lifetime)) = [[RACTestObject alloc] init]; + [subject setKeyPath:@keypath(testObject.objectValue) onObject:testObject]; + expect(testObject.objectValue).to.beNil(); + + [subject sendNext:@1]; + expect(testObject.objectValue).to.equal(@1); + + [subject sendNext:@2]; + expect(testObject.objectValue).to.equal(@2); + } + + // This shouldn't do anything. + [subject sendNext:@3]; + }); + + it(@"should allow a new derivation after the signal's completed", ^{ + RACSubject *subject1 = [RACSubject subject]; + RACTestObject *testObject = [[RACTestObject alloc] init]; + [subject1 setKeyPath:@keypath(testObject.objectValue) onObject:testObject]; + [subject1 sendCompleted]; + + RACSubject *subject2 = [RACSubject subject]; + // This will assert if the previous completion didn't dispose of the + // subscription. + [subject2 setKeyPath:@keypath(testObject.objectValue) onObject:testObject]; + }); + + it(@"should set the given value when nil is received", ^{ + RACSubject *subject = [RACSubject subject]; + RACTestObject *testObject = [[RACTestObject alloc] init]; + [subject setKeyPath:@keypath(testObject.integerValue) onObject:testObject nilValue:@5]; + + [subject sendNext:@1]; + expect(testObject.integerValue).to.equal(1); + + [subject sendNext:nil]; + expect(testObject.integerValue).to.equal(5); + + [subject sendCompleted]; + expect(testObject.integerValue).to.equal(5); + }); + + it(@"should keep object alive over -sendNext:", ^{ + RACSubject *subject = [RACSubject subject]; + __block RACTestObject *testObject = [[RACTestObject alloc] init]; + __block id deallocValue; + + __unsafe_unretained RACTestObject *unsafeTestObject = testObject; + [testObject.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + deallocValue = unsafeTestObject.slowObjectValue; + }]]; + + [subject setKeyPath:@keypath(testObject.slowObjectValue) onObject:testObject]; + expect(testObject.slowObjectValue).to.beNil(); + + // Attempt to deallocate concurrently. + [[RACScheduler scheduler] afterDelay:0.01 schedule:^{ + testObject = nil; + }]; + + expect(deallocValue).to.beNil(); + [subject sendNext:@1]; + expect(deallocValue).to.equal(@1); + }); +}); + +describe(@"memory management", ^{ + it(@"should dealloc signals if the signal does nothing", ^{ + __block BOOL deallocd = NO; + @autoreleasepool { + RACSignal *signal __attribute__((objc_precise_lifetime)) = [RACSignal createSignal:^ id (id<RACSubscriber> subscriber) { + return nil; + }]; + + [signal.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + deallocd = YES; + }]]; + } + + expect(deallocd).will.beTruthy(); + }); + + it(@"should retain signals for a single run loop iteration", ^{ + __block BOOL deallocd = NO; + + @autoreleasepool { + RACSignal *signal __attribute__((objc_precise_lifetime)) = [RACSignal createSignal:^ id (id<RACSubscriber> subscriber) { + return nil; + }]; + + [signal.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + deallocd = YES; + }]]; + } + + expect(deallocd).to.beFalsy(); + expect(deallocd).will.beTruthy(); + }); + + it(@"should dealloc signals if the signal immediately completes", ^{ + __block BOOL deallocd = NO; + @autoreleasepool { + __block BOOL done = NO; + + RACSignal *signal __attribute__((objc_precise_lifetime)) = [RACSignal createSignal:^ id (id<RACSubscriber> subscriber) { + [subscriber sendCompleted]; + return nil; + }]; + + [signal.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + deallocd = YES; + }]]; + + [signal subscribeCompleted:^{ + done = YES; + }]; + + expect(done).will.beTruthy(); + } + + expect(deallocd).will.beTruthy(); + }); + + it(@"should dealloc a replay subject if it completes immediately", ^{ + __block BOOL completed = NO; + __block BOOL deallocd = NO; + @autoreleasepool { + RACReplaySubject *subject __attribute__((objc_precise_lifetime)) = [RACReplaySubject subject]; + [subject sendCompleted]; + + [subject.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + deallocd = YES; + }]]; + + [subject subscribeCompleted:^{ + completed = YES; + }]; + } + + expect(completed).will.beTruthy(); + + expect(deallocd).will.beTruthy(); + }); + + it(@"should dealloc if the signal was created on a background queue", ^{ + __block BOOL completed = NO; + __block BOOL deallocd = NO; + @autoreleasepool { + [[RACScheduler scheduler] schedule:^{ + RACSignal *signal __attribute__((objc_precise_lifetime)) = [RACSignal createSignal:^ id (id<RACSubscriber> subscriber) { + [subscriber sendCompleted]; + return nil; + }]; + + [signal.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + deallocd = YES; + }]]; + + [signal subscribeCompleted:^{ + completed = YES; + }]; + }]; + } + + expect(completed).will.beTruthy(); + + expect(deallocd).will.beTruthy(); + }); + + it(@"should dealloc if the signal was created on a background queue, never gets any subscribers, and the background queue gets delayed", ^{ + __block BOOL deallocd = NO; + @autoreleasepool { + [[RACScheduler scheduler] schedule:^{ + RACSignal *signal __attribute__((objc_precise_lifetime)) = [RACSignal createSignal:^ id (id<RACSubscriber> subscriber) { + return nil; + }]; + + [signal.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + deallocd = YES; + }]]; + + [NSThread sleepForTimeInterval:1]; + + expect(deallocd).to.beFalsy(); + }]; + } + + // The default test timeout is 1s so we'd race to see if the queue delay + // or default timeout happens first. To avoid that, just bump the + // timeout slightly for this test. + NSTimeInterval originalTestTimeout = Expecta.asynchronousTestTimeout; + Expecta.asynchronousTestTimeout = 1.1f; + expect(deallocd).will.beTruthy(); + Expecta.asynchronousTestTimeout = originalTestTimeout; + }); + + it(@"should retain signals when subscribing", ^{ + __block BOOL deallocd = NO; + + RACDisposable *disposable; + @autoreleasepool { + @autoreleasepool { + @autoreleasepool { + RACSignal *signal __attribute__((objc_precise_lifetime)) = [RACSignal createSignal:^ id (id<RACSubscriber> subscriber) { + return nil; + }]; + + [signal.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + deallocd = YES; + }]]; + + disposable = [signal subscribeCompleted:^{}]; + } + + // Spin the run loop to account for RAC magic that retains the + // signal for a single iteration. + [NSRunLoop.mainRunLoop runMode:NSDefaultRunLoopMode beforeDate:[NSDate date]]; + } + + expect(deallocd).to.beFalsy(); + + [disposable dispose]; + } + expect(deallocd).will.beTruthy(); + }); + + it(@"should retain intermediate signals when subscribing", ^{ + RACSubject *subject = [RACSubject subject]; + expect(subject).notTo.beNil(); + + __block BOOL gotNext = NO; + __block BOOL completed = NO; + + RACDisposable *disposable; + + @autoreleasepool { + @autoreleasepool { + RACSignal *intermediateSignal = [subject doNext:^(id _) { + gotNext = YES; + }]; + + expect(intermediateSignal).notTo.beNil(); + + disposable = [intermediateSignal subscribeCompleted:^{ + completed = YES; + }]; + } + + // Spin the run loop to account for RAC magic that retains the + // signal for a single iteration. + [NSRunLoop.mainRunLoop runMode:NSDefaultRunLoopMode beforeDate:[NSDate date]]; + } + + [subject sendNext:@5]; + expect(gotNext).to.beTruthy(); + + [subject sendCompleted]; + expect(completed).to.beTruthy(); + + [disposable dispose]; + }); +}); + +describe(@"-merge:", ^{ + __block RACSubject *sub1; + __block RACSubject *sub2; + __block RACSignal *merged; + beforeEach(^{ + sub1 = [RACSubject subject]; + sub2 = [RACSubject subject]; + merged = [sub1 merge:sub2]; + }); + + it(@"should send all values from both signals", ^{ + NSMutableArray *values = [NSMutableArray array]; + [merged subscribeNext:^(id x) { + [values addObject:x]; + }]; + + [sub1 sendNext:@1]; + [sub2 sendNext:@2]; + [sub2 sendNext:@3]; + [sub1 sendNext:@4]; + + NSArray *expected = @[ @1, @2, @3, @4 ]; + expect(values).to.equal(expected); + }); + + it(@"should send an error if one occurs", ^{ + __block NSError *errorReceived; + [merged subscribeError:^(NSError *error) { + errorReceived = error; + }]; + + [sub1 sendError:RACSignalTestError]; + expect(errorReceived).to.equal(RACSignalTestError); + }); + + it(@"should complete only after both signals complete", ^{ + NSMutableArray *values = [NSMutableArray array]; + __block BOOL completed = NO; + [merged subscribeNext:^(id x) { + [values addObject:x]; + } completed:^{ + completed = YES; + }]; + + [sub1 sendNext:@1]; + [sub2 sendNext:@2]; + [sub2 sendNext:@3]; + [sub2 sendCompleted]; + expect(completed).to.beFalsy(); + + [sub1 sendNext:@4]; + [sub1 sendCompleted]; + expect(completed).to.beTruthy(); + + NSArray *expected = @[ @1, @2, @3, @4 ]; + expect(values).to.equal(expected); + }); + + it(@"should complete only after both signals complete for any number of subscribers", ^{ + __block BOOL completed1 = NO; + __block BOOL completed2 = NO; + [merged subscribeCompleted:^{ + completed1 = YES; + }]; + + [merged subscribeCompleted:^{ + completed2 = YES; + }]; + + expect(completed1).to.beFalsy(); + expect(completed2).to.beFalsy(); + + [sub1 sendCompleted]; + [sub2 sendCompleted]; + expect(completed1).to.beTruthy(); + expect(completed2).to.beTruthy(); + }); +}); + +describe(@"+merge:", ^{ + __block RACSubject *sub1; + __block RACSubject *sub2; + __block RACSignal *merged; + beforeEach(^{ + sub1 = [RACSubject subject]; + sub2 = [RACSubject subject]; + merged = [RACSignal merge:@[ sub1, sub2 ].objectEnumerator]; + }); + + it(@"should send all values from both signals", ^{ + NSMutableArray *values = [NSMutableArray array]; + [merged subscribeNext:^(id x) { + [values addObject:x]; + }]; + + [sub1 sendNext:@1]; + [sub2 sendNext:@2]; + [sub2 sendNext:@3]; + [sub1 sendNext:@4]; + + NSArray *expected = @[ @1, @2, @3, @4 ]; + expect(values).to.equal(expected); + }); + + it(@"should send an error if one occurs", ^{ + __block NSError *errorReceived; + [merged subscribeError:^(NSError *error) { + errorReceived = error; + }]; + + [sub1 sendError:RACSignalTestError]; + expect(errorReceived).to.equal(RACSignalTestError); + }); + + it(@"should complete only after both signals complete", ^{ + NSMutableArray *values = [NSMutableArray array]; + __block BOOL completed = NO; + [merged subscribeNext:^(id x) { + [values addObject:x]; + } completed:^{ + completed = YES; + }]; + + [sub1 sendNext:@1]; + [sub2 sendNext:@2]; + [sub2 sendNext:@3]; + [sub2 sendCompleted]; + expect(completed).to.beFalsy(); + + [sub1 sendNext:@4]; + [sub1 sendCompleted]; + expect(completed).to.beTruthy(); + + NSArray *expected = @[ @1, @2, @3, @4 ]; + expect(values).to.equal(expected); + }); + + it(@"should complete immediately when not given any signals", ^{ + RACSignal *signal = [RACSignal merge:@[].objectEnumerator]; + + __block BOOL completed = NO; + [signal subscribeCompleted:^{ + completed = YES; + }]; + + expect(completed).to.beTruthy(); + }); + + it(@"should complete only after both signals complete for any number of subscribers", ^{ + __block BOOL completed1 = NO; + __block BOOL completed2 = NO; + [merged subscribeCompleted:^{ + completed1 = YES; + }]; + + [merged subscribeCompleted:^{ + completed2 = YES; + }]; + + expect(completed1).to.beFalsy(); + expect(completed2).to.beFalsy(); + + [sub1 sendCompleted]; + [sub2 sendCompleted]; + expect(completed1).to.beTruthy(); + expect(completed2).to.beTruthy(); + }); +}); + +describe(@"-flatten:", ^{ + __block BOOL subscribedTo1 = NO; + __block BOOL subscribedTo2 = NO; + __block BOOL subscribedTo3 = NO; + __block RACSignal *sub1; + __block RACSignal *sub2; + __block RACSignal *sub3; + __block RACSubject *subject1; + __block RACSubject *subject2; + __block RACSubject *subject3; + __block RACSubject *signalsSubject; + __block NSMutableArray *values; + + beforeEach(^{ + subscribedTo1 = NO; + subject1 = [RACSubject subject]; + sub1 = [RACSignal defer:^{ + subscribedTo1 = YES; + return subject1; + }]; + + subscribedTo2 = NO; + subject2 = [RACSubject subject]; + sub2 = [RACSignal defer:^{ + subscribedTo2 = YES; + return subject2; + }]; + + subscribedTo3 = NO; + subject3 = [RACSubject subject]; + sub3 = [RACSignal defer:^{ + subscribedTo3 = YES; + return subject3; + }]; + + signalsSubject = [RACSubject subject]; + + values = [NSMutableArray array]; + }); + + describe(@"when its max is 0", ^{ + it(@"should merge all the signals concurrently", ^{ + [[signalsSubject flatten:0] subscribeNext:^(id x) { + [values addObject:x]; + }]; + + expect(subscribedTo1).to.beFalsy(); + expect(subscribedTo2).to.beFalsy(); + expect(subscribedTo3).to.beFalsy(); + + [signalsSubject sendNext:sub1]; + [signalsSubject sendNext:sub2]; + + expect(subscribedTo1).to.beTruthy(); + expect(subscribedTo2).to.beTruthy(); + expect(subscribedTo3).to.beFalsy(); + + [subject1 sendNext:@1]; + + [signalsSubject sendNext:sub3]; + + expect(subscribedTo1).to.beTruthy(); + expect(subscribedTo2).to.beTruthy(); + expect(subscribedTo3).to.beTruthy(); + + [subject1 sendCompleted]; + + [subject2 sendNext:@2]; + [subject2 sendCompleted]; + + [subject3 sendNext:@3]; + [subject3 sendCompleted]; + + NSArray *expected = @[ @1, @2, @3 ]; + expect(values).to.equal(expected); + }); + + itShouldBehaveLike(RACSignalMergeConcurrentCompletionExampleGroup, @{ RACSignalMaxConcurrent: @0 }); + }); + + describe(@"when its max is > 0", ^{ + it(@"should merge only the given number at a time", ^{ + [[signalsSubject flatten:1] subscribeNext:^(id x) { + [values addObject:x]; + }]; + + expect(subscribedTo1).to.beFalsy(); + expect(subscribedTo2).to.beFalsy(); + expect(subscribedTo3).to.beFalsy(); + + [signalsSubject sendNext:sub1]; + [signalsSubject sendNext:sub2]; + + expect(subscribedTo1).to.beTruthy(); + expect(subscribedTo2).to.beFalsy(); + expect(subscribedTo3).to.beFalsy(); + + [subject1 sendNext:@1]; + + [signalsSubject sendNext:sub3]; + + expect(subscribedTo1).to.beTruthy(); + expect(subscribedTo2).to.beFalsy(); + expect(subscribedTo3).to.beFalsy(); + + [signalsSubject sendCompleted]; + + expect(subscribedTo1).to.beTruthy(); + expect(subscribedTo2).to.beFalsy(); + expect(subscribedTo3).to.beFalsy(); + + [subject1 sendCompleted]; + + expect(subscribedTo2).to.beTruthy(); + expect(subscribedTo3).to.beFalsy(); + + [subject2 sendNext:@2]; + [subject2 sendCompleted]; + + expect(subscribedTo3).to.beTruthy(); + + [subject3 sendNext:@3]; + [subject3 sendCompleted]; + + NSArray *expected = @[ @1, @2, @3 ]; + expect(values).to.equal(expected); + }); + + itShouldBehaveLike(RACSignalMergeConcurrentCompletionExampleGroup, @{ RACSignalMaxConcurrent: @1 }); + }); + + it(@"shouldn't create a retain cycle", ^{ + __block BOOL subjectDeallocd = NO; + __block BOOL signalDeallocd = NO; + @autoreleasepool { + RACSubject *subject __attribute__((objc_precise_lifetime)) = [RACSubject subject]; + [subject.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + subjectDeallocd = YES; + }]]; + + RACSignal *signal __attribute__((objc_precise_lifetime)) = [subject flatten]; + [signal.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + signalDeallocd = YES; + }]]; + + [signal subscribeCompleted:^{}]; + + [subject sendCompleted]; + } + + expect(subjectDeallocd).will.beTruthy(); + expect(signalDeallocd).will.beTruthy(); + }); + + it(@"should not crash when disposing while subscribing", ^{ + RACDisposable *disposable = [[signalsSubject flatten:0] subscribeCompleted:^{ + }]; + + [signalsSubject sendNext:[RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) { + [disposable dispose]; + [subscriber sendCompleted]; + return nil; + }]]; + + [signalsSubject sendCompleted]; + }); + + it(@"should dispose after last synchronous signal subscription and should not crash", ^{ + + RACSignal *flattened = [signalsSubject flatten:1]; + RACDisposable *flattenDisposable = [flattened subscribeCompleted:^{}]; + + RACSignal *syncSignal = [RACSignal createSignal:^ RACDisposable *(id<RACSubscriber> subscriber) { + expect(flattenDisposable.disposed).to.beFalsy(); + [subscriber sendCompleted]; + expect(flattenDisposable.disposed).to.beTruthy(); + return nil; + }]; + + RACSignal *asyncSignal = [sub1 delay:0]; + + [signalsSubject sendNext:asyncSignal]; + [signalsSubject sendNext:syncSignal]; + + [signalsSubject sendCompleted]; + + [subject1 sendCompleted]; + + expect(flattenDisposable.disposed).will.beTruthy(); + }); + + it(@"should not crash when disposed because of takeUntil:", ^{ + for (int i = 0; i < 100; i++) { + RACSubject *flattenedReceiver = [RACSubject subject]; + RACSignal *done = [flattenedReceiver map:^(NSNumber *n) { + return @(n.integerValue == 1); + }]; + + RACSignal *flattened = [signalsSubject flatten:1]; + + RACDisposable *flattenDisposable = [[flattened takeUntil:[done ignore:@NO]] subscribe:flattenedReceiver]; + + RACSignal *syncSignal = [RACSignal createSignal:^ RACDisposable *(id<RACSubscriber> subscriber) { + expect(flattenDisposable.disposed).to.beFalsy(); + [subscriber sendNext:@1]; + expect(flattenDisposable.disposed).to.beTruthy(); + [subscriber sendCompleted]; + return nil; + }]; + + RACSignal *asyncSignal = [sub1 delay:0]; + [subject1 sendNext:@0]; + + [signalsSubject sendNext:asyncSignal]; + [signalsSubject sendNext:syncSignal]; + [signalsSubject sendCompleted]; + + [subject1 sendCompleted]; + + expect(flattenDisposable.disposed).will.beTruthy(); + } + }); +}); + +describe(@"-switchToLatest", ^{ + __block RACSubject *subject; + + __block NSMutableArray *values; + __block NSError *lastError = nil; + __block BOOL completed = NO; + + beforeEach(^{ + subject = [RACSubject subject]; + + values = [NSMutableArray array]; + lastError = nil; + completed = NO; + + [[subject switchToLatest] subscribeNext:^(id x) { + expect(lastError).to.beNil(); + expect(completed).to.beFalsy(); + + [values addObject:x]; + } error:^(NSError *error) { + expect(lastError).to.beNil(); + expect(completed).to.beFalsy(); + + lastError = error; + } completed:^{ + expect(lastError).to.beNil(); + expect(completed).to.beFalsy(); + + completed = YES; + }]; + }); + + it(@"should send values from the most recent signal", ^{ + [subject sendNext:[RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) { + [subscriber sendNext:@1]; + [subscriber sendNext:@2]; + return nil; + }]]; + + [subject sendNext:[RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) { + [subscriber sendNext:@3]; + [subscriber sendNext:@4]; + return nil; + }]]; + + NSArray *expected = @[ @1, @2, @3, @4 ]; + expect(values).to.equal(expected); + }); + + it(@"should send errors from the most recent signal", ^{ + [subject sendNext:[RACSignal createSignal:^ id (id<RACSubscriber> subscriber) { + [subscriber sendError:[NSError errorWithDomain:@"" code:-1 userInfo:nil]]; + return nil; + }]]; + + expect(lastError).notTo.beNil(); + }); + + it(@"should not send completed if only the switching signal completes", ^{ + [subject sendNext:RACSignal.never]; + + expect(completed).to.beFalsy(); + + [subject sendCompleted]; + expect(completed).to.beFalsy(); + }); + + it(@"should send completed when the switching signal completes and the last sent signal does", ^{ + [subject sendNext:RACSignal.empty]; + + expect(completed).to.beFalsy(); + + [subject sendCompleted]; + expect(completed).to.beTruthy(); + }); + + it(@"should accept nil signals", ^{ + [subject sendNext:nil]; + [subject sendNext:[RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) { + [subscriber sendNext:@1]; + [subscriber sendNext:@2]; + return nil; + }]]; + + NSArray *expected = @[ @1, @2 ]; + expect(values).to.equal(expected); + }); + + it(@"should return a cold signal", ^{ + __block NSUInteger subscriptions = 0; + RACSignal *signalOfSignals = [RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) { + subscriptions++; + [subscriber sendNext:[RACSignal empty]]; + return nil; + }]; + + RACSignal *switched = [signalOfSignals switchToLatest]; + + [[switched publish] connect]; + expect(subscriptions).to.equal(1); + + [[switched publish] connect]; + expect(subscriptions).to.equal(2); + }); +}); + +describe(@"+switch:cases:default:", ^{ + __block RACSubject *keySubject; + + __block RACSubject *subjectZero; + __block RACSubject *subjectOne; + __block RACSubject *subjectTwo; + + __block RACSubject *defaultSubject; + + __block NSMutableArray *values; + __block NSError *lastError = nil; + __block BOOL completed = NO; + + beforeEach(^{ + keySubject = [RACSubject subject]; + + subjectZero = [RACSubject subject]; + subjectOne = [RACSubject subject]; + subjectTwo = [RACSubject subject]; + + defaultSubject = [RACSubject subject]; + + values = [NSMutableArray array]; + lastError = nil; + completed = NO; + }); + + describe(@"switching between values with a default", ^{ + __block RACSignal *switchSignal; + + beforeEach(^{ + switchSignal = [RACSignal switch:keySubject cases:@{ + @0: subjectZero, + @1: subjectOne, + @2: subjectTwo, + } default:[RACSignal never]]; + + [switchSignal subscribeNext:^(id x) { + expect(lastError).to.beNil(); + expect(completed).to.beFalsy(); + + [values addObject:x]; + } error:^(NSError *error) { + expect(lastError).to.beNil(); + expect(completed).to.beFalsy(); + + lastError = error; + } completed:^{ + expect(lastError).to.beNil(); + expect(completed).to.beFalsy(); + + completed = YES; + }]; + }); + + it(@"should not send any values before a key is sent", ^{ + [subjectZero sendNext:RACUnit.defaultUnit]; + [subjectOne sendNext:RACUnit.defaultUnit]; + [subjectTwo sendNext:RACUnit.defaultUnit]; + + expect(values).to.equal(@[]); + expect(lastError).to.beNil(); + expect(completed).to.beFalsy(); + }); + + it(@"should send events based on the latest key", ^{ + [keySubject sendNext:@0]; + + [subjectZero sendNext:@"zero"]; + [subjectZero sendNext:@"zero"]; + [subjectOne sendNext:@"one"]; + [subjectTwo sendNext:@"two"]; + + NSArray *expected = @[ @"zero", @"zero" ]; + expect(values).to.equal(expected); + + [keySubject sendNext:@1]; + + [subjectZero sendNext:@"zero"]; + [subjectOne sendNext:@"one"]; + [subjectTwo sendNext:@"two"]; + + expected = @[ @"zero", @"zero", @"one" ]; + expect(values).to.equal(expected); + + expect(lastError).to.beNil(); + expect(completed).to.beFalsy(); + + [keySubject sendNext:@2]; + + [subjectZero sendError:[NSError errorWithDomain:@"" code:-1 userInfo:nil]]; + [subjectOne sendError:[NSError errorWithDomain:@"" code:-1 userInfo:nil]]; + expect(lastError).to.beNil(); + + [subjectTwo sendError:[NSError errorWithDomain:@"" code:-1 userInfo:nil]]; + expect(lastError).notTo.beNil(); + }); + + it(@"should not send completed when only the key signal completes", ^{ + [keySubject sendNext:@0]; + [subjectZero sendNext:@"zero"]; + [keySubject sendCompleted]; + + expect(values).to.equal(@[ @"zero" ]); + expect(completed).to.beFalsy(); + }); + + it(@"should send completed when the key signal and the latest sent signal complete", ^{ + [keySubject sendNext:@0]; + [subjectZero sendNext:@"zero"]; + [keySubject sendCompleted]; + [subjectZero sendCompleted]; + + expect(values).to.equal(@[ @"zero" ]); + expect(completed).to.beTruthy(); + }); + }); + + it(@"should use the default signal if key that was sent does not have an associated signal", ^{ + [[RACSignal + switch:keySubject + cases:@{ + @0: subjectZero, + @1: subjectOne, + } + default:defaultSubject] + subscribeNext:^(id x) { + [values addObject:x]; + }]; + + [keySubject sendNext:@"not a valid key"]; + [defaultSubject sendNext:@"default"]; + + expect(values).to.equal(@[ @"default" ]); + + [keySubject sendNext:nil]; + [defaultSubject sendNext:@"default"]; + + expect(values).to.equal((@[ @"default", @"default" ])); + }); + + it(@"should send an error if key that was sent does not have an associated signal and there's no default", ^{ + [[RACSignal + switch:keySubject + cases:@{ + @0: subjectZero, + @1: subjectOne, + } + default:nil] + subscribeNext:^(id x) { + [values addObject:x]; + } error:^(NSError *error) { + lastError = error; + }]; + + [keySubject sendNext:@0]; + [subjectZero sendNext:@"zero"]; + + expect(values).to.equal(@[ @"zero" ]); + expect(lastError).to.beNil(); + + [keySubject sendNext:nil]; + + expect(values).to.equal(@[ @"zero" ]); + expect(lastError).notTo.beNil(); + expect(lastError.domain).to.equal(RACSignalErrorDomain); + expect(lastError.code).to.equal(RACSignalErrorNoMatchingCase); + }); + + it(@"should match RACTupleNil case when a nil value is sent", ^{ + [[RACSignal + switch:keySubject + cases:@{ + RACTupleNil.tupleNil: subjectZero, + } + default:defaultSubject] + subscribeNext:^(id x) { + [values addObject:x]; + }]; + + [keySubject sendNext:nil]; + [subjectZero sendNext:@"zero"]; + expect(values).to.equal(@[ @"zero" ]); + }); +}); + +describe(@"+if:then:else", ^{ + __block RACSubject *boolSubject; + __block RACSubject *trueSubject; + __block RACSubject *falseSubject; + + __block NSMutableArray *values; + __block NSError *lastError = nil; + __block BOOL completed = NO; + + beforeEach(^{ + boolSubject = [RACSubject subject]; + trueSubject = [RACSubject subject]; + falseSubject = [RACSubject subject]; + + values = [NSMutableArray array]; + lastError = nil; + completed = NO; + + [[RACSignal if:boolSubject then:trueSubject else:falseSubject] subscribeNext:^(id x) { + expect(lastError).to.beNil(); + expect(completed).to.beFalsy(); + + [values addObject:x]; + } error:^(NSError *error) { + expect(lastError).to.beNil(); + expect(completed).to.beFalsy(); + + lastError = error; + } completed:^{ + expect(lastError).to.beNil(); + expect(completed).to.beFalsy(); + + completed = YES; + }]; + }); + + it(@"should not send any values before a boolean is sent", ^{ + [trueSubject sendNext:RACUnit.defaultUnit]; + [falseSubject sendNext:RACUnit.defaultUnit]; + + expect(values).to.equal(@[]); + expect(lastError).to.beNil(); + expect(completed).to.beFalsy(); + }); + + it(@"should send events based on the latest boolean", ^{ + [boolSubject sendNext:@YES]; + + [trueSubject sendNext:@"foo"]; + [falseSubject sendNext:@"buzz"]; + [trueSubject sendNext:@"bar"]; + + NSArray *expected = @[ @"foo", @"bar" ]; + expect(values).to.equal(expected); + expect(lastError).to.beNil(); + expect(completed).to.beFalsy(); + + [boolSubject sendNext:@NO]; + + [trueSubject sendNext:@"baz"]; + [falseSubject sendNext:@"buzz"]; + [trueSubject sendNext:@"barfoo"]; + + expected = @[ @"foo", @"bar", @"buzz" ]; + expect(values).to.equal(expected); + expect(lastError).to.beNil(); + expect(completed).to.beFalsy(); + + [trueSubject sendError:[NSError errorWithDomain:@"" code:-1 userInfo:nil]]; + expect(lastError).to.beNil(); + + [falseSubject sendError:[NSError errorWithDomain:@"" code:-1 userInfo:nil]]; + expect(lastError).notTo.beNil(); + }); + + it(@"should not send completed when only the BOOL signal completes", ^{ + [boolSubject sendNext:@YES]; + [trueSubject sendNext:@"foo"]; + [boolSubject sendCompleted]; + + expect(values).to.equal(@[ @"foo" ]); + expect(completed).to.beFalsy(); + }); + + it(@"should send completed when the BOOL signal and the latest sent signal complete", ^{ + [boolSubject sendNext:@YES]; + [trueSubject sendNext:@"foo"]; + [trueSubject sendCompleted]; + [boolSubject sendCompleted]; + + expect(values).to.equal(@[ @"foo" ]); + expect(completed).to.beTruthy(); + }); +}); + +describe(@"+interval:onScheduler: and +interval:onScheduler:withLeeway:", ^{ + static const NSTimeInterval interval = 0.1; + static const NSTimeInterval leeway = 0.2; + + __block void (^testTimer)(RACSignal *, NSNumber *, NSNumber *) = nil; + + before(^{ + testTimer = [^(RACSignal *timer, NSNumber *minInterval, NSNumber *leeway) { + __block NSUInteger nextsReceived = 0; + + NSTimeInterval startTime = NSDate.timeIntervalSinceReferenceDate; + [[timer take:3] subscribeNext:^(NSDate *date) { + ++nextsReceived; + + NSTimeInterval currentTime = date.timeIntervalSinceReferenceDate; + + // Uniformly distribute the expected interval for all + // received values. We do this instead of saving a timestamp + // because a delayed interval may cause the _next_ value to + // send sooner than the interval. + NSTimeInterval expectedMinInterval = minInterval.doubleValue * nextsReceived; + NSTimeInterval expectedMaxInterval = expectedMinInterval + leeway.doubleValue * 3 + 0.05; + + expect(currentTime - startTime).beGreaterThanOrEqualTo(expectedMinInterval); + expect(currentTime - startTime).beLessThanOrEqualTo(expectedMaxInterval); + }]; + + expect(nextsReceived).will.equal(3); + } copy]; + }); + + describe(@"+interval:onScheduler:", ^{ + it(@"should work on the main thread scheduler", ^{ + testTimer([RACSignal interval:interval onScheduler:RACScheduler.mainThreadScheduler], @(interval), @0); + }); + + it(@"should work on a background scheduler", ^{ + testTimer([RACSignal interval:interval onScheduler:[RACScheduler scheduler]], @(interval), @0); + }); + }); + + describe(@"+interval:onScheduler:withLeeway:", ^{ + it(@"should work on the main thread scheduler", ^{ + testTimer([RACSignal interval:interval onScheduler:RACScheduler.mainThreadScheduler withLeeway:leeway], @(interval), @(leeway)); + }); + + it(@"should work on a background scheduler", ^{ + testTimer([RACSignal interval:interval onScheduler:[RACScheduler scheduler] withLeeway:leeway], @(interval), @(leeway)); + }); + }); +}); + +describe(@"-timeout:onScheduler:", ^{ + __block RACSubject *subject; + + beforeEach(^{ + subject = [RACSubject subject]; + }); + + it(@"should time out", ^{ + RACTestScheduler *scheduler = [[RACTestScheduler alloc] init]; + + __block NSError *receivedError = nil; + [[subject timeout:1 onScheduler:scheduler] subscribeError:^(NSError *e) { + receivedError = e; + }]; + + expect(receivedError).to.beNil(); + + [scheduler stepAll]; + expect(receivedError).willNot.beNil(); + expect(receivedError.domain).to.equal(RACSignalErrorDomain); + expect(receivedError.code).to.equal(RACSignalErrorTimedOut); + }); + + it(@"should pass through events while not timed out", ^{ + __block id next = nil; + __block BOOL completed = NO; + [[subject timeout:1 onScheduler:RACScheduler.mainThreadScheduler] subscribeNext:^(id x) { + next = x; + } completed:^{ + completed = YES; + }]; + + [subject sendNext:RACUnit.defaultUnit]; + expect(next).to.equal(RACUnit.defaultUnit); + + [subject sendCompleted]; + expect(completed).to.beTruthy(); + }); + + it(@"should not time out after disposal", ^{ + RACTestScheduler *scheduler = [[RACTestScheduler alloc] init]; + + __block NSError *receivedError = nil; + RACDisposable *disposable = [[subject timeout:1 onScheduler:scheduler] subscribeError:^(NSError *e) { + receivedError = e; + }]; + + [disposable dispose]; + [scheduler stepAll]; + expect(receivedError).to.beNil(); + }); +}); + +describe(@"-delay:", ^{ + __block RACSubject *subject; + __block RACSignal *delayedSignal; + + beforeEach(^{ + subject = [RACSubject subject]; + delayedSignal = [subject delay:0]; + }); + + it(@"should delay nexts", ^{ + __block id next = nil; + [delayedSignal subscribeNext:^(id x) { + next = x; + }]; + + [subject sendNext:@"foo"]; + expect(next).to.beNil(); + expect(next).will.equal(@"foo"); + }); + + it(@"should delay completed", ^{ + __block BOOL completed = NO; + [delayedSignal subscribeCompleted:^{ + completed = YES; + }]; + + [subject sendCompleted]; + expect(completed).to.beFalsy(); + expect(completed).will.beTruthy(); + }); + + it(@"should not delay errors", ^{ + __block NSError *error = nil; + [delayedSignal subscribeError:^(NSError *e) { + error = e; + }]; + + [subject sendError:RACSignalTestError]; + expect(error).to.equal(RACSignalTestError); + }); + + it(@"should cancel delayed events when disposed", ^{ + __block id next = nil; + RACDisposable *disposable = [delayedSignal subscribeNext:^(id x) { + next = x; + }]; + + [subject sendNext:@"foo"]; + + __block BOOL done = NO; + [RACScheduler.mainThreadScheduler after:[NSDate date] schedule:^{ + done = YES; + }]; + + [disposable dispose]; + + expect(done).will.beTruthy(); + expect(next).to.beNil(); + }); +}); + +describe(@"-catch:", ^{ + it(@"should subscribe to ensuing signal on error", ^{ + RACSubject *subject = [RACSubject subject]; + + RACSignal *signal = [subject catch:^(NSError *error) { + return [RACSignal return:@41]; + }]; + + __block id value = nil; + [signal subscribeNext:^(id x) { + value = x; + }]; + + [subject sendError:RACSignalTestError]; + expect(value).to.equal(@41); + }); + + it(@"should prevent source error from propagating", ^{ + RACSubject *subject = [RACSubject subject]; + + RACSignal *signal = [subject catch:^(NSError *error) { + return [RACSignal empty]; + }]; + + __block BOOL errorReceived = NO; + [signal subscribeError:^(NSError *error) { + errorReceived = YES; + }]; + + [subject sendError:RACSignalTestError]; + expect(errorReceived).to.beFalsy(); + }); + + it(@"should propagate error from ensuing signal", ^{ + RACSubject *subject = [RACSubject subject]; + + NSError *secondaryError = [NSError errorWithDomain:@"bubs" code:41 userInfo:nil]; + RACSignal *signal = [subject catch:^(NSError *error) { + return [RACSignal error:secondaryError]; + }]; + + __block NSError *errorReceived = nil; + [signal subscribeError:^(NSError *error) { + errorReceived = error; + }]; + + [subject sendError:RACSignalTestError]; + expect(errorReceived).to.equal(secondaryError); + }); + + it(@"should dispose ensuing signal", ^{ + RACSubject *subject = [RACSubject subject]; + + __block BOOL disposed = NO; + RACSignal *signal = [subject catch:^(NSError *error) { + return [RACSignal createSignal:^(id<RACSubscriber> subscriber) { + return [RACDisposable disposableWithBlock:^{ + disposed = YES; + }]; + }]; + }]; + + RACDisposable *disposable = [signal subscribeCompleted:^{}]; + [subject sendError:RACSignalTestError]; + [disposable dispose]; + + expect(disposed).will.beTruthy(); + }); +}); + +describe(@"-try:", ^{ + __block RACSubject *subject; + __block NSError *receivedError; + __block NSMutableArray *nextValues; + __block BOOL completed; + + beforeEach(^{ + subject = [RACSubject subject]; + nextValues = [NSMutableArray array]; + completed = NO; + receivedError = nil; + + [[subject try:^(NSString *value, NSError **error) { + if (value != nil) return YES; + + if (error != nil) *error = RACSignalTestError; + + return NO; + }] subscribeNext:^(id x) { + [nextValues addObject:x]; + } error:^(NSError *error) { + receivedError = error; + } completed:^{ + completed = YES; + }]; + }); + + it(@"should pass values while YES is returned from the tryBlock", ^{ + [subject sendNext:@"foo"]; + [subject sendNext:@"bar"]; + [subject sendNext:@"baz"]; + [subject sendNext:@"buzz"]; + [subject sendCompleted]; + + NSArray *receivedValues = [nextValues copy]; + NSArray *expectedValues = @[ @"foo", @"bar", @"baz", @"buzz" ]; + + expect(receivedError).to.beNil(); + expect(receivedValues).to.equal(expectedValues); + expect(completed).to.beTruthy(); + }); + + it(@"should pass values until NO is returned from the tryBlock", ^{ + [subject sendNext:@"foo"]; + [subject sendNext:@"bar"]; + [subject sendNext:nil]; + [subject sendNext:@"buzz"]; + [subject sendCompleted]; + + NSArray *receivedValues = [nextValues copy]; + NSArray *expectedValues = @[ @"foo", @"bar" ]; + + expect(receivedError).to.equal(RACSignalTestError); + expect(receivedValues).to.equal(expectedValues); + expect(completed).to.beFalsy(); + }); +}); + +describe(@"-tryMap:", ^{ + __block RACSubject *subject; + __block NSError *receivedError; + __block NSMutableArray *nextValues; + __block BOOL completed; + + beforeEach(^{ + subject = [RACSubject subject]; + nextValues = [NSMutableArray array]; + completed = NO; + receivedError = nil; + + [[subject tryMap:^ id (NSString *value, NSError **error) { + if (value != nil) return [NSString stringWithFormat:@"%@_a", value]; + + if (error != nil) *error = RACSignalTestError; + + return nil; + }] subscribeNext:^(id x) { + [nextValues addObject:x]; + } error:^(NSError *error) { + receivedError = error; + } completed:^{ + completed = YES; + }]; + }); + + it(@"should map values with the mapBlock", ^{ + [subject sendNext:@"foo"]; + [subject sendNext:@"bar"]; + [subject sendNext:@"baz"]; + [subject sendNext:@"buzz"]; + [subject sendCompleted]; + + NSArray *receivedValues = [nextValues copy]; + NSArray *expectedValues = @[ @"foo_a", @"bar_a", @"baz_a", @"buzz_a" ]; + + expect(receivedError).to.beNil(); + expect(receivedValues).to.equal(expectedValues); + expect(completed).to.beTruthy(); + }); + + it(@"should map values with the mapBlock, until the mapBlock returns nil", ^{ + [subject sendNext:@"foo"]; + [subject sendNext:@"bar"]; + [subject sendNext:nil]; + [subject sendNext:@"buzz"]; + [subject sendCompleted]; + + NSArray *receivedValues = [nextValues copy]; + NSArray *expectedValues = @[ @"foo_a", @"bar_a" ]; + + expect(receivedError).to.equal(RACSignalTestError); + expect(receivedValues).to.equal(expectedValues); + expect(completed).to.beFalsy(); + }); +}); + +describe(@"throttling", ^{ + __block RACSubject *subject; + + beforeEach(^{ + subject = [RACSubject subject]; + }); + + describe(@"-throttle:", ^{ + __block RACSignal *throttledSignal; + + beforeEach(^{ + throttledSignal = [subject throttle:0]; + }); + + it(@"should throttle nexts", ^{ + NSMutableArray *valuesReceived = [NSMutableArray array]; + [throttledSignal subscribeNext:^(id x) { + [valuesReceived addObject:x]; + }]; + + [subject sendNext:@"foo"]; + [subject sendNext:@"bar"]; + expect(valuesReceived).to.equal(@[]); + + NSArray *expected = @[ @"bar" ]; + expect(valuesReceived).will.equal(expected); + + [subject sendNext:@"buzz"]; + expect(valuesReceived).to.equal(expected); + + expected = @[ @"bar", @"buzz" ]; + expect(valuesReceived).will.equal(expected); + }); + + it(@"should forward completed immediately", ^{ + __block BOOL completed = NO; + [throttledSignal subscribeCompleted:^{ + completed = YES; + }]; + + [subject sendCompleted]; + expect(completed).to.beTruthy(); + }); + + it(@"should forward errors immediately", ^{ + __block NSError *error = nil; + [throttledSignal subscribeError:^(NSError *e) { + error = e; + }]; + + [subject sendError:RACSignalTestError]; + expect(error).to.equal(RACSignalTestError); + }); + + it(@"should cancel future nexts when disposed", ^{ + __block id next = nil; + RACDisposable *disposable = [throttledSignal subscribeNext:^(id x) { + next = x; + }]; + + [subject sendNext:@"foo"]; + + __block BOOL done = NO; + [RACScheduler.mainThreadScheduler after:[NSDate date] schedule:^{ + done = YES; + }]; + + [disposable dispose]; + + expect(done).will.beTruthy(); + expect(next).to.beNil(); + }); + }); + + describe(@"-throttle:valuesPassingTest:", ^{ + __block RACSignal *throttledSignal; + __block BOOL shouldThrottle; + + beforeEach(^{ + shouldThrottle = YES; + + __block id value = nil; + throttledSignal = [[subject + doNext:^(id x) { + value = x; + }] + throttle:0 valuesPassingTest:^(id x) { + // Make sure that we're given the latest value. + expect(x).to.beIdenticalTo(value); + + return shouldThrottle; + }]; + + expect(throttledSignal).notTo.beNil(); + }); + + describe(@"nexts", ^{ + __block NSMutableArray *valuesReceived; + __block NSMutableArray *expected; + + beforeEach(^{ + expected = [[NSMutableArray alloc] init]; + valuesReceived = [[NSMutableArray alloc] init]; + + [throttledSignal subscribeNext:^(id x) { + [valuesReceived addObject:x]; + }]; + }); + + it(@"should forward unthrottled values immediately", ^{ + shouldThrottle = NO; + [subject sendNext:@"foo"]; + + [expected addObject:@"foo"]; + expect(valuesReceived).to.equal(expected); + }); + + it(@"should delay throttled values", ^{ + [subject sendNext:@"bar"]; + expect(valuesReceived).to.equal(expected); + + [expected addObject:@"bar"]; + expect(valuesReceived).will.equal(expected); + }); + + it(@"should drop buffered values when a throttled value arrives", ^{ + [subject sendNext:@"foo"]; + [subject sendNext:@"bar"]; + [subject sendNext:@"buzz"]; + expect(valuesReceived).to.equal(expected); + + [expected addObject:@"buzz"]; + expect(valuesReceived).will.equal(expected); + }); + + it(@"should drop buffered values when an immediate value arrives", ^{ + [subject sendNext:@"foo"]; + [subject sendNext:@"bar"]; + + shouldThrottle = NO; + [subject sendNext:@"buzz"]; + [expected addObject:@"buzz"]; + expect(valuesReceived).to.equal(expected); + + // Make sure that nothing weird happens when sending another + // throttled value. + shouldThrottle = YES; + [subject sendNext:@"baz"]; + expect(valuesReceived).to.equal(expected); + + [expected addObject:@"baz"]; + expect(valuesReceived).will.equal(expected); + }); + + it(@"should not be resent upon completion", ^{ + [subject sendNext:@"bar"]; + [expected addObject:@"bar"]; + expect(valuesReceived).will.equal(expected); + + [subject sendCompleted]; + expect(valuesReceived).to.equal(expected); + }); + }); + + it(@"should forward completed immediately", ^{ + __block BOOL completed = NO; + [throttledSignal subscribeCompleted:^{ + completed = YES; + }]; + + [subject sendCompleted]; + expect(completed).to.beTruthy(); + }); + + it(@"should forward errors immediately", ^{ + __block NSError *error = nil; + [throttledSignal subscribeError:^(NSError *e) { + error = e; + }]; + + [subject sendError:RACSignalTestError]; + expect(error).to.equal(RACSignalTestError); + }); + + it(@"should cancel future nexts when disposed", ^{ + __block id next = nil; + RACDisposable *disposable = [throttledSignal subscribeNext:^(id x) { + next = x; + }]; + + [subject sendNext:@"foo"]; + + __block BOOL done = NO; + [RACScheduler.mainThreadScheduler after:[NSDate date] schedule:^{ + done = YES; + }]; + + [disposable dispose]; + + expect(done).will.beTruthy(); + expect(next).to.beNil(); + }); + }); +}); + +describe(@"-then:", ^{ + it(@"should continue onto returned signal", ^{ + RACSubject *subject = [RACSubject subject]; + + __block id value = nil; + [[subject then:^{ + return [RACSignal return:@2]; + }] subscribeNext:^(id x) { + value = x; + }]; + + [subject sendNext:@1]; + + // The value shouldn't change until the first signal completes. + expect(value).to.beNil(); + + [subject sendCompleted]; + + expect(value).to.equal(@2); + }); + + it(@"should sequence even if no next value is sent", ^{ + RACSubject *subject = [RACSubject subject]; + + __block id value = nil; + [[subject then:^{ + return [RACSignal return:RACUnit.defaultUnit]; + }] subscribeNext:^(id x) { + value = x; + }]; + + [subject sendCompleted]; + + expect(value).to.equal(RACUnit.defaultUnit); + }); +}); + +describe(@"-sequence", ^{ + RACSignal *signal = [RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) { + [subscriber sendNext:@1]; + [subscriber sendNext:@2]; + [subscriber sendNext:@3]; + [subscriber sendNext:@4]; + [subscriber sendCompleted]; + return nil; + }]; + + itShouldBehaveLike(RACSequenceExamples, ^{ + return @{ + RACSequenceExampleSequence: signal.sequence, + RACSequenceExampleExpectedValues: @[ @1, @2, @3, @4 ] + }; + }); +}); + +it(@"should complete take: even if the original signal doesn't", ^{ + RACSignal *sendOne = [RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) { + [subscriber sendNext:RACUnit.defaultUnit]; + return nil; + }]; + + __block id value = nil; + __block BOOL completed = NO; + [[sendOne take:1] subscribeNext:^(id received) { + value = received; + } completed:^{ + completed = YES; + }]; + + expect(value).to.equal(RACUnit.defaultUnit); + expect(completed).to.beTruthy(); +}); + +describe(@"+zip:", ^{ + __block RACSubject *subject1 = nil; + __block RACSubject *subject2 = nil; + __block BOOL hasSentError = NO; + __block BOOL hasSentCompleted = NO; + __block RACDisposable *disposable = nil; + __block void (^send2NextAndErrorTo1)(void) = nil; + __block void (^send3NextAndErrorTo1)(void) = nil; + __block void (^send2NextAndCompletedTo2)(void) = nil; + __block void (^send3NextAndCompletedTo2)(void) = nil; + + before(^{ + send2NextAndErrorTo1 = [^{ + [subject1 sendNext:@1]; + [subject1 sendNext:@2]; + [subject1 sendError:RACSignalTestError]; + } copy]; + send3NextAndErrorTo1 = [^{ + [subject1 sendNext:@1]; + [subject1 sendNext:@2]; + [subject1 sendNext:@3]; + [subject1 sendError:RACSignalTestError]; + } copy]; + send2NextAndCompletedTo2 = [^{ + [subject2 sendNext:@1]; + [subject2 sendNext:@2]; + [subject2 sendCompleted]; + } copy]; + send3NextAndCompletedTo2 = [^{ + [subject2 sendNext:@1]; + [subject2 sendNext:@2]; + [subject2 sendNext:@3]; + [subject2 sendCompleted]; + } copy]; + subject1 = [RACSubject subject]; + subject2 = [RACSubject subject]; + hasSentError = NO; + hasSentCompleted = NO; + disposable = [[RACSignal zip:@[ subject1, subject2 ]] subscribeError:^(NSError *error) { + hasSentError = YES; + } completed:^{ + hasSentCompleted = YES; + }]; + }); + + after(^{ + [disposable dispose]; + }); + + it(@"should complete as soon as no new zipped values are possible", ^{ + [subject1 sendNext:@1]; + [subject2 sendNext:@1]; + expect(hasSentCompleted).to.beFalsy(); + + [subject1 sendNext:@2]; + [subject1 sendCompleted]; + expect(hasSentCompleted).to.beFalsy(); + + [subject2 sendNext:@2]; + expect(hasSentCompleted).to.beTruthy(); + }); + + it(@"outcome should not be dependent on order of signals", ^{ + [subject2 sendCompleted]; + expect(hasSentCompleted).to.beTruthy(); + }); + + it(@"should forward errors sent earlier than (time-wise) and before (position-wise) a complete", ^{ + send2NextAndErrorTo1(); + send3NextAndCompletedTo2(); + expect(hasSentError).to.beTruthy(); + expect(hasSentCompleted).to.beFalsy(); + }); + + it(@"should forward errors sent earlier than (time-wise) and after (position-wise) a complete", ^{ + send3NextAndErrorTo1(); + send2NextAndCompletedTo2(); + expect(hasSentError).to.beTruthy(); + expect(hasSentCompleted).to.beFalsy(); + }); + + it(@"should forward errors sent later than (time-wise) and before (position-wise) a complete", ^{ + send3NextAndCompletedTo2(); + send2NextAndErrorTo1(); + expect(hasSentError).to.beTruthy(); + expect(hasSentCompleted).to.beFalsy(); + }); + + it(@"should ignore errors sent later than (time-wise) and after (position-wise) a complete", ^{ + send2NextAndCompletedTo2(); + send3NextAndErrorTo1(); + expect(hasSentError).to.beFalsy(); + expect(hasSentCompleted).to.beTruthy(); + }); + + it(@"should handle signals sending values unevenly", ^{ + __block NSError *receivedError = nil; + __block BOOL hasCompleted = NO; + + RACSubject *a = [RACSubject subject]; + RACSubject *b = [RACSubject subject]; + RACSubject *c = [RACSubject subject]; + + NSMutableArray *receivedValues = NSMutableArray.array; + NSArray *expectedValues = nil; + + [[RACSignal zip:@[ a, b, c ] reduce:^(NSNumber *a, NSNumber *b, NSNumber *c) { + return [NSString stringWithFormat:@"%@%@%@", a, b, c]; + }] subscribeNext:^(id x) { + [receivedValues addObject:x]; + } error:^(NSError *error) { + receivedError = error; + } completed:^{ + hasCompleted = YES; + }]; + + [a sendNext:@1]; + [a sendNext:@2]; + [a sendNext:@3]; + + [b sendNext:@1]; + + [c sendNext:@1]; + [c sendNext:@2]; + + // a: [===......] + // b: [=........] + // c: [==.......] + + expectedValues = @[ @"111" ]; + expect(receivedValues).to.equal(expectedValues); + expect(receivedError).to.beNil(); + expect(hasCompleted).to.beFalsy(); + + [b sendNext:@2]; + [b sendNext:@3]; + [b sendNext:@4]; + [b sendCompleted]; + + // a: [===......] + // b: [====C....] + // c: [==.......] + + expectedValues = @[ @"111", @"222" ]; + expect(receivedValues).to.equal(expectedValues); + expect(receivedError).to.beNil(); + expect(hasCompleted).to.beFalsy(); + + [c sendNext:@3]; + [c sendNext:@4]; + [c sendNext:@5]; + [c sendError:RACSignalTestError]; + + // a: [===......] + // b: [====C....] + // c: [=====E...] + + expectedValues = @[ @"111", @"222", @"333" ]; + expect(receivedValues).to.equal(expectedValues); + expect(receivedError).to.equal(RACSignalTestError); + expect(hasCompleted).to.beFalsy(); + + [a sendNext:@4]; + [a sendNext:@5]; + [a sendNext:@6]; + [a sendNext:@7]; + + // a: [=======..] + // b: [====C....] + // c: [=====E...] + + expectedValues = @[ @"111", @"222", @"333" ]; + expect(receivedValues).to.equal(expectedValues); + expect(receivedError).to.equal(RACSignalTestError); + expect(hasCompleted).to.beFalsy(); + }); + + it(@"should handle multiples of the same side-effecting signal", ^{ + __block NSUInteger counter = 0; + RACSignal *sideEffectingSignal = [RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) { + ++counter; + [subscriber sendNext:@1]; + [subscriber sendCompleted]; + return nil; + }]; + RACSignal *combined = [RACSignal zip:@[ sideEffectingSignal, sideEffectingSignal ] reduce:^ NSString * (id x, id y) { + return [NSString stringWithFormat:@"%@%@", x, y]; + }]; + NSMutableArray *receivedValues = NSMutableArray.array; + + expect(counter).to.equal(0); + + [combined subscribeNext:^(id x) { + [receivedValues addObject:x]; + }]; + + expect(counter).to.equal(2); + expect(receivedValues).to.equal(@[ @"11" ]); + }); +}); + +describe(@"-sample:", ^{ + it(@"should send the latest value when the sampler signal fires", ^{ + RACSubject *subject = [RACSubject subject]; + RACSubject *sampleSubject = [RACSubject subject]; + RACSignal *sampled = [subject sample:sampleSubject]; + NSMutableArray *values = [NSMutableArray array]; + [sampled subscribeNext:^(id x) { + [values addObject:x]; + }]; + + [sampleSubject sendNext:RACUnit.defaultUnit]; + expect(values).to.equal(@[]); + + [subject sendNext:@1]; + [subject sendNext:@2]; + expect(values).to.equal(@[]); + + [sampleSubject sendNext:RACUnit.defaultUnit]; + NSArray *expected = @[ @2 ]; + expect(values).to.equal(expected); + + [subject sendNext:@3]; + expect(values).to.equal(expected); + + [sampleSubject sendNext:RACUnit.defaultUnit]; + expected = @[ @2, @3 ]; + expect(values).to.equal(expected); + + [sampleSubject sendNext:RACUnit.defaultUnit]; + expected = @[ @2, @3, @3 ]; + expect(values).to.equal(expected); + }); +}); + +describe(@"-collect", ^{ + __block RACSubject *subject; + __block RACSignal *collected; + + __block id value; + __block BOOL hasCompleted; + + beforeEach(^{ + subject = [RACSubject subject]; + collected = [subject collect]; + + value = nil; + hasCompleted = NO; + + [collected subscribeNext:^(id x) { + value = x; + } completed:^{ + hasCompleted = YES; + }]; + }); + + it(@"should send a single array when the original signal completes", ^{ + NSArray *expected = @[ @1, @2, @3 ]; + + [subject sendNext:@1]; + [subject sendNext:@2]; + [subject sendNext:@3]; + expect(value).to.beNil(); + + [subject sendCompleted]; + expect(value).to.equal(expected); + expect(hasCompleted).to.beTruthy(); + }); + + it(@"should add NSNull to an array for nil values", ^{ + NSArray *expected = @[ NSNull.null, @1, NSNull.null ]; + + [subject sendNext:nil]; + [subject sendNext:@1]; + [subject sendNext:nil]; + expect(value).to.beNil(); + + [subject sendCompleted]; + expect(value).to.equal(expected); + expect(hasCompleted).to.beTruthy(); + }); +}); + +describe(@"-bufferWithTime:", ^{ + __block RACTestScheduler *scheduler; + + __block RACSubject *input; + __block RACSignal *bufferedInput; + __block RACTuple *latestValue; + + beforeEach(^{ + scheduler = [[RACTestScheduler alloc] init]; + + input = [RACSubject subject]; + bufferedInput = [input bufferWithTime:1 onScheduler:scheduler]; + latestValue = nil; + + [bufferedInput subscribeNext:^(RACTuple *x) { + latestValue = x; + }]; + }); + + it(@"should buffer nexts", ^{ + [input sendNext:@1]; + [input sendNext:@2]; + + [scheduler stepAll]; + expect(latestValue).to.equal(RACTuplePack(@1, @2)); + + [input sendNext:@3]; + [input sendNext:@4]; + + [scheduler stepAll]; + expect(latestValue).to.equal(RACTuplePack(@3, @4)); + }); + + it(@"should not perform buffering until a value is sent", ^{ + [input sendNext:@1]; + [input sendNext:@2]; + [scheduler stepAll]; + expect(latestValue).to.equal(RACTuplePack(@1, @2)); + + [scheduler stepAll]; + expect(latestValue).to.equal(RACTuplePack(@1, @2)); + + [input sendNext:@3]; + [input sendNext:@4]; + [scheduler stepAll]; + expect(latestValue).to.equal(RACTuplePack(@3, @4)); + }); + + it(@"should flush any buffered nexts upon completion", ^{ + [input sendNext:@1]; + [input sendCompleted]; + [scheduler stepAll]; + expect(latestValue).to.equal(RACTuplePack(@1)); + }); + + it(@"should support NSNull values", ^{ + [input sendNext:NSNull.null]; + [scheduler stepAll]; + expect(latestValue).to.equal(RACTuplePack(NSNull.null)); + }); + + it(@"should buffer nil values", ^{ + [input sendNext:nil]; + [scheduler stepAll]; + expect(latestValue).to.equal(RACTuplePack(nil)); + }); +}); + +describe(@"-concat", ^{ + __block RACSubject *subject; + + __block RACSignal *oneSignal; + __block RACSignal *twoSignal; + __block RACSignal *threeSignal; + + __block RACSignal *errorSignal; + __block RACSignal *completedSignal; + + beforeEach(^{ + subject = [RACReplaySubject subject]; + + oneSignal = [RACSignal return:@1]; + twoSignal = [RACSignal return:@2]; + threeSignal = [RACSignal return:@3]; + + errorSignal = [RACSignal error:RACSignalTestError]; + completedSignal = RACSignal.empty; + }); + + it(@"should concatenate the values of inner signals", ^{ + [subject sendNext:oneSignal]; + [subject sendNext:twoSignal]; + [subject sendNext:completedSignal]; + [subject sendNext:threeSignal]; + + NSMutableArray *values = [NSMutableArray array]; + [[subject concat] subscribeNext:^(id x) { + [values addObject:x]; + }]; + + NSArray *expected = @[ @1, @2, @3 ]; + expect(values).to.equal(expected); + }); + + it(@"should complete only after all signals complete", ^{ + RACReplaySubject *valuesSubject = [RACReplaySubject subject]; + + [subject sendNext:valuesSubject]; + [subject sendCompleted]; + + [valuesSubject sendNext:@1]; + [valuesSubject sendNext:@2]; + [valuesSubject sendCompleted]; + + NSArray *expected = @[ @1, @2 ]; + expect([[subject concat] toArray]).to.equal(expected); + }); + + it(@"should pass through errors", ^{ + [subject sendNext:errorSignal]; + + NSError *error = nil; + [[subject concat] firstOrDefault:nil success:NULL error:&error]; + expect(error).to.equal(RACSignalTestError); + }); + + it(@"should concat signals sent later", ^{ + [subject sendNext:oneSignal]; + + NSMutableArray *values = [NSMutableArray array]; + [[subject concat] subscribeNext:^(id x) { + [values addObject:x]; + }]; + + NSArray *expected = @[ @1 ]; + expect(values).to.equal(expected); + + [subject sendNext:[twoSignal delay:0]]; + + expected = @[ @1, @2 ]; + expect(values).will.equal(expected); + + [subject sendNext:threeSignal]; + + expected = @[ @1, @2, @3 ]; + expect(values).to.equal(expected); + }); + + it(@"should dispose the current signal", ^{ + __block BOOL disposed = NO; + RACSignal *innerSignal = [RACSignal createSignal:^(id<RACSubscriber> subscriber) { + return [RACDisposable disposableWithBlock:^{ + disposed = YES; + }]; + }]; + + RACDisposable *concatDisposable = [[subject concat] subscribeCompleted:^{}]; + + [subject sendNext:innerSignal]; + expect(disposed).notTo.beTruthy(); + + [concatDisposable dispose]; + expect(disposed).to.beTruthy(); + }); + + it(@"should dispose later signals", ^{ + __block BOOL disposed = NO; + RACSignal *laterSignal = [RACSignal createSignal:^(id<RACSubscriber> subscriber) { + return [RACDisposable disposableWithBlock:^{ + disposed = YES; + }]; + }]; + + RACSubject *firstSignal = [RACSubject subject]; + RACSignal *outerSignal = [RACSignal createSignal:^ id (id<RACSubscriber> subscriber) { + [subscriber sendNext:firstSignal]; + [subscriber sendNext:laterSignal]; + return nil; + }]; + + RACDisposable *concatDisposable = [[outerSignal concat] subscribeCompleted:^{}]; + + [firstSignal sendCompleted]; + expect(disposed).notTo.beTruthy(); + + [concatDisposable dispose]; + expect(disposed).to.beTruthy(); + }); +}); + +describe(@"-initially:", ^{ + __block RACSubject *subject; + + __block NSUInteger initiallyInvokedCount; + __block RACSignal *signal; + + beforeEach(^{ + subject = [RACSubject subject]; + + initiallyInvokedCount = 0; + signal = [subject initially:^{ + ++initiallyInvokedCount; + }]; + }); + + it(@"should not run without a subscription", ^{ + [subject sendCompleted]; + expect(initiallyInvokedCount).to.equal(0); + }); + + it(@"should run on subscription", ^{ + [signal subscribe:[RACSubscriber new]]; + expect(initiallyInvokedCount).to.equal(1); + }); + + it(@"should re-run for each subscription", ^{ + [signal subscribe:[RACSubscriber new]]; + [signal subscribe:[RACSubscriber new]]; + expect(initiallyInvokedCount).to.equal(2); + }); +}); + +describe(@"-finally:", ^{ + __block RACSubject *subject; + + __block BOOL finallyInvoked; + __block RACSignal *signal; + + beforeEach(^{ + subject = [RACSubject subject]; + + finallyInvoked = NO; + signal = [subject finally:^{ + finallyInvoked = YES; + }]; + }); + + it(@"should not run finally without a subscription", ^{ + [subject sendCompleted]; + expect(finallyInvoked).to.beFalsy(); + }); + + describe(@"with a subscription", ^{ + __block RACDisposable *disposable; + + beforeEach(^{ + disposable = [signal subscribeCompleted:^{}]; + }); + + afterEach(^{ + [disposable dispose]; + }); + + it(@"should not run finally upon next", ^{ + [subject sendNext:RACUnit.defaultUnit]; + expect(finallyInvoked).to.beFalsy(); + }); + + it(@"should run finally upon completed", ^{ + [subject sendCompleted]; + expect(finallyInvoked).to.beTruthy(); + }); + + it(@"should run finally upon error", ^{ + [subject sendError:nil]; + expect(finallyInvoked).to.beTruthy(); + }); + }); +}); + +describe(@"-ignoreValues", ^{ + __block RACSubject *subject; + + __block BOOL gotNext; + __block BOOL gotCompleted; + __block NSError *receivedError; + + beforeEach(^{ + subject = [RACSubject subject]; + + gotNext = NO; + gotCompleted = NO; + receivedError = nil; + + [[subject ignoreValues] subscribeNext:^(id _) { + gotNext = YES; + } error:^(NSError *error) { + receivedError = error; + } completed:^{ + gotCompleted = YES; + }]; + }); + + it(@"should skip nexts and pass through completed", ^{ + [subject sendNext:RACUnit.defaultUnit]; + [subject sendCompleted]; + + expect(gotNext).to.beFalsy(); + expect(gotCompleted).to.beTruthy(); + expect(receivedError).to.beNil(); + }); + + it(@"should skip nexts and pass through errors", ^{ + [subject sendNext:RACUnit.defaultUnit]; + [subject sendError:RACSignalTestError]; + + expect(gotNext).to.beFalsy(); + expect(gotCompleted).to.beFalsy(); + expect(receivedError).to.equal(RACSignalTestError); + }); +}); + +describe(@"-materialize", ^{ + it(@"should convert nexts and completed into RACEvents", ^{ + NSArray *events = [[[RACSignal return:RACUnit.defaultUnit] materialize] toArray]; + NSArray *expected = @[ + [RACEvent eventWithValue:RACUnit.defaultUnit], + RACEvent.completedEvent + ]; + + expect(events).to.equal(expected); + }); + + it(@"should convert errors into RACEvents and complete", ^{ + NSArray *events = [[[RACSignal error:RACSignalTestError] materialize] toArray]; + NSArray *expected = @[ [RACEvent eventWithError:RACSignalTestError] ]; + expect(events).to.equal(expected); + }); +}); + +describe(@"-dematerialize", ^{ + it(@"should convert nexts from RACEvents", ^{ + RACSignal *events = [RACSignal createSignal:^ id (id<RACSubscriber> subscriber) { + [subscriber sendNext:[RACEvent eventWithValue:@1]]; + [subscriber sendNext:[RACEvent eventWithValue:@2]]; + [subscriber sendCompleted]; + return nil; + }]; + + NSArray *expected = @[ @1, @2 ]; + expect([[events dematerialize] toArray]).to.equal(expected); + }); + + it(@"should convert completed from a RACEvent", ^{ + RACSignal *events = [RACSignal createSignal:^ id (id<RACSubscriber> subscriber) { + [subscriber sendNext:[RACEvent eventWithValue:@1]]; + [subscriber sendNext:RACEvent.completedEvent]; + [subscriber sendNext:[RACEvent eventWithValue:@2]]; + [subscriber sendCompleted]; + return nil; + }]; + + NSArray *expected = @[ @1 ]; + expect([[events dematerialize] toArray]).to.equal(expected); + }); + + it(@"should convert error from a RACEvent", ^{ + RACSignal *events = [RACSignal createSignal:^ id (id<RACSubscriber> subscriber) { + [subscriber sendNext:[RACEvent eventWithError:RACSignalTestError]]; + [subscriber sendNext:[RACEvent eventWithValue:@1]]; + [subscriber sendCompleted]; + return nil; + }]; + + __block NSError *error = nil; + expect([[events dematerialize] firstOrDefault:nil success:NULL error:&error]).to.beNil(); + expect(error).to.equal(RACSignalTestError); + }); +}); + +describe(@"-not", ^{ + it(@"should invert every BOOL sent", ^{ + RACSubject *subject = [RACReplaySubject subject]; + [subject sendNext:@NO]; + [subject sendNext:@YES]; + [subject sendCompleted]; + NSArray *results = [[subject not] toArray]; + NSArray *expected = @[ @YES, @NO ]; + expect(results).to.equal(expected); + }); +}); + +describe(@"-and", ^{ + it(@"should return YES if all YES values are sent", ^{ + RACSubject *subject = [RACReplaySubject subject]; + + [subject sendNext:RACTuplePack(@YES, @NO, @YES)]; + [subject sendNext:RACTuplePack(@NO, @NO, @NO)]; + [subject sendNext:RACTuplePack(@YES, @YES, @YES)]; + [subject sendCompleted]; + + NSArray *results = [[subject and] toArray]; + NSArray *expected = @[ @NO, @NO, @YES ]; + + expect(results).to.equal(expected); + }); +}); + +describe(@"-or", ^{ + it(@"should return YES for any YES values sent", ^{ + RACSubject *subject = [RACReplaySubject subject]; + + [subject sendNext:RACTuplePack(@YES, @NO, @YES)]; + [subject sendNext:RACTuplePack(@NO, @NO, @NO)]; + [subject sendCompleted]; + + NSArray *results = [[subject or] toArray]; + NSArray *expected = @[ @YES, @NO ]; + + expect(results).to.equal(expected); + }); +}); + +describe(@"-groupBy:", ^{ + it(@"should send completed to all grouped signals.", ^{ + RACSubject *subject = [RACReplaySubject subject]; + + __block NSUInteger groupedSignalCount = 0; + __block NSUInteger completedGroupedSignalCount = 0; + [[subject groupBy:^(NSNumber *number) { + return @(floorf(number.floatValue)); + }] subscribeNext:^(RACGroupedSignal *groupedSignal) { + ++groupedSignalCount; + + [groupedSignal subscribeCompleted:^{ + ++completedGroupedSignalCount; + }]; + }]; + + [subject sendNext:@1]; + [subject sendNext:@2]; + [subject sendCompleted]; + + expect(completedGroupedSignalCount).to.equal(groupedSignalCount); + }); + + it(@"should send error to all grouped signals.", ^{ + RACSubject *subject = [RACReplaySubject subject]; + + __block NSUInteger groupedSignalCount = 0; + __block NSUInteger erroneousGroupedSignalCount = 0; + [[subject groupBy:^(NSNumber *number) { + return @(floorf(number.floatValue)); + }] subscribeNext:^(RACGroupedSignal *groupedSignal) { + ++groupedSignalCount; + + [groupedSignal subscribeError:^(NSError *error) { + ++erroneousGroupedSignalCount; + + expect(error.domain).to.equal(@"TestDomain"); + expect(error.code).to.equal(123); + }]; + }]; + + [subject sendNext:@1]; + [subject sendNext:@2]; + [subject sendError:[NSError errorWithDomain:@"TestDomain" code:123 userInfo:nil]]; + + expect(erroneousGroupedSignalCount).to.equal(groupedSignalCount); + }); +}); + +describe(@"starting signals", ^{ + describe(@"+startLazilyWithScheduler:block:", ^{ + itBehavesLike(RACSignalStartSharedExamplesName, ^{ + NSArray *expectedValues = @[ @42, @43 ]; + RACScheduler *scheduler = [RACScheduler scheduler]; + RACSignal *signal = [RACSignal startLazilyWithScheduler:scheduler block:^(id<RACSubscriber> subscriber) { + for (id value in expectedValues) { + [subscriber sendNext:value]; + } + [subscriber sendCompleted]; + }]; + return @{ + RACSignalStartSignal: signal, + RACSignalStartExpectedValues: expectedValues, + RACSignalStartExpectedScheduler: scheduler, + }; + }); + + __block NSUInteger invokedCount = 0; + __block void (^subscribe)(void); + + beforeEach(^{ + invokedCount = 0; + + RACSignal *signal = [RACSignal startLazilyWithScheduler:RACScheduler.immediateScheduler block:^(id<RACSubscriber> subscriber) { + invokedCount++; + [subscriber sendNext:@42]; + [subscriber sendCompleted]; + }]; + + subscribe = [^{ + [signal subscribe:[RACSubscriber subscriberWithNext:nil error:nil completed:nil]]; + } copy]; + }); + + it(@"should only invoke the block on subscription", ^{ + expect(invokedCount).to.equal(0); + subscribe(); + expect(invokedCount).to.equal(1); + }); + + it(@"should only invoke the block once", ^{ + expect(invokedCount).to.equal(0); + subscribe(); + expect(invokedCount).to.equal(1); + subscribe(); + expect(invokedCount).to.equal(1); + subscribe(); + expect(invokedCount).to.equal(1); + }); + + it(@"should invoke the block on the given scheduler", ^{ + RACScheduler *scheduler = [RACScheduler scheduler]; + __block RACScheduler *currentScheduler; + [[[RACSignal + startLazilyWithScheduler:scheduler block:^(id<RACSubscriber> subscriber) { + currentScheduler = RACScheduler.currentScheduler; + }] + publish] + connect]; + + expect(currentScheduler).will.equal(scheduler); + }); + }); + + describe(@"+startEagerlyWithScheduler:block:", ^{ + itBehavesLike(RACSignalStartSharedExamplesName, ^{ + NSArray *expectedValues = @[ @42, @43 ]; + RACScheduler *scheduler = [RACScheduler scheduler]; + RACSignal *signal = [RACSignal startEagerlyWithScheduler:scheduler block:^(id<RACSubscriber> subscriber) { + for (id value in expectedValues) { + [subscriber sendNext:value]; + } + [subscriber sendCompleted]; + }]; + return @{ + RACSignalStartSignal: signal, + RACSignalStartExpectedValues: expectedValues, + RACSignalStartExpectedScheduler: scheduler, + }; + }); + + it(@"should immediately invoke the block", ^{ + __block BOOL blockInvoked = NO; + [RACSignal startEagerlyWithScheduler:[RACScheduler scheduler] block:^(id<RACSubscriber> subscriber) { + blockInvoked = YES; + }]; + + expect(blockInvoked).will.beTruthy(); + }); + + it(@"should only invoke the block once", ^{ + __block NSUInteger invokedCount = 0; + RACSignal *signal = [RACSignal startEagerlyWithScheduler:RACScheduler.immediateScheduler block:^(id<RACSubscriber> subscriber) { + invokedCount++; + }]; + + expect(invokedCount).to.equal(1); + + [[signal publish] connect]; + expect(invokedCount).to.equal(1); + + [[signal publish] connect]; + expect(invokedCount).to.equal(1); + }); + + it(@"should invoke the block on the given scheduler", ^{ + RACScheduler *scheduler = [RACScheduler scheduler]; + __block RACScheduler *currentScheduler; + [RACSignal startEagerlyWithScheduler:scheduler block:^(id<RACSubscriber> subscriber) { + currentScheduler = RACScheduler.currentScheduler; + }]; + + expect(currentScheduler).will.equal(scheduler); + }); + }); +}); + +describe(@"-toArray", ^{ + __block RACSubject *subject; + + beforeEach(^{ + subject = [RACReplaySubject subject]; + }); + + it(@"should return an array which contains NSNulls for nil values", ^{ + NSArray *expected = @[ NSNull.null, @1, NSNull.null ]; + + [subject sendNext:nil]; + [subject sendNext:@1]; + [subject sendNext:nil]; + [subject sendCompleted]; + + expect([subject toArray]).to.equal(expected); + }); + + it(@"should return nil upon error", ^{ + [subject sendError:nil]; + expect([subject toArray]).to.beNil(); + }); + + it(@"should return nil upon error even if some nexts were sent", ^{ + [subject sendNext:@1]; + [subject sendNext:@2]; + [subject sendError:nil]; + + expect([subject toArray]).to.beNil(); + }); +}); + +describe(@"-ignore:", ^{ + it(@"should ignore nil", ^{ + RACSignal *signal = [[RACSignal + createSignal:^ id (id<RACSubscriber> subscriber) { + [subscriber sendNext:@1]; + [subscriber sendNext:nil]; + [subscriber sendNext:@3]; + [subscriber sendNext:@4]; + [subscriber sendNext:nil]; + [subscriber sendCompleted]; + return nil; + }] + ignore:nil]; + + NSArray *expected = @[ @1, @3, @4 ]; + expect([signal toArray]).to.equal(expected); + }); +}); + +describe(@"-replayLazily", ^{ + __block NSUInteger subscriptionCount; + __block BOOL disposed; + + __block RACSignal *signal; + __block RACSubject *disposeSubject; + __block RACSignal *replayedSignal; + + beforeEach(^{ + subscriptionCount = 0; + disposed = NO; + + signal = [RACSignal createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) { + subscriptionCount++; + [subscriber sendNext:RACUnit.defaultUnit]; + + RACDisposable *schedulingDisposable = [RACScheduler.mainThreadScheduler schedule:^{ + [subscriber sendNext:RACUnit.defaultUnit]; + [subscriber sendCompleted]; + }]; + + return [RACDisposable disposableWithBlock:^{ + [schedulingDisposable dispose]; + disposed = YES; + }]; + }]; + + disposeSubject = [RACSubject subject]; + replayedSignal = [[signal takeUntil:disposeSubject] replayLazily]; + }); + + it(@"should forward the input signal upon subscription", ^{ + expect(subscriptionCount).to.equal(0); + + expect([replayedSignal asynchronouslyWaitUntilCompleted:NULL]).to.beTruthy(); + expect(subscriptionCount).to.equal(1); + }); + + it(@"should replay the input signal for future subscriptions", ^{ + NSArray *events = [[[replayedSignal materialize] collect] asynchronousFirstOrDefault:nil success:NULL error:NULL]; + expect(events).notTo.beNil(); + + expect([[[replayedSignal materialize] collect] asynchronousFirstOrDefault:nil success:NULL error:NULL]).to.equal(events); + expect(subscriptionCount).to.equal(1); + }); + + it(@"should replay even after disposal", ^{ + __block NSUInteger valueCount = 0; + [replayedSignal subscribeNext:^(id x) { + valueCount++; + }]; + + [disposeSubject sendCompleted]; + expect(valueCount).to.equal(1); + expect([[replayedSignal toArray] count]).to.equal(valueCount); + }); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACSignalStartExamples.h b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSignalStartExamples.h new file mode 100644 index 0000000..3e01c36 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSignalStartExamples.h
@@ -0,0 +1,20 @@ +// +// RACSignalStartExamples.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 5/29/13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import <Foundation/Foundation.h> + +extern NSString * const RACSignalStartSharedExamplesName; + +// The signal to test, created by some +start...: variation. +extern NSString * const RACSignalStartSignal; + +// An NSArray of the values which the signal should be expected to send. +extern NSString * const RACSignalStartExpectedValues; + +// The scheduler on which the signal should be expected to send values. +extern NSString * const RACSignalStartExpectedScheduler;
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACSignalStartExamples.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSignalStartExamples.m new file mode 100644 index 0000000..6416630 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSignalStartExamples.m
@@ -0,0 +1,74 @@ +// +// RACSignalStartExamples.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 5/29/13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACSignalStartExamples.h" +#import "RACSignal.h" +#import "RACSignal+Operations.h" +#import "RACScheduler.h" +#import "RACSubscriber.h" +#import "RACMulticastConnection.h" + +NSString * const RACSignalStartSharedExamplesName = @"RACSignalStartSharedExamplesName"; + +NSString * const RACSignalStartSignal = @"RACSignalStartSignal"; +NSString * const RACSignalStartExpectedValues = @"RACSignalStartExpectedValues"; +NSString * const RACSignalStartExpectedScheduler = @"RACSignalStartExpectedScheduler"; + +SharedExampleGroupsBegin(RACSignalStartSpec) + +sharedExamples(RACSignalStartSharedExamplesName, ^(NSDictionary *data) { + __block RACSignal *signal; + __block NSArray *expectedValues; + __block RACScheduler *scheduler; + __block RACScheduler * (^subscribeAndGetScheduler)(void); + + beforeEach(^{ + signal = data[RACSignalStartSignal]; + expectedValues = data[RACSignalStartExpectedValues]; + scheduler = data[RACSignalStartExpectedScheduler]; + + subscribeAndGetScheduler = [^{ + __block RACScheduler *schedulerInDelivery; + [signal subscribeNext:^(id _) { + schedulerInDelivery = RACScheduler.currentScheduler; + }]; + + expect(schedulerInDelivery).willNot.beNil(); + return schedulerInDelivery; + } copy]; + }); + + it(@"should send values from the returned signal", ^{ + NSArray *values = [signal toArray]; + expect(values).to.equal(expectedValues); + }); + + it(@"should replay all values", ^{ + // Force a subscription so that we get replayed results. + [[signal publish] connect]; + + NSArray *values = [signal toArray]; + expect(values).to.equal(expectedValues); + }); + + it(@"should deliver the original results on the given scheduler", ^{ + RACScheduler *currentScheduler = subscribeAndGetScheduler(); + expect(currentScheduler).to.equal(scheduler); + }); + + it(@"should deliver replayed results on the given scheduler", ^{ + // Force a subscription so that we get replayed results on the + // tested subscription. + subscribeAndGetScheduler(); + + RACScheduler *currentScheduler = subscribeAndGetScheduler(); + expect(currentScheduler).to.equal(scheduler); + }); +}); + +SharedExampleGroupsEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACStreamExamples.h b/ReactiveCocoaFramework/ReactiveCocoaTests/RACStreamExamples.h new file mode 100644 index 0000000..318a6a8 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACStreamExamples.h
@@ -0,0 +1,26 @@ +// +// RACStreamExamples.h +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-11-01. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +// The name of the shared examples for a RACStream subclass. +extern NSString * const RACStreamExamples; + +// The RACStream subclass to test. +extern NSString * const RACStreamExamplesClass; + +// An infinite RACStream to test, making sure that certain operations +// terminate. +// +// The stream should contain infinite RACUnit values. +extern NSString * const RACStreamExamplesInfiniteStream; + +// A block with the signature: +// +// void (^)(RACStream *stream, NSArray *expectedValues) +// +// … used to verify that a stream contains the expected values. +extern NSString * const RACStreamExamplesVerifyValuesBlock;
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACStreamExamples.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACStreamExamples.m new file mode 100644 index 0000000..bdf22f1 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACStreamExamples.m
@@ -0,0 +1,648 @@ +// +// RACStreamExamples.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-11-01. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACStreamExamples.h" + +#import "RACStream.h" +#import "RACUnit.h" +#import "RACTuple.h" + +NSString * const RACStreamExamples = @"RACStreamExamples"; +NSString * const RACStreamExamplesClass = @"RACStreamExamplesClass"; +NSString * const RACStreamExamplesInfiniteStream = @"RACStreamExamplesInfiniteStream"; +NSString * const RACStreamExamplesVerifyValuesBlock = @"RACStreamExamplesVerifyValuesBlock"; + +SharedExampleGroupsBegin(RACStreamExamples) + +sharedExamplesFor(RACStreamExamples, ^(NSDictionary *data) { + __block Class streamClass; + __block void (^verifyValues)(RACStream *, NSArray *); + __block RACStream *infiniteStream; + + __block RACStream *(^streamWithValues)(NSArray *); + + before(^{ + streamClass = data[RACStreamExamplesClass]; + verifyValues = data[RACStreamExamplesVerifyValuesBlock]; + infiniteStream = data[RACStreamExamplesInfiniteStream]; + streamWithValues = [^(NSArray *values) { + RACStream *stream = [streamClass empty]; + + for (id value in values) { + stream = [stream concat:[streamClass return:value]]; + } + + return stream; + } copy]; + }); + + it(@"should return an empty stream", ^{ + RACStream *stream = [streamClass empty]; + verifyValues(stream, @[]); + }); + + it(@"should lift a value into a stream", ^{ + RACStream *stream = [streamClass return:RACUnit.defaultUnit]; + verifyValues(stream, @[ RACUnit.defaultUnit ]); + }); + + describe(@"-concat:", ^{ + it(@"should concatenate two streams", ^{ + RACStream *stream = [[streamClass return:@0] concat:[streamClass return:@1]]; + verifyValues(stream, @[ @0, @1 ]); + }); + + it(@"should concatenate three streams", ^{ + RACStream *stream = [[[streamClass return:@0] concat:[streamClass return:@1]] concat:[streamClass return:@2]]; + verifyValues(stream, @[ @0, @1, @2 ]); + }); + + it(@"should concatenate around an empty stream", ^{ + RACStream *stream = [[[streamClass return:@0] concat:[streamClass empty]] concat:[streamClass return:@2]]; + verifyValues(stream, @[ @0, @2 ]); + }); + }); + + it(@"should flatten", ^{ + RACStream *stream = [[streamClass return:[streamClass return:RACUnit.defaultUnit]] flatten]; + verifyValues(stream, @[ RACUnit.defaultUnit ]); + }); + + describe(@"-bind:", ^{ + it(@"should return the result of binding a single value", ^{ + RACStream *stream = [[streamClass return:@0] bind:^{ + return ^(NSNumber *value, BOOL *stop) { + NSNumber *newValue = @(value.integerValue + 1); + return [streamClass return:newValue]; + }; + }]; + + verifyValues(stream, @[ @1 ]); + }); + + it(@"should concatenate the result of binding multiple values", ^{ + RACStream *baseStream = streamWithValues(@[ @0, @1 ]); + RACStream *stream = [baseStream bind:^{ + return ^(NSNumber *value, BOOL *stop) { + NSNumber *newValue = @(value.integerValue + 1); + return [streamClass return:newValue]; + }; + }]; + + verifyValues(stream, @[ @1, @2 ]); + }); + + it(@"should concatenate with an empty result from binding a value", ^{ + RACStream *baseStream = streamWithValues(@[ @0, @1, @2 ]); + RACStream *stream = [baseStream bind:^{ + return ^(NSNumber *value, BOOL *stop) { + if (value.integerValue == 1) return [streamClass empty]; + + NSNumber *newValue = @(value.integerValue + 1); + return [streamClass return:newValue]; + }; + }]; + + verifyValues(stream, @[ @1, @3 ]); + }); + + it(@"should terminate immediately when returning nil", ^{ + RACStream *stream = [infiniteStream bind:^{ + return ^ id (id _, BOOL *stop) { + return nil; + }; + }]; + + verifyValues(stream, @[]); + }); + + it(@"should terminate after one value when setting 'stop'", ^{ + RACStream *stream = [infiniteStream bind:^{ + return ^ id (id value, BOOL *stop) { + *stop = YES; + return [streamClass return:value]; + }; + }]; + + verifyValues(stream, @[ RACUnit.defaultUnit ]); + }); + + it(@"should terminate immediately when returning nil and setting 'stop'", ^{ + RACStream *stream = [infiniteStream bind:^{ + return ^ id (id _, BOOL *stop) { + *stop = YES; + return nil; + }; + }]; + + verifyValues(stream, @[]); + }); + + it(@"should be restartable even with block state", ^{ + NSArray *values = @[ @0, @1, @2 ]; + RACStream *baseStream = streamWithValues(values); + + RACStream *countingStream = [baseStream bind:^{ + __block NSUInteger counter = 0; + + return ^(id x, BOOL *stop) { + return [streamClass return:@(counter++)]; + }; + }]; + + verifyValues(countingStream, @[ @0, @1, @2 ]); + verifyValues(countingStream, @[ @0, @1, @2 ]); + }); + + it(@"should be interleavable even with block state", ^{ + NSArray *values = @[ @0, @1, @2 ]; + RACStream *baseStream = streamWithValues(values); + + RACStream *countingStream = [baseStream bind:^{ + __block NSUInteger counter = 0; + + return ^(id x, BOOL *stop) { + return [streamClass return:@(counter++)]; + }; + }]; + + // Just so +zip:reduce: thinks this is a unique stream. + RACStream *anotherStream = [[streamClass empty] concat:countingStream]; + + RACStream *zipped = [streamClass zip:@[ countingStream, anotherStream ] reduce:^(NSNumber *v1, NSNumber *v2) { + return @(v1.integerValue + v2.integerValue); + }]; + + verifyValues(zipped, @[ @0, @2, @4 ]); + }); + }); + + describe(@"-flattenMap:", ^{ + it(@"should return a single mapped result", ^{ + RACStream *stream = [[streamClass return:@0] flattenMap:^(NSNumber *value) { + NSNumber *newValue = @(value.integerValue + 1); + return [streamClass return:newValue]; + }]; + + verifyValues(stream, @[ @1 ]); + }); + + it(@"should concatenate the results of mapping multiple values", ^{ + RACStream *baseStream = streamWithValues(@[ @0, @1 ]); + RACStream *stream = [baseStream flattenMap:^(NSNumber *value) { + NSNumber *newValue = @(value.integerValue + 1); + return [streamClass return:newValue]; + }]; + + verifyValues(stream, @[ @1, @2 ]); + }); + + it(@"should concatenate with an empty result from mapping a value", ^{ + RACStream *baseStream = streamWithValues(@[ @0, @1, @2 ]); + RACStream *stream = [baseStream flattenMap:^(NSNumber *value) { + if (value.integerValue == 1) return [streamClass empty]; + + NSNumber *newValue = @(value.integerValue + 1); + return [streamClass return:newValue]; + }]; + + verifyValues(stream, @[ @1, @3 ]); + }); + + it(@"should treat nil streams like empty streams", ^{ + RACStream *baseStream = streamWithValues(@[ @0, @1, @2 ]); + RACStream *stream = [baseStream flattenMap:^ RACStream * (NSNumber *value) { + if (value.integerValue == 1) return nil; + + NSNumber *newValue = @(value.integerValue + 1); + return [streamClass return:newValue]; + }]; + + verifyValues(stream, @[ @1, @3 ]); + }); + }); + + it(@"should map", ^{ + RACStream *baseStream = streamWithValues(@[ @0, @1, @2 ]); + RACStream *stream = [baseStream map:^(NSNumber *value) { + return @(value.integerValue + 1); + }]; + + verifyValues(stream, @[ @1, @2, @3 ]); + }); + + it(@"should map and replace", ^{ + RACStream *baseStream = streamWithValues(@[ @0, @1, @2 ]); + RACStream *stream = [baseStream mapReplace:RACUnit.defaultUnit]; + + verifyValues(stream, @[ RACUnit.defaultUnit, RACUnit.defaultUnit, RACUnit.defaultUnit ]); + }); + + it(@"should filter", ^{ + RACStream *baseStream = streamWithValues(@[ @0, @1, @2, @3, @4, @5, @6 ]); + RACStream *stream = [baseStream filter:^ BOOL (NSNumber *value) { + return value.integerValue % 2 == 0; + }]; + + verifyValues(stream, @[ @0, @2, @4, @6 ]); + }); + + describe(@"-ignore:", ^{ + it(@"should ignore a value", ^{ + RACStream *baseStream = streamWithValues(@[ @0, @1, @2, @3, @4, @5, @6 ]); + RACStream *stream = [baseStream ignore:@1]; + + verifyValues(stream, @[ @0, @2, @3, @4, @5, @6 ]); + }); + + it(@"should ignore based on object equality", ^{ + RACStream *baseStream = streamWithValues(@[ @"0", @"1", @"2", @"3", @"4", @"5", @"6" ]); + + NSMutableString *valueToIgnore = [[NSMutableString alloc] init]; + [valueToIgnore appendString:@"1"]; + RACStream *stream = [baseStream ignore:valueToIgnore]; + + verifyValues(stream, @[ @"0", @"2", @"3", @"4", @"5", @"6" ]); + }); + }); + + it(@"should start with a value", ^{ + RACStream *stream = [[streamClass return:@1] startWith:@0]; + verifyValues(stream, @[ @0, @1 ]); + }); + + describe(@"-skip:", ^{ + __block NSArray *values; + __block RACStream *stream; + + before(^{ + values = @[ @0, @1, @2 ]; + stream = streamWithValues(values); + }); + + it(@"should skip any valid number of values", ^{ + for (NSUInteger i = 0; i < values.count; i++) { + verifyValues([stream skip:i], [values subarrayWithRange:NSMakeRange(i, values.count - i)]); + } + }); + + it(@"should return an empty stream when skipping too many values", ^{ + verifyValues([stream skip:4], @[]); + }); + }); + + describe(@"-take:", ^{ + describe(@"with three values", ^{ + __block NSArray *values; + __block RACStream *stream; + + before(^{ + values = @[ @0, @1, @2 ]; + stream = streamWithValues(values); + }); + + it(@"should take any valid number of values", ^{ + for (NSUInteger i = 0; i < values.count; i++) { + verifyValues([stream take:i], [values subarrayWithRange:NSMakeRange(0, i)]); + } + }); + + it(@"should return the same stream when taking too many values", ^{ + verifyValues([stream take:4], values); + }); + }); + + it(@"should take and terminate from an infinite stream", ^{ + verifyValues([infiniteStream take:0], @[]); + verifyValues([infiniteStream take:1], @[ RACUnit.defaultUnit ]); + verifyValues([infiniteStream take:2], @[ RACUnit.defaultUnit, RACUnit.defaultUnit ]); + }); + + it(@"should take and terminate from a single-item stream", ^{ + NSArray *values = @[ RACUnit.defaultUnit ]; + RACStream *stream = streamWithValues(values); + verifyValues([stream take:1], values); + }); + }); + + describe(@"zip stream creation methods", ^{ + __block NSArray *valuesOne; + + __block RACStream *streamOne; + __block RACStream *streamTwo; + __block RACStream *streamThree; + __block NSArray *threeStreams; + + __block NSArray *oneStreamTuples; + __block NSArray *twoStreamTuples; + __block NSArray *threeStreamTuples; + + before(^{ + valuesOne = @[ @"Ada", @"Bob", @"Dea" ]; + NSArray *valuesTwo = @[ @"eats", @"cooks", @"jumps" ]; + NSArray *valuesThree = @[ @"fish", @"bear", @"rock" ]; + + streamOne = streamWithValues(valuesOne); + streamTwo = streamWithValues(valuesTwo); + streamThree = streamWithValues(valuesThree); + threeStreams = @[ streamOne, streamTwo, streamThree ]; + + oneStreamTuples = @[ + RACTuplePack(valuesOne[0]), + RACTuplePack(valuesOne[1]), + RACTuplePack(valuesOne[2]), + ]; + + twoStreamTuples = @[ + RACTuplePack(valuesOne[0], valuesTwo[0]), + RACTuplePack(valuesOne[1], valuesTwo[1]), + RACTuplePack(valuesOne[2], valuesTwo[2]), + ]; + + threeStreamTuples = @[ + RACTuplePack(valuesOne[0], valuesTwo[0], valuesThree[0]), + RACTuplePack(valuesOne[1], valuesTwo[1], valuesThree[1]), + RACTuplePack(valuesOne[2], valuesTwo[2], valuesThree[2]), + ]; + }); + + describe(@"-zipWith:", ^{ + it(@"should make a stream of tuples", ^{ + RACStream *stream = [streamOne zipWith:streamTwo]; + verifyValues(stream, twoStreamTuples); + }); + + it(@"should truncate streams", ^{ + RACStream *shortStream = streamWithValues(@[ @"now", @"later" ]); + RACStream *stream = [streamOne zipWith:shortStream]; + + verifyValues(stream, @[ + RACTuplePack(valuesOne[0], @"now"), + RACTuplePack(valuesOne[1], @"later") + ]); + }); + + it(@"should work on infinite streams", ^{ + RACStream *stream = [streamOne zipWith:infiniteStream]; + verifyValues(stream, @[ + RACTuplePack(valuesOne[0], RACUnit.defaultUnit), + RACTuplePack(valuesOne[1], RACUnit.defaultUnit), + RACTuplePack(valuesOne[2], RACUnit.defaultUnit) + ]); + }); + + it(@"should handle multiples of the same stream", ^{ + RACStream *stream = [streamOne zipWith:streamOne]; + verifyValues(stream, @[ + RACTuplePack(valuesOne[0], valuesOne[0]), + RACTuplePack(valuesOne[1], valuesOne[1]), + RACTuplePack(valuesOne[2], valuesOne[2]), + ]); + }); + }); + + describe(@"+zip:reduce:", ^{ + it(@"should reduce values", ^{ + RACStream *stream = [streamClass zip:threeStreams reduce:^ NSString * (id x, id y, id z) { + return [NSString stringWithFormat:@"%@ %@ %@", x, y, z]; + }]; + verifyValues(stream, @[ @"Ada eats fish", @"Bob cooks bear", @"Dea jumps rock" ]); + }); + + it(@"should truncate streams", ^{ + RACStream *shortStream = streamWithValues(@[ @"now", @"later" ]); + NSArray *streams = [threeStreams arrayByAddingObject:shortStream]; + RACStream *stream = [streamClass zip:streams reduce:^ NSString * (id w, id x, id y, id z) { + return [NSString stringWithFormat:@"%@ %@ %@ %@", w, x, y, z]; + }]; + verifyValues(stream, @[ @"Ada eats fish now", @"Bob cooks bear later" ]); + }); + + it(@"should work on infinite streams", ^{ + NSArray *streams = [threeStreams arrayByAddingObject:infiniteStream]; + RACStream *stream = [streamClass zip:streams reduce:^ NSString * (id w, id x, id y, id z) { + return [NSString stringWithFormat:@"%@ %@ %@", w, x, y]; + }]; + verifyValues(stream, @[ @"Ada eats fish", @"Bob cooks bear", @"Dea jumps rock" ]); + }); + + it(@"should handle multiples of the same stream", ^{ + NSArray *streams = @[ streamOne, streamOne, streamTwo, streamThree, streamTwo, streamThree ]; + RACStream *stream = [streamClass zip:streams reduce:^ NSString * (id x1, id x2, id y1, id z1, id y2, id z2) { + return [NSString stringWithFormat:@"%@ %@ %@ %@ %@ %@", x1, x2, y1, z1, y2, z2]; + }]; + verifyValues(stream, @[ @"Ada Ada eats fish eats fish", @"Bob Bob cooks bear cooks bear", @"Dea Dea jumps rock jumps rock" ]); + }); + }); + + describe(@"+zip:", ^{ + it(@"should make a stream of tuples out of single value", ^{ + RACStream *stream = [streamClass zip:@[ streamOne ]]; + verifyValues(stream, oneStreamTuples); + }); + + it(@"should make a stream of tuples out of an array of streams", ^{ + RACStream *stream = [streamClass zip:threeStreams]; + verifyValues(stream, threeStreamTuples); + }); + + it(@"should make an empty stream if given an empty array", ^{ + RACStream *stream = [streamClass zip:@[]]; + verifyValues(stream, @[]); + }); + + it(@"should make a stream of tuples out of an enumerator of streams", ^{ + RACStream *stream = [streamClass zip:threeStreams.objectEnumerator]; + verifyValues(stream, threeStreamTuples); + }); + + it(@"should make an empty stream if given an empty enumerator", ^{ + RACStream *stream = [streamClass zip:@[].objectEnumerator]; + verifyValues(stream, @[]); + }); + }); + }); + + describe(@"+concat:", ^{ + __block NSArray *streams = nil; + __block NSArray *result = nil; + + before(^{ + RACStream *a = [streamClass return:@0]; + RACStream *b = [streamClass empty]; + RACStream *c = streamWithValues(@[ @1, @2, @3 ]); + RACStream *d = [streamClass return:@4]; + RACStream *e = [streamClass return:@5]; + RACStream *f = [streamClass empty]; + RACStream *g = [streamClass empty]; + RACStream *h = streamWithValues(@[ @6, @7 ]); + streams = @[ a, b, c, d, e, f, g, h ]; + result = @[ @0, @1, @2, @3, @4, @5, @6, @7 ]; + }); + + it(@"should concatenate an array of streams", ^{ + RACStream *stream = [streamClass concat:streams]; + verifyValues(stream, result); + }); + + it(@"should concatenate an enumerator of streams", ^{ + RACStream *stream = [streamClass concat:streams.objectEnumerator]; + verifyValues(stream, result); + }); + }); + + it(@"should scan", ^{ + RACStream *stream = streamWithValues(@[ @1, @2, @3, @4 ]); + RACStream *scanned = [stream scanWithStart:@0 reduce:^(NSNumber *running, NSNumber *next) { + return @(running.integerValue + next.integerValue); + }]; + + verifyValues(scanned, @[ @1, @3, @6, @10 ]); + }); + + describe(@"taking with a predicate", ^{ + NSArray *values = @[ @0, @1, @2, @3, @0, @2, @4 ]; + + __block RACStream *stream; + + before(^{ + stream = streamWithValues(values); + }); + + it(@"should take until a predicate is true", ^{ + RACStream *taken = [stream takeUntilBlock:^ BOOL (NSNumber *x) { + return x.integerValue >= 3; + }]; + + verifyValues(taken, @[ @0, @1, @2 ]); + }); + + it(@"should take while a predicate is true", ^{ + RACStream *taken = [stream takeWhileBlock:^ BOOL (NSNumber *x) { + return x.integerValue <= 1; + }]; + + verifyValues(taken, @[ @0, @1 ]); + }); + + it(@"should take a full stream", ^{ + RACStream *taken = [stream takeWhileBlock:^ BOOL (NSNumber *x) { + return x.integerValue <= 10; + }]; + + verifyValues(taken, values); + }); + + it(@"should return an empty stream", ^{ + RACStream *taken = [stream takeWhileBlock:^ BOOL (NSNumber *x) { + return x.integerValue < 0; + }]; + + verifyValues(taken, @[]); + }); + + it(@"should terminate an infinite stream", ^{ + RACStream *infiniteCounter = [infiniteStream scanWithStart:@0 reduce:^(NSNumber *running, id _) { + return @(running.unsignedIntegerValue + 1); + }]; + + RACStream *taken = [infiniteCounter takeWhileBlock:^ BOOL (NSNumber *x) { + return x.integerValue <= 5; + }]; + + verifyValues(taken, @[ @1, @2, @3, @4, @5 ]); + }); + }); + + describe(@"skipping with a predicate", ^{ + NSArray *values = @[ @0, @1, @2, @3, @0, @2, @4 ]; + + __block RACStream *stream; + + before(^{ + stream = streamWithValues(values); + }); + + it(@"should skip until a predicate is true", ^{ + RACStream *taken = [stream skipUntilBlock:^ BOOL (NSNumber *x) { + return x.integerValue >= 3; + }]; + + verifyValues(taken, @[ @3, @0, @2, @4 ]); + }); + + it(@"should skip while a predicate is true", ^{ + RACStream *taken = [stream skipWhileBlock:^ BOOL (NSNumber *x) { + return x.integerValue <= 1; + }]; + + verifyValues(taken, @[ @2, @3, @0, @2, @4 ]); + }); + + it(@"should skip a full stream", ^{ + RACStream *taken = [stream skipWhileBlock:^ BOOL (NSNumber *x) { + return x.integerValue <= 10; + }]; + + verifyValues(taken, @[]); + }); + + it(@"should finish skipping immediately", ^{ + RACStream *taken = [stream skipWhileBlock:^ BOOL (NSNumber *x) { + return x.integerValue < 0; + }]; + + verifyValues(taken, values); + }); + }); + + describe(@"-combinePreviousWithStart:reduce:", ^{ + NSArray *values = @[ @1, @2, @3 ]; + __block RACStream *stream; + beforeEach(^{ + stream = streamWithValues(values); + }); + + it(@"should pass the previous next into the reduce block", ^{ + NSMutableArray *previouses = [NSMutableArray array]; + RACStream *mapped = [stream combinePreviousWithStart:nil reduce:^(id previous, id next) { + [previouses addObject:previous ?: RACTupleNil.tupleNil]; + return next; + }]; + + verifyValues(mapped, @[ @1, @2, @3 ]); + + NSArray *expected = @[ RACTupleNil.tupleNil, @1, @2 ]; + expect(previouses).to.equal(expected); + }); + + it(@"should send the combined value", ^{ + RACStream *mapped = [stream combinePreviousWithStart:@1 reduce:^(NSNumber *previous, NSNumber *next) { + return [NSString stringWithFormat:@"%lu - %lu", (unsigned long)previous.unsignedIntegerValue, (unsigned long)next.unsignedIntegerValue]; + }]; + + verifyValues(mapped, @[ @"1 - 1", @"1 - 2", @"2 - 3" ]); + }); + }); + + it(@"should reduce tuples", ^{ + RACStream *stream = streamWithValues(@[ + RACTuplePack(@"foo", @"bar"), + RACTuplePack(@"buzz", @"baz"), + RACTuplePack(@"", @"_") + ]); + + RACStream *reduced = [stream reduceEach:^(NSString *a, NSString *b) { + return [a stringByAppendingString:b]; + }]; + + verifyValues(reduced, @[ @"foobar", @"buzzbaz", @"_" ]); + }); +}); + +SharedExampleGroupsEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubclassObject.h b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubclassObject.h new file mode 100644 index 0000000..962b7eb --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubclassObject.h
@@ -0,0 +1,23 @@ +// +// RACSubclassObject.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 3/18/13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACTestObject.h" + +@interface RACSubclassObject : RACTestObject + +// Set whenever -forwardInvocation: is invoked on the receiver. +@property (nonatomic, assign) SEL forwardedSelector; + +// Invokes the superclass implementation with `objectValue` concatenated to +// "SUBCLASS". +- (NSString *)combineObjectValue:(id)objectValue andIntegerValue:(NSInteger)integerValue; + +// Asynchronously invokes the superclass implementation on the current scheduler. +- (void)setObjectValue:(id)objectValue andSecondObjectValue:(id)secondObjectValue; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubclassObject.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubclassObject.m new file mode 100644 index 0000000..41e61f7 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubclassObject.m
@@ -0,0 +1,38 @@ +// +// RACSubclassObject.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 3/18/13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACSubclassObject.h" +#import "RACScheduler.h" + +@implementation RACSubclassObject + +- (void)forwardInvocation:(NSInvocation *)invocation { + self.forwardedSelector = invocation.selector; +} + +- (NSMethodSignature *)methodSignatureForSelector:(SEL)selector { + NSParameterAssert(selector != NULL); + + NSMethodSignature *signature = [super methodSignatureForSelector:selector]; + if (signature != nil) return signature; + + return [super methodSignatureForSelector:@selector(description)]; +} + +- (NSString *)combineObjectValue:(id)objectValue andIntegerValue:(NSInteger)integerValue { + NSString *appended = [[objectValue description] stringByAppendingString:@"SUBCLASS"]; + return [super combineObjectValue:appended andIntegerValue:integerValue]; +} + +- (void)setObjectValue:(id)objectValue andSecondObjectValue:(id)secondObjectValue { + [RACScheduler.currentScheduler schedule:^{ + [super setObjectValue:objectValue andSecondObjectValue:secondObjectValue]; + }]; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubjectSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubjectSpec.m new file mode 100644 index 0000000..6bc175f --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubjectSpec.m
@@ -0,0 +1,335 @@ +// +// RACSubjectSpec.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 6/24/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACSubscriberExamples.h" + +#import <libkern/OSAtomic.h> +#import "EXTScope.h" +#import "RACBehaviorSubject.h" +#import "RACDisposable.h" +#import "RACReplaySubject.h" +#import "RACScheduler.h" +#import "RACSignal+Operations.h" +#import "RACSubject.h" +#import "RACUnit.h" + +SpecBegin(RACSubject) + +describe(@"RACSubject", ^{ + __block RACSubject *subject; + __block NSMutableArray *values; + + __block BOOL success; + __block NSError *error; + + beforeEach(^{ + values = [NSMutableArray array]; + + subject = [RACSubject subject]; + success = YES; + error = nil; + + [subject subscribeNext:^(id value) { + [values addObject:value]; + } error:^(NSError *e) { + error = e; + success = NO; + } completed:^{ + success = YES; + }]; + }); + + itShouldBehaveLike(RACSubscriberExamples, ^{ + return @{ + RACSubscriberExampleSubscriber: subject, + RACSubscriberExampleValuesReceivedBlock: [^{ return [values copy]; } copy], + RACSubscriberExampleErrorReceivedBlock: [^{ return error; } copy], + RACSubscriberExampleSuccessBlock: [^{ return success; } copy] + }; + }); +}); + +describe(@"RACReplaySubject", ^{ + __block RACReplaySubject *subject = nil; + + describe(@"with a capacity of 1", ^{ + beforeEach(^{ + subject = [RACReplaySubject replaySubjectWithCapacity:1]; + }); + + it(@"should send the last value", ^{ + id firstValue = @"blah"; + id secondValue = @"more blah"; + + [subject sendNext:firstValue]; + [subject sendNext:secondValue]; + + __block id valueReceived = nil; + [subject subscribeNext:^(id x) { + valueReceived = x; + }]; + + expect(valueReceived).to.equal(secondValue); + }); + + it(@"should send the last value to new subscribers after completion", ^{ + id firstValue = @"blah"; + id secondValue = @"more blah"; + + __block id valueReceived = nil; + __block NSUInteger nextsReceived = 0; + + [subject sendNext:firstValue]; + [subject sendNext:secondValue]; + + expect(nextsReceived).to.equal(0); + expect(valueReceived).to.beNil(); + + [subject sendCompleted]; + + [subject subscribeNext:^(id x) { + valueReceived = x; + nextsReceived++; + }]; + + expect(nextsReceived).to.equal(1); + expect(valueReceived).to.equal(secondValue); + }); + + it(@"should not send any values to new subscribers if none were sent originally", ^{ + [subject sendCompleted]; + + __block BOOL nextInvoked = NO; + [subject subscribeNext:^(id x) { + nextInvoked = YES; + }]; + + expect(nextInvoked).to.beFalsy(); + }); + + it(@"should resend errors", ^{ + NSError *error = [NSError errorWithDomain:NSCocoaErrorDomain code:0 userInfo:nil]; + [subject sendError:error]; + + __block BOOL errorSent = NO; + [subject subscribeError:^(NSError *sentError) { + expect(sentError).to.equal(error); + errorSent = YES; + }]; + + expect(errorSent).to.beTruthy(); + }); + + it(@"should resend nil errors", ^{ + [subject sendError:nil]; + + __block BOOL errorSent = NO; + [subject subscribeError:^(NSError *sentError) { + expect(sentError).to.beNil(); + errorSent = YES; + }]; + + expect(errorSent).to.beTruthy(); + }); + }); + + describe(@"with an unlimited capacity", ^{ + beforeEach(^{ + subject = [RACReplaySubject subject]; + }); + + itShouldBehaveLike(RACSubscriberExamples, ^{ + return @{ + RACSubscriberExampleSubscriber: subject, + RACSubscriberExampleValuesReceivedBlock: [^{ + NSMutableArray *values = [NSMutableArray array]; + + // This subscription should synchronously dump all values already + // received into 'values'. + [subject subscribeNext:^(id value) { + [values addObject:value]; + }]; + + return values; + } copy], + RACSubscriberExampleErrorReceivedBlock: [^{ + __block NSError *error = nil; + + [subject subscribeError:^(NSError *x) { + error = x; + }]; + + return error; + } copy], + RACSubscriberExampleSuccessBlock: [^{ + __block BOOL success = YES; + + [subject subscribeError:^(NSError *x) { + success = NO; + }]; + + return success; + } copy] + }; + }); + + it(@"should send both values to new subscribers after completion", ^{ + id firstValue = @"blah"; + id secondValue = @"more blah"; + + [subject sendNext:firstValue]; + [subject sendNext:secondValue]; + [subject sendCompleted]; + + __block BOOL completed = NO; + NSMutableArray *valuesReceived = [NSMutableArray array]; + [subject subscribeNext:^(id x) { + [valuesReceived addObject:x]; + } completed:^{ + completed = YES; + }]; + + expect(valuesReceived.count).to.equal(2); + NSArray *expected = [NSArray arrayWithObjects:firstValue, secondValue, nil]; + expect(valuesReceived).to.equal(expected); + expect(completed).to.beTruthy(); + }); + + it(@"should send values in the same order live as when replaying", ^{ + NSUInteger count = 49317; + + // Just leak it, ain't no thang. + __unsafe_unretained volatile id *values = (__unsafe_unretained id *)calloc(count, sizeof(*values)); + __block volatile int32_t nextIndex = 0; + + [subject subscribeNext:^(NSNumber *value) { + int32_t indexPlusOne = OSAtomicIncrement32(&nextIndex); + values[indexPlusOne - 1] = value; + }]; + + dispatch_queue_t queue = dispatch_queue_create("com.github.ReactiveCocoa.RACSubjectSpec", DISPATCH_QUEUE_CONCURRENT); + @onExit { + dispatch_release(queue); + }; + + dispatch_suspend(queue); + + for (NSUInteger i = 0; i < count; i++) { + dispatch_async(queue, ^{ + [subject sendNext:@(i)]; + }); + } + + dispatch_resume(queue); + dispatch_barrier_sync(queue, ^{ + [subject sendCompleted]; + }); + + OSMemoryBarrier(); + + NSArray *liveValues = [NSArray arrayWithObjects:(id *)values count:(NSUInteger)nextIndex]; + expect(liveValues.count).to.equal(count); + + NSArray *replayedValues = subject.toArray; + expect(replayedValues.count).to.equal(count); + + // It should return the same ordering for multiple invocations too. + expect(replayedValues).to.equal(subject.toArray); + + [replayedValues enumerateObjectsUsingBlock:^(id value, NSUInteger index, BOOL *stop) { + expect(liveValues[index]).to.equal(value); + }]; + }); + + it(@"should have a current scheduler when replaying", ^{ + [subject sendNext:RACUnit.defaultUnit]; + + __block RACScheduler *currentScheduler; + [subject subscribeNext:^(id x) { + currentScheduler = RACScheduler.currentScheduler; + }]; + + expect(currentScheduler).notTo.beNil(); + + currentScheduler = nil; + dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ + [subject subscribeNext:^(id x) { + currentScheduler = RACScheduler.currentScheduler; + }]; + }); + + expect(currentScheduler).willNot.beNil(); + }); + + it(@"should stop replaying when the subscription is disposed", ^{ + NSMutableArray *values = [NSMutableArray array]; + + [subject sendNext:@0]; + [subject sendNext:@1]; + + dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ + __block RACDisposable *disposable = [subject subscribeNext:^(id x) { + expect(disposable).notTo.beNil(); + + [values addObject:x]; + [disposable dispose]; + }]; + }); + + expect(values).will.equal(@[ @0 ]); + }); + + it(@"should finish replaying before completing", ^{ + [subject sendNext:@1]; + + __block id received; + dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ + [subject subscribeNext:^(id x) { + received = x; + }]; + + [subject sendCompleted]; + }); + + expect(received).will.equal(@1); + }); + + it(@"should finish replaying before erroring", ^{ + [subject sendNext:@1]; + + __block id received; + dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ + [subject subscribeNext:^(id x) { + received = x; + }]; + + [subject sendError:[NSError errorWithDomain:@"blah" code:-99 userInfo:nil]]; + }); + + expect(received).will.equal(@1); + }); + + it(@"should finish replaying before sending new values", ^{ + [subject sendNext:@1]; + + NSMutableArray *received = [NSMutableArray array]; + dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ + [subject subscribeNext:^(id x) { + [received addObject:x]; + }]; + + [subject sendNext:@2]; + }); + + NSArray *expected = @[ @1, @2 ]; + expect(received).will.equal(expected); + }); + }); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubscriberExamples.h b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubscriberExamples.h new file mode 100644 index 0000000..edc9e5a --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubscriberExamples.h
@@ -0,0 +1,23 @@ +// +// RACSubscriberExamples.h +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-11-27. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +// The name of the shared examples for implementors of <RACSubscriber>. +extern NSString * const RACSubscriberExamples; + +// id<RACSubscriber> +extern NSString * const RACSubscriberExampleSubscriber; + +// A block which returns an NSArray of the values received so far. +extern NSString * const RACSubscriberExampleValuesReceivedBlock; + +// A block which returns any NSError received so far. +extern NSString * const RACSubscriberExampleErrorReceivedBlock; + +// A block which returns a BOOL indicating whether the subscriber is successful +// so far. +extern NSString * const RACSubscriberExampleSuccessBlock;
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubscriberExamples.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubscriberExamples.m new file mode 100644 index 0000000..946a307 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubscriberExamples.m
@@ -0,0 +1,185 @@ +// +// RACSubscriberExamples.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-11-27. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACSubscriberExamples.h" + +#import "NSObject+RACDeallocating.h" +#import "RACCompoundDisposable.h" +#import "RACDisposable.h" +#import "RACSubject.h" +#import "RACSubscriber.h" + +NSString * const RACSubscriberExamples = @"RACSubscriberExamples"; +NSString * const RACSubscriberExampleSubscriber = @"RACSubscriberExampleSubscriber"; +NSString * const RACSubscriberExampleValuesReceivedBlock = @"RACSubscriberExampleValuesReceivedBlock"; +NSString * const RACSubscriberExampleErrorReceivedBlock = @"RACSubscriberExampleErrorReceivedBlock"; +NSString * const RACSubscriberExampleSuccessBlock = @"RACSubscriberExampleSuccessBlock"; + +SharedExampleGroupsBegin(RACSubscriberExamples) + +sharedExamplesFor(RACSubscriberExamples, ^(NSDictionary *data) { + __block NSArray * (^valuesReceived)(void); + __block NSError * (^errorReceived)(void); + __block BOOL (^success)(void); + __block id<RACSubscriber> subscriber; + + beforeEach(^{ + valuesReceived = data[RACSubscriberExampleValuesReceivedBlock]; + errorReceived = data[RACSubscriberExampleErrorReceivedBlock]; + success = data[RACSubscriberExampleSuccessBlock]; + subscriber = data[RACSubscriberExampleSubscriber]; + expect(subscriber).notTo.beNil(); + }); + + it(@"should accept a nil error", ^{ + [subscriber sendError:nil]; + + expect(success()).to.beFalsy(); + expect(errorReceived()).to.beNil(); + expect(valuesReceived()).to.equal(@[]); + }); + + describe(@"with values", ^{ + __block NSSet *values; + + beforeEach(^{ + NSMutableSet *mutableValues = [NSMutableSet set]; + for (NSUInteger i = 0; i < 20; i++) { + [mutableValues addObject:@(i)]; + } + + values = [mutableValues copy]; + }); + + it(@"should send nexts serially, even when delivered from multiple threads", ^{ + NSArray *allValues = values.allObjects; + dispatch_apply(allValues.count, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), [^(size_t index) { + [subscriber sendNext:allValues[index]]; + } copy]); + + expect(success()).to.beTruthy(); + expect(errorReceived()).to.beNil(); + + NSSet *valuesReceivedSet = [NSSet setWithArray:valuesReceived()]; + expect(valuesReceivedSet).to.equal(values); + }); + }); + + describe(@"multiple subscriptions", ^{ + __block RACSubject *first; + __block RACSubject *second; + + beforeEach(^{ + first = [RACSubject subject]; + [first subscribe:subscriber]; + + second = [RACSubject subject]; + [second subscribe:subscriber]; + }); + + it(@"should send values from all subscriptions", ^{ + [first sendNext:@"foo"]; + [second sendNext:@"bar"]; + [first sendNext:@"buzz"]; + [second sendNext:@"baz"]; + + expect(success()).to.beTruthy(); + expect(errorReceived()).to.beNil(); + + NSArray *expected = @[ @"foo", @"bar", @"buzz", @"baz" ]; + expect(valuesReceived()).to.equal(expected); + }); + + it(@"should terminate after the first error from any subscription", ^{ + NSError *error = [NSError errorWithDomain:@"" code:-1 userInfo:nil]; + + [first sendNext:@"foo"]; + [second sendError:error]; + [first sendNext:@"buzz"]; + + expect(success()).to.beFalsy(); + expect(errorReceived()).to.equal(error); + + NSArray *expected = @[ @"foo" ]; + expect(valuesReceived()).to.equal(expected); + }); + + it(@"should terminate after the first completed from any subscription", ^{ + [first sendNext:@"foo"]; + [second sendNext:@"bar"]; + [first sendCompleted]; + [second sendNext:@"baz"]; + + expect(success()).to.beTruthy(); + expect(errorReceived()).to.beNil(); + + NSArray *expected = @[ @"foo", @"bar" ]; + expect(valuesReceived()).to.equal(expected); + }); + + it(@"should dispose of all current subscriptions upon termination", ^{ + __block BOOL firstDisposed = NO; + RACSignal *firstDisposableSignal = [RACSignal createSignal:^(id<RACSubscriber> subscriber) { + return [RACDisposable disposableWithBlock:^{ + firstDisposed = YES; + }]; + }]; + + __block BOOL secondDisposed = NO; + RACSignal *secondDisposableSignal = [RACSignal createSignal:^(id<RACSubscriber> subscriber) { + return [RACDisposable disposableWithBlock:^{ + secondDisposed = YES; + }]; + }]; + + [firstDisposableSignal subscribe:subscriber]; + [secondDisposableSignal subscribe:subscriber]; + + expect(firstDisposed).to.beFalsy(); + expect(secondDisposed).to.beFalsy(); + + [first sendCompleted]; + + expect(firstDisposed).to.beTruthy(); + expect(secondDisposed).to.beTruthy(); + }); + + it(@"should dispose of future subscriptions upon termination", ^{ + __block BOOL disposed = NO; + RACSignal *disposableSignal = [RACSignal createSignal:^(id<RACSubscriber> subscriber) { + return [RACDisposable disposableWithBlock:^{ + disposed = YES; + }]; + }]; + + [first sendCompleted]; + expect(disposed).to.beFalsy(); + + [disposableSignal subscribe:subscriber]; + expect(disposed).to.beTruthy(); + }); + }); + + describe(@"memory management", ^{ + it(@"should not retain disposed disposables", ^{ + __block BOOL disposableDeallocd = NO; + @autoreleasepool { + RACCompoundDisposable *disposable __attribute__((objc_precise_lifetime)) = [RACCompoundDisposable disposableWithBlock:^{}]; + [disposable.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + disposableDeallocd = YES; + }]]; + + [subscriber didSubscribeWithDisposable:disposable]; + [disposable dispose]; + } + expect(disposableDeallocd).to.beTruthy(); + }); + }); +}); + +SharedExampleGroupsEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubscriberSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubscriberSpec.m new file mode 100644 index 0000000..8a1725d --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubscriberSpec.m
@@ -0,0 +1,130 @@ +// +// RACSubscriberSpec.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-11-27. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACSubscriberExamples.h" + +#import "RACSubscriber.h" +#import "RACSubscriber+Private.h" +#import <libkern/OSAtomic.h> + +SpecBegin(RACSubscriber) + +__block RACSubscriber *subscriber; +__block NSMutableArray *values; + +__block volatile BOOL finished; +__block volatile int32_t nextsAfterFinished; + +__block BOOL success; +__block NSError *error; + +beforeEach(^{ + values = [NSMutableArray array]; + + finished = NO; + nextsAfterFinished = 0; + + success = YES; + error = nil; + + subscriber = [RACSubscriber subscriberWithNext:^(id value) { + if (finished) OSAtomicIncrement32Barrier(&nextsAfterFinished); + + [values addObject:value]; + } error:^(NSError *e) { + error = e; + success = NO; + } completed:^{ + success = YES; + }]; +}); + +itShouldBehaveLike(RACSubscriberExamples, ^{ + return @{ + RACSubscriberExampleSubscriber: subscriber, + RACSubscriberExampleValuesReceivedBlock: [^{ return [values copy]; } copy], + RACSubscriberExampleErrorReceivedBlock: [^{ return error; } copy], + RACSubscriberExampleSuccessBlock: [^{ return success; } copy] + }; +}); + +describe(@"finishing", ^{ + __block void (^sendValues)(void); + __block BOOL expectedSuccess; + + __block dispatch_group_t dispatchGroup; + __block dispatch_queue_t concurrentQueue; + + beforeEach(^{ + dispatchGroup = dispatch_group_create(); + expect(dispatchGroup).notTo.beNil(); + + concurrentQueue = dispatch_queue_create("com.github.ReactiveCocoa.RACSubscriberSpec", DISPATCH_QUEUE_CONCURRENT); + expect(concurrentQueue).notTo.beNil(); + + dispatch_suspend(concurrentQueue); + + sendValues = [^{ + for (NSUInteger i = 0; i < 15; i++) { + dispatch_group_async(dispatchGroup, concurrentQueue, ^{ + [subscriber sendNext:@(i)]; + }); + } + } copy]; + + sendValues(); + }); + + afterEach(^{ + sendValues(); + dispatch_resume(concurrentQueue); + + // Time out after one second. + dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 * NSEC_PER_SEC)); + expect(dispatch_group_wait(dispatchGroup, time)).to.equal(0); + + dispatch_release(dispatchGroup); + dispatchGroup = NULL; + + dispatch_release(concurrentQueue); + concurrentQueue = NULL; + + expect(nextsAfterFinished).to.equal(0); + + if (expectedSuccess) { + expect(success).to.beTruthy(); + expect(error).to.beNil(); + } else { + expect(success).to.beFalsy(); + } + }); + + it(@"should never invoke next after sending completed", ^{ + expectedSuccess = YES; + + dispatch_group_async(dispatchGroup, concurrentQueue, ^{ + [subscriber sendCompleted]; + + finished = YES; + OSMemoryBarrier(); + }); + }); + + it(@"should never invoke next after sending error", ^{ + expectedSuccess = NO; + + dispatch_group_async(dispatchGroup, concurrentQueue, ^{ + [subscriber sendError:nil]; + + finished = YES; + OSMemoryBarrier(); + }); + }); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubscriptingAssignmentTrampolineSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubscriptingAssignmentTrampolineSpec.m new file mode 100644 index 0000000..9165f11 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACSubscriptingAssignmentTrampolineSpec.m
@@ -0,0 +1,33 @@ +// +// RACSubscriptingAssignmentTrampolineSpec.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 9/24/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACSubscriptingAssignmentTrampoline.h" +#import "RACPropertySignalExamples.h" +#import "RACTestObject.h" +#import "RACSubject.h" + +SpecBegin(RACSubscriptingAssignmentTrampoline) + +id setupBlock = ^(RACTestObject *testObject, NSString *keyPath, id nilValue, RACSignal *signal) { + [[RACSubscriptingAssignmentTrampoline alloc] initWithTarget:testObject nilValue:nilValue][keyPath] = signal; +}; + +itShouldBehaveLike(RACPropertySignalExamples, ^{ + return @{ RACPropertySignalExamplesSetupBlock: setupBlock }; +}); + +it(@"should expand the RAC macro properly", ^{ + RACSubject *subject = [RACSubject subject]; + RACTestObject *testObject = [[RACTestObject alloc] init]; + RAC(testObject, objectValue) = subject; + + [subject sendNext:@1]; + expect(testObject.objectValue).to.equal(@1); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACTargetQueueSchedulerSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACTargetQueueSchedulerSpec.m new file mode 100644 index 0000000..b193844 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACTargetQueueSchedulerSpec.m
@@ -0,0 +1,50 @@ +// +// RACTargetQueueSchedulerSpec.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 6/7/13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACTargetQueueScheduler.h" +#import <libkern/OSAtomic.h> + +SpecBegin(RACTargetQueueScheduler) + +it(@"should have a valid current scheduler", ^{ + dispatch_queue_t queue = dispatch_queue_create("test-queue", DISPATCH_QUEUE_SERIAL); + RACScheduler *scheduler = [[RACTargetQueueScheduler alloc] initWithName:@"test-scheduler" targetQueue:queue]; + __block RACScheduler *currentScheduler; + [scheduler schedule:^{ + currentScheduler = RACScheduler.currentScheduler; + }]; + + expect(currentScheduler).will.equal(scheduler); + + dispatch_release(queue); +}); + +it(@"should schedule blocks FIFO even when given a concurrent queue", ^{ + dispatch_queue_t queue = dispatch_queue_create("test-queue", DISPATCH_QUEUE_CONCURRENT); + RACScheduler *scheduler = [[RACTargetQueueScheduler alloc] initWithName:@"test-scheduler" targetQueue:queue]; + __block volatile int32_t startedCount = 0; + __block volatile uint32_t waitInFirst = 1; + [scheduler schedule:^{ + OSAtomicIncrement32Barrier(&startedCount); + while (waitInFirst == 1) ; + }]; + + [scheduler schedule:^{ + OSAtomicIncrement32Barrier(&startedCount); + }]; + + expect(startedCount).will.equal(1); + + OSAtomicAnd32Barrier(0, &waitInFirst); + + expect(startedCount).will.equal(2); + + dispatch_release(queue); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestExampleScheduler.h b/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestExampleScheduler.h new file mode 100644 index 0000000..0470d98 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestExampleScheduler.h
@@ -0,0 +1,15 @@ +// +// RACTestExampleScheduler.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 6/7/13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import <ReactiveCocoa/ReactiveCocoa.h> + +@interface RACTestExampleScheduler : RACQueueScheduler + +- (id)initWithQueue:(dispatch_queue_t)queue; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestExampleScheduler.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestExampleScheduler.m new file mode 100644 index 0000000..859055c --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestExampleScheduler.m
@@ -0,0 +1,39 @@ +// +// RACTestExampleScheduler.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 6/7/13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACTestExampleScheduler.h" +#import "RACQueueScheduler+Subclass.h" + +@implementation RACTestExampleScheduler + +#pragma mark Lifecycle + +- (id)initWithQueue:(dispatch_queue_t)queue { + return [super initWithName:nil queue:queue]; +} + +#pragma mark RACScheduler + +- (RACDisposable *)schedule:(void (^)(void))block { + dispatch_async(self.queue, ^{ + [self performAsCurrentScheduler:block]; + }); + + return nil; +} + +- (RACDisposable *)after:(NSDate *)date schedule:(void (^)(void))block { + dispatch_time_t when = dispatch_time(DISPATCH_TIME_NOW, (int64_t)([date timeIntervalSinceNow] * NSEC_PER_SEC)); + dispatch_after(when, self.queue, ^{ + [self performAsCurrentScheduler:block]; + }); + + return nil; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestObject.h b/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestObject.h new file mode 100644 index 0000000..a963b0a --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestObject.h
@@ -0,0 +1,86 @@ +// +// RACTestObject.h +// ReactiveCocoa +// +// Created by Josh Abernathy on 9/18/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import <Foundation/Foundation.h> + +typedef struct { + long long integerField; + double doubleField; +} RACTestStruct; + +@protocol RACTestProtocol <NSObject> + +@optional +- (void)optionalProtocolMethodWithObjectValue:(id)objectValue; + +@end + +@interface RACTestObject : NSObject <RACTestProtocol> + +@property (nonatomic, strong) id objectValue; +@property (nonatomic, strong) id secondObjectValue; +@property (nonatomic, strong) RACTestObject *strongTestObjectValue; +@property (nonatomic, weak) RACTestObject *weakTestObjectValue; +@property (nonatomic, weak) id<RACTestProtocol> weakObjectWithProtocol; +@property (nonatomic, assign) NSInteger integerValue; +// Holds a copy of the string. +@property (nonatomic, assign) char *charPointerValue; +// Holds a copy of the string. +@property (nonatomic, assign) const char *constCharPointerValue; +@property (nonatomic, assign) CGRect rectValue; +@property (nonatomic, assign) CGSize sizeValue; +@property (nonatomic, assign) CGPoint pointValue; +@property (nonatomic, assign) NSRange rangeValue; +@property (nonatomic, assign) RACTestStruct structValue; +@property (nonatomic, assign) _Bool c99BoolValue; +@property (nonatomic, copy) NSString *stringValue; +@property (nonatomic, copy) NSArray *arrayValue; +@property (nonatomic, copy) NSSet *setValue; +@property (nonatomic, copy) NSOrderedSet *orderedSetValue; +@property (nonatomic, strong) id slowObjectValue; + +// Returns a new object each time, with the integerValue set to 42. +@property (nonatomic, copy, readonly) RACTestObject *dynamicObjectProperty; + +// Returns a new object each time, with the integerValue set to 42. +- (RACTestObject *)dynamicObjectMethod; + +// Whether to allow -setNilValueForKey: to be invoked without throwing an +// exception. +@property (nonatomic, assign) BOOL catchSetNilValueForKey; + +// Has -setObjectValue:andIntegerValue: been called? +@property (nonatomic, assign) BOOL hasInvokedSetObjectValueAndIntegerValue; + +// Has -setObjectValue:andSecondObjectValue: been called? +@property (nonatomic, assign) BOOL hasInvokedSetObjectValueAndSecondObjectValue; + +- (void)setObjectValue:(id)objectValue andIntegerValue:(NSInteger)integerValue; +- (void)setObjectValue:(id)objectValue andSecondObjectValue:(id)secondObjectValue; + +// Returns a string of the form "objectValue: integerValue". +- (NSString *)combineObjectValue:(id)objectValue andIntegerValue:(NSInteger)integerValue; +- (NSString *)combineObjectValue:(id)objectValue andSecondObjectValue:(id)secondObjectValue; + +- (void)lifeIsGood:(id)sender; + ++ (void)lifeIsGood:(id)sender; + +- (NSRange)returnRangeValueWithObjectValue:(id)objectValue andIntegerValue:(NSInteger)integerValue; + +// Writes 5 to the int pointed to by intPointer. +- (void)write5ToIntPointer:(int *)intPointer; + +- (NSInteger)doubleInteger:(NSInteger)integer; +- (char *)doubleString:(char *)string; +- (const char *)doubleConstString:(const char *)string; +- (RACTestStruct)doubleStruct:(RACTestStruct)testStruct; + +- (dispatch_block_t)wrapBlock:(dispatch_block_t)block; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestObject.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestObject.m new file mode 100644 index 0000000..f590703 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestObject.m
@@ -0,0 +1,121 @@ +// +// RACTestObject.m +// ReactiveCocoa +// +// Created by Josh Abernathy on 9/18/12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACTestObject.h" + +@implementation RACTestObject + +- (void)dealloc { + free(_charPointerValue); + free((void *)_constCharPointerValue); +} + +- (void)setNilValueForKey:(NSString *)key { + if (!self.catchSetNilValueForKey) [super setNilValueForKey:key]; +} + +- (void)setCharPointerValue:(char *)charPointerValue { + if (charPointerValue == _charPointerValue) return; + free(_charPointerValue); + _charPointerValue = strdup(charPointerValue); +} + +- (void)setConstCharPointerValue:(const char *)constCharPointerValue { + if (constCharPointerValue == _constCharPointerValue) return; + free((void *)_constCharPointerValue); + _constCharPointerValue = strdup(constCharPointerValue); +} + +- (void)setObjectValue:(id)objectValue andIntegerValue:(NSInteger)integerValue { + self.hasInvokedSetObjectValueAndIntegerValue = YES; + self.objectValue = objectValue; + self.integerValue = integerValue; +} + +- (void)setObjectValue:(id)objectValue andSecondObjectValue:(id)secondObjectValue { + self.hasInvokedSetObjectValueAndSecondObjectValue = YES; + self.objectValue = objectValue; + self.secondObjectValue = secondObjectValue; +} + +- (void)setSlowObjectValue:(id)value { + [NSThread sleepForTimeInterval:0.02]; + _slowObjectValue = value; +} + +- (NSString *)combineObjectValue:(id)objectValue andIntegerValue:(NSInteger)integerValue { + return [NSString stringWithFormat:@"%@: %ld", objectValue, (long)integerValue]; +} + +- (NSString *)combineObjectValue:(id)objectValue andSecondObjectValue:(id)secondObjectValue { + return [NSString stringWithFormat:@"%@: %@", objectValue, secondObjectValue]; +} + +- (void)lifeIsGood:(id)sender { + +} + ++ (void)lifeIsGood:(id)sender { + +} + +- (NSRange)returnRangeValueWithObjectValue:(id)objectValue andIntegerValue:(NSInteger)integerValue { + return NSMakeRange((NSUInteger)[objectValue integerValue], (NSUInteger)integerValue); +} + +- (RACTestObject *)dynamicObjectProperty { + return [self dynamicObjectMethod]; +} + +- (RACTestObject *)dynamicObjectMethod { + RACTestObject *testObject = [[RACTestObject alloc] init]; + testObject.integerValue = 42; + return testObject; +} + +- (void)write5ToIntPointer:(int *)intPointer { + NSCParameterAssert(intPointer != NULL); + *intPointer = 5; +} + +- (NSInteger)doubleInteger:(NSInteger)integer { + return integer * 2; +} + +- (char *)doubleString:(char *)string { + size_t doubledSize = strlen(string) * 2 + 1; + char *doubledString = malloc(sizeof(char) * doubledSize); + + doubledString[0] = '\0'; + strlcat(doubledString, string, doubledSize); + strlcat(doubledString, string, doubledSize); + + dispatch_async(dispatch_get_main_queue(), ^{ + free(doubledString); + }); + + return doubledString; +} + +- (const char *)doubleConstString:(const char *)string { + return [self doubleString:(char *)string]; +} + +- (RACTestStruct)doubleStruct:(RACTestStruct)testStruct { + testStruct.integerField *= 2; + testStruct.doubleField *= 2; + return testStruct; +} + +- (dispatch_block_t)wrapBlock:(dispatch_block_t)block { + return ^{ + block(); + }; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestSchedulerSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestSchedulerSpec.m new file mode 100644 index 0000000..baa8994 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestSchedulerSpec.m
@@ -0,0 +1,175 @@ +// +// RACTestSchedulerSpec.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-07-06. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACTestScheduler.h" + +SpecBegin(RACTestScheduler) + +__block RACTestScheduler *scheduler; + +beforeEach(^{ + scheduler = [[RACTestScheduler alloc] init]; + expect(scheduler).notTo.beNil(); +}); + +it(@"should do nothing when stepping while empty", ^{ + [scheduler step]; + [scheduler step:5]; + [scheduler stepAll]; +}); + +it(@"should execute the earliest enqueued block when stepping", ^{ + __block BOOL firstExecuted = NO; + [scheduler schedule:^{ + firstExecuted = YES; + }]; + + __block BOOL secondExecuted = NO; + [scheduler schedule:^{ + secondExecuted = YES; + }]; + + expect(firstExecuted).to.beFalsy(); + expect(secondExecuted).to.beFalsy(); + + [scheduler step]; + expect(firstExecuted).to.beTruthy(); + expect(secondExecuted).to.beFalsy(); + + [scheduler step]; + expect(secondExecuted).to.beTruthy(); +}); + +it(@"should step multiple times", ^{ + __block BOOL firstExecuted = NO; + [scheduler schedule:^{ + firstExecuted = YES; + }]; + + __block BOOL secondExecuted = NO; + [scheduler schedule:^{ + secondExecuted = YES; + }]; + + __block BOOL thirdExecuted = NO; + [scheduler schedule:^{ + thirdExecuted = YES; + }]; + + expect(firstExecuted).to.beFalsy(); + expect(secondExecuted).to.beFalsy(); + expect(thirdExecuted).to.beFalsy(); + + [scheduler step:2]; + expect(firstExecuted).to.beTruthy(); + expect(secondExecuted).to.beTruthy(); + expect(thirdExecuted).to.beFalsy(); + + [scheduler step:1]; + expect(thirdExecuted).to.beTruthy(); +}); + +it(@"should step through all scheduled blocks", ^{ + __block NSUInteger executions = 0; + for (NSUInteger i = 0; i < 10; i++) { + [scheduler schedule:^{ + executions++; + }]; + } + + expect(executions).to.equal(0); + + [scheduler stepAll]; + expect(executions).to.equal(10); +}); + +it(@"should execute blocks in date order when stepping", ^{ + __block BOOL laterExecuted = NO; + [scheduler after:[NSDate distantFuture] schedule:^{ + laterExecuted = YES; + }]; + + __block BOOL earlierExecuted = NO; + [scheduler after:[NSDate dateWithTimeIntervalSinceNow:20] schedule:^{ + earlierExecuted = YES; + }]; + + expect(earlierExecuted).to.beFalsy(); + expect(laterExecuted).to.beFalsy(); + + [scheduler step]; + expect(earlierExecuted).to.beTruthy(); + expect(laterExecuted).to.beFalsy(); + + [scheduler step]; + expect(laterExecuted).to.beTruthy(); +}); + +it(@"should execute delayed blocks in date order when stepping", ^{ + __block BOOL laterExecuted = NO; + [scheduler afterDelay:100 schedule:^{ + laterExecuted = YES; + }]; + + __block BOOL earlierExecuted = NO; + [scheduler afterDelay:50 schedule:^{ + earlierExecuted = YES; + }]; + + expect(earlierExecuted).to.beFalsy(); + expect(laterExecuted).to.beFalsy(); + + [scheduler step]; + expect(earlierExecuted).to.beTruthy(); + expect(laterExecuted).to.beFalsy(); + + [scheduler step]; + expect(laterExecuted).to.beTruthy(); +}); + +it(@"should execute a repeating blocks in date order", ^{ + __block NSUInteger firstExecutions = 0; + [scheduler after:[NSDate dateWithTimeIntervalSinceNow:20] repeatingEvery:5 withLeeway:0 schedule:^{ + firstExecutions++; + }]; + + __block NSUInteger secondExecutions = 0; + [scheduler after:[NSDate dateWithTimeIntervalSinceNow:22] repeatingEvery:10 withLeeway:0 schedule:^{ + secondExecutions++; + }]; + + expect(firstExecutions).to.equal(0); + expect(secondExecutions).to.equal(0); + + // 20 ticks + [scheduler step]; + expect(firstExecutions).to.equal(1); + expect(secondExecutions).to.equal(0); + + // 22 ticks + [scheduler step]; + expect(firstExecutions).to.equal(1); + expect(secondExecutions).to.equal(1); + + // 25 ticks + [scheduler step]; + expect(firstExecutions).to.equal(2); + expect(secondExecutions).to.equal(1); + + // 30 ticks + [scheduler step]; + expect(firstExecutions).to.equal(3); + expect(secondExecutions).to.equal(1); + + // 32 ticks + [scheduler step]; + expect(firstExecutions).to.equal(3); + expect(secondExecutions).to.equal(2); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestUIButton.h b/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestUIButton.h new file mode 100644 index 0000000..03e9716 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestUIButton.h
@@ -0,0 +1,16 @@ +// +// RACTestUIButton.h +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-06-15. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import <UIKit/UIKit.h> + +// Enables use of -sendActionsForControlEvents: in unit tests. +@interface RACTestUIButton : UIButton + ++ (instancetype)button; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestUIButton.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestUIButton.m new file mode 100644 index 0000000..48b2674 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACTestUIButton.m
@@ -0,0 +1,27 @@ +// +// RACTestUIButton.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-06-15. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACTestUIButton.h" + +@implementation RACTestUIButton + ++ (instancetype)button { + RACTestUIButton *button = [self buttonWithType:UIButtonTypeCustom]; + return button; +} + +// Required for unit testing – controls don't work normally +// outside of normal apps. +-(void)sendAction:(SEL)action to:(id)target forEvent:(UIEvent *)event { +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Warc-performSelector-leaks" + [target performSelector:action withObject:self]; +#pragma clang diagnostic pop +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/RACTupleSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/RACTupleSpec.m new file mode 100644 index 0000000..e85d76d --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/RACTupleSpec.m
@@ -0,0 +1,120 @@ +// +// RACTupleSpec.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-12-12. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import "RACTuple.h" +#import "RACUnit.h" + +SpecBegin(RACTuple) + +describe(@"RACTupleUnpack", ^{ + it(@"should unpack a single value", ^{ + RACTupleUnpack(RACUnit *value) = [RACTuple tupleWithObjects:RACUnit.defaultUnit, nil]; + expect(value).to.equal(RACUnit.defaultUnit); + }); + + it(@"should translate RACTupleNil", ^{ + RACTupleUnpack(id value) = [RACTuple tupleWithObjects:RACTupleNil.tupleNil, nil]; + expect(value).to.beNil(); + }); + + it(@"should unpack multiple values", ^{ + RACTupleUnpack(NSString *str, NSNumber *num) = [RACTuple tupleWithObjects:@"foobar", @5, nil]; + + expect(str).to.equal(@"foobar"); + expect(num).to.equal(@5); + }); + + it(@"should fill in missing values with nil", ^{ + RACTupleUnpack(NSString *str, NSNumber *num) = [RACTuple tupleWithObjects:@"foobar", nil]; + + expect(str).to.equal(@"foobar"); + expect(num).to.beNil(); + }); + + it(@"should skip any values not assigned to", ^{ + RACTupleUnpack(NSString *str, NSNumber *num) = [RACTuple tupleWithObjects:@"foobar", @5, RACUnit.defaultUnit, nil]; + + expect(str).to.equal(@"foobar"); + expect(num).to.equal(@5); + }); + + it(@"should keep an unpacked value alive when captured in a block", ^{ + __weak id weakPtr = nil; + id (^block)(void) = nil; + + @autoreleasepool { + RACTupleUnpack(NSString *str) = [RACTuple tupleWithObjects:[[NSMutableString alloc] init], nil]; + + weakPtr = str; + expect(weakPtr).notTo.beNil(); + + block = [^{ + return str; + } copy]; + } + + expect(weakPtr).notTo.beNil(); + expect(block()).to.equal(weakPtr); + }); +}); + +describe(@"RACTuplePack", ^{ + it(@"should pack a single value", ^{ + RACTuple *tuple = [RACTuple tupleWithObjects:RACUnit.defaultUnit, nil]; + expect(RACTuplePack(RACUnit.defaultUnit)).to.equal(tuple); + }); + + it(@"should translate nil", ^{ + RACTuple *tuple = [RACTuple tupleWithObjects:RACTupleNil.tupleNil, nil]; + expect(RACTuplePack(nil)).to.equal(tuple); + }); + + it(@"should pack multiple values", ^{ + NSString *string = @"foobar"; + NSNumber *number = @5; + RACTuple *tuple = [RACTuple tupleWithObjects:string, number, nil]; + expect(RACTuplePack(string, number)).to.equal(tuple); + }); +}); + +describe(@"-tupleByAddingObject:", ^{ + __block RACTuple *tuple; + + beforeEach(^{ + tuple = RACTuplePack(@"foo", nil, @"bar"); + }); + + it(@"should add a non-nil object", ^{ + RACTuple *newTuple = [tuple tupleByAddingObject:@"buzz"]; + expect(newTuple.count).to.equal(4); + expect(newTuple[0]).to.equal(@"foo"); + expect(newTuple[1]).to.beNil(); + expect(newTuple[2]).to.equal(@"bar"); + expect(newTuple[3]).to.equal(@"buzz"); + }); + + it(@"should add nil", ^{ + RACTuple *newTuple = [tuple tupleByAddingObject:nil]; + expect(newTuple.count).to.equal(4); + expect(newTuple[0]).to.equal(@"foo"); + expect(newTuple[1]).to.beNil(); + expect(newTuple[2]).to.equal(@"bar"); + expect(newTuple[3]).to.beNil(); + }); + + it(@"should add NSNull", ^{ + RACTuple *newTuple = [tuple tupleByAddingObject:NSNull.null]; + expect(newTuple.count).to.equal(4); + expect(newTuple[0]).to.equal(@"foo"); + expect(newTuple[1]).to.beNil(); + expect(newTuple[2]).to.equal(@"bar"); + expect(newTuple[3]).to.equal(NSNull.null); + }); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/ReactiveCocoaTests-Info.plist b/ReactiveCocoaFramework/ReactiveCocoaTests/ReactiveCocoaTests-Info.plist new file mode 100644 index 0000000..d783a87 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/ReactiveCocoaTests-Info.plist
@@ -0,0 +1,22 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> +<plist version="1.0"> +<dict> + <key>CFBundleDevelopmentRegion</key> + <string>en</string> + <key>CFBundleExecutable</key> + <string>${EXECUTABLE_NAME}</string> + <key>CFBundleIdentifier</key> + <string>com.github.${PRODUCT_NAME:rfc1034identifier}</string> + <key>CFBundleInfoDictionaryVersion</key> + <string>6.0</string> + <key>CFBundlePackageType</key> + <string>BNDL</string> + <key>CFBundleShortVersionString</key> + <string>1.0</string> + <key>CFBundleSignature</key> + <string>????</string> + <key>CFBundleVersion</key> + <string>1</string> +</dict> +</plist>
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/ReactiveCocoaTests-Prefix.pch b/ReactiveCocoaFramework/ReactiveCocoaTests/ReactiveCocoaTests-Prefix.pch new file mode 100644 index 0000000..970a36e --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/ReactiveCocoaTests-Prefix.pch
@@ -0,0 +1,14 @@ +// +// ReactiveCocoaTests-Prefix.pch +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2012-11-29. +// Copyright (c) 2012 GitHub, Inc. All rights reserved. +// + +#import <Foundation/Foundation.h> +#import <CoreGraphics/CGGeometry.h> + +#define EXP_SHORTHAND +#import "Specta.h" +#import "Expecta.h"
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIActionSheetRACSupportSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/UIActionSheetRACSupportSpec.m new file mode 100644 index 0000000..a695ea5 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIActionSheetRACSupportSpec.m
@@ -0,0 +1,36 @@ +// +// UIActionSheetRACSupportSpec.m +// ReactiveCocoa +// +// Created by Dave Lee on 2013-06-22. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACSignal.h" +#import "RACSignal+Operations.h" +#import "UIActionSheet+RACSignalSupport.h" + +SpecBegin(UIActionSheetRACSupportSpec) + +describe(@"-rac_buttonClickedSignal", ^{ + __block UIActionSheet *actionSheet; + + beforeEach(^{ + actionSheet = [[UIActionSheet alloc] init]; + [actionSheet addButtonWithTitle:@"Button 0"]; + [actionSheet addButtonWithTitle:@"Button 1"]; + expect(actionSheet).notTo.beNil(); + }); + + it(@"should send the index of the clicked button", ^{ + __block NSNumber *index = nil; + [actionSheet.rac_buttonClickedSignal subscribeNext:^(NSNumber *i) { + index = i; + }]; + + [actionSheet.delegate actionSheet:actionSheet clickedButtonAtIndex:1]; + expect(index).to.equal(@1); + }); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIAlertViewRACSupportSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/UIAlertViewRACSupportSpec.m new file mode 100644 index 0000000..f37294e --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIAlertViewRACSupportSpec.m
@@ -0,0 +1,34 @@ +// +// UIAlertViewRACSupportSpec.m +// ReactiveCocoa +// +// Created by Henrik Hodne on 6/16/13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import <objc/message.h> +#import "RACSignal.h" +#import "UIAlertView+RACSignalSupport.h" + +SpecBegin(UIAlertViewRACSupport) + +describe(@"UIAlertView", ^{ + __block UIAlertView *alertView; + + beforeEach(^{ + alertView = [[UIAlertView alloc] initWithFrame:CGRectZero]; + expect(alertView).notTo.beNil(); + }); + + it(@"sends the index of the clicked button to the buttonClickedSignal when a button is clicked", ^{ + __block NSInteger index = -1; + [alertView.rac_buttonClickedSignal subscribeNext:^(NSNumber *sentIndex) { + index = sentIndex.integerValue; + }]; + + [alertView.delegate alertView:alertView clickedButtonAtIndex:2]; + expect(index).to.equal(2); + }); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIBarButtonItemRACSupportSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/UIBarButtonItemRACSupportSpec.m new file mode 100644 index 0000000..089630b --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIBarButtonItemRACSupportSpec.m
@@ -0,0 +1,40 @@ +// +// UIBarButtonItemRACSupportSpec.m +// ReactiveCocoa +// +// Created by Kyle LeNeau on 4/13/13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACControlCommandExamples.h" + +#import "UIBarButtonItem+RACCommandSupport.h" +#import "RACCommand.h" +#import "RACDisposable.h" + +SpecBegin(UIBarButtonItemRACSupport) + +describe(@"UIBarButtonItem", ^{ + __block UIBarButtonItem *button; + + beforeEach(^{ + button = [[UIBarButtonItem alloc] init]; + expect(button).notTo.beNil(); + }); + + itShouldBehaveLike(RACControlCommandExamples, ^{ + return @{ + RACControlCommandExampleControl: button, + RACControlCommandExampleActivateBlock: ^(UIBarButtonItem *button) { + NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:[button.target methodSignatureForSelector:button.action]]; + invocation.selector = button.action; + + id target = button.target; + [invocation setArgument:&target atIndex:2]; + [invocation invokeWithTarget:target]; + } + }; + }); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIButtonRACSupportSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/UIButtonRACSupportSpec.m new file mode 100644 index 0000000..0fefa92 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIButtonRACSupportSpec.m
@@ -0,0 +1,39 @@ +// +// UIButtonRACSupportSpec.m +// ReactiveCocoa +// +// Created by Ash Furrow on 2013-06-06. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACControlCommandExamples.h" +#import "RACTestUIButton.h" + +#import "UIButton+RACCommandSupport.h" +#import "RACCommand.h" +#import "RACDisposable.h" + +SpecBegin(UIButtonRACSupport) + +describe(@"UIButton", ^{ + __block UIButton *button; + + beforeEach(^{ + button = [RACTestUIButton button]; + expect(button).notTo.beNil(); + }); + + itShouldBehaveLike(RACControlCommandExamples, ^{ + return @{ + RACControlCommandExampleControl: button, + RACControlCommandExampleActivateBlock: ^(UIButton *button) { + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Warc-performSelector-leaks" + [button sendActionsForControlEvents:UIControlEventTouchUpInside]; + #pragma clang diagnostic pop + } + }; + }); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIControlRACSupportSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/UIControlRACSupportSpec.m new file mode 100644 index 0000000..4aaf68c --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIControlRACSupportSpec.m
@@ -0,0 +1,105 @@ +// +// UIControlRACSupportSpec.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-06-15. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACTestUIButton.h" + +#import "EXTKeyPathCoding.h" +#import "NSObject+RACDeallocating.h" +#import "RACChannelExamples.h" +#import "RACCompoundDisposable.h" +#import "RACDisposable.h" +#import "RACSignal.h" +#import "UIControl+RACSignalSupport.h" +#import "UISlider+RACSignalSupport.h" + +SpecBegin(UIControlRACSupport) + +void (^setViewValueBlock)(UISlider *, NSNumber *) = ^(UISlider *view, NSNumber *value) { + view.value = value.floatValue; + + // UIControlEvents don't trigger from programmatic modification. Do it + // manually. + for (id target in view.allTargets) { + // Control events are a mask, but UIControlEventAllEvents doesn't seem to + // match anything, 0 does. + for (NSString *selectorString in [view actionsForTarget:target forControlEvent:0]) { + SEL selector = NSSelectorFromString(selectorString); + + NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:[target methodSignatureForSelector:selector]]; + invocation.selector = selector; + UIEvent *event = nil; + [invocation setArgument:&event atIndex:2]; + + [invocation invokeWithTarget:target]; + } + } +}; + +itShouldBehaveLike(RACViewChannelExamples, ^{ + return @{ + RACViewChannelExampleCreateViewBlock: ^{ + return [[UISlider alloc] init]; + }, + RACViewChannelExampleCreateTerminalBlock: ^(UISlider *view) { + return [view rac_newValueChannelWithNilValue:@0.0]; + }, + RACViewChannelExampleKeyPath: @keypath(UISlider.new, value), + RACViewChannelExampleSetViewValueBlock: setViewValueBlock + }; +}); + +it(@"should send on the returned signal when matching actions are sent", ^{ + UIControl *control = [RACTestUIButton button]; + expect(control).notTo.beNil(); + + __block NSUInteger receivedCount = 0; + [[control + rac_signalForControlEvents:UIControlEventTouchUpInside | UIControlEventTouchUpOutside] + subscribeNext:^(UIControl *sender) { + expect(sender).to.beIdenticalTo(control); + receivedCount++; + }]; + + expect(receivedCount).to.equal(0); + + [control sendActionsForControlEvents:UIControlEventTouchUpInside]; + expect(receivedCount).to.equal(1); + + // Should do nothing. + [control sendActionsForControlEvents:UIControlEventTouchDown]; + expect(receivedCount).to.equal(1); + + [control sendActionsForControlEvents:UIControlEventTouchUpOutside]; + expect(receivedCount).to.equal(2); +}); + +it(@"should send completed when the control is deallocated", ^{ + __block BOOL completed = NO; + __block BOOL deallocated = NO; + + @autoreleasepool { + UIControl *control __attribute__((objc_precise_lifetime)) = [RACTestUIButton button]; + [control.rac_deallocDisposable addDisposable:[RACDisposable disposableWithBlock:^{ + deallocated = YES; + }]]; + + [[control + rac_signalForControlEvents:UIControlEventTouchDown] + subscribeCompleted:^{ + completed = YES; + }]; + + expect(deallocated).to.beFalsy(); + expect(completed).to.beFalsy(); + } + + expect(deallocated).to.beTruthy(); + expect(completed).to.beTruthy(); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/Default-568h@2x.png b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/Default-568h@2x.png new file mode 100644 index 0000000..0891b7a --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/Default-568h@2x.png Binary files differ
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/Default.png b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/Default.png new file mode 100644 index 0000000..4c8ca6f --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/Default.png Binary files differ
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/Default@2x.png b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/Default@2x.png new file mode 100644 index 0000000..35b84cf --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/Default@2x.png Binary files differ
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/RACAppDelegate.h b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/RACAppDelegate.h new file mode 100644 index 0000000..88abcec --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/RACAppDelegate.h
@@ -0,0 +1,17 @@ +// +// RACAppDelegate.h +// ReactiveCocoa-iOS-UIKitTestHost +// +// Created by Andrew Mackenzie-Ross on 27/06/13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import <UIKit/UIKit.h> + +@interface RACAppDelegate : UIResponder <UIApplicationDelegate> + +@property (nonatomic, strong) UIWindow *window; + ++ (instancetype)delegate; + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/RACAppDelegate.m b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/RACAppDelegate.m new file mode 100644 index 0000000..6af5af8 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/RACAppDelegate.m
@@ -0,0 +1,24 @@ +// +// RACAppDelegate.m +// ReactiveCocoa-iOS-UIKitTestHost +// +// Created by Andrew Mackenzie-Ross on 27/06/13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACAppDelegate.h" + +@implementation RACAppDelegate + ++ (instancetype)delegate { + return (id)UIApplication.sharedApplication.delegate; +} + +- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions { + self.window = [[UIWindow alloc] initWithFrame:UIScreen.mainScreen.bounds]; + [self.window makeKeyAndVisible]; + + return YES; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/RACTestTableViewController.h b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/RACTestTableViewController.h new file mode 100644 index 0000000..a4163aa --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/RACTestTableViewController.h
@@ -0,0 +1,13 @@ +// +// RACTestTableViewController.h +// ReactiveCocoa +// +// Created by Syo Ikeda on 12/30/13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import <UIKit/UIKit.h> + +@interface RACTestTableViewController : UITableViewController + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/RACTestTableViewController.m b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/RACTestTableViewController.m new file mode 100644 index 0000000..0a9d496 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/RACTestTableViewController.m
@@ -0,0 +1,39 @@ +// +// RACTestTableViewController.m +// ReactiveCocoa +// +// Created by Syo Ikeda on 12/30/13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACTestTableViewController.h" + +@implementation RACTestTableViewController + +- (instancetype)initWithStyle:(UITableViewStyle)style { + self = [super initWithStyle:style]; + if (self == nil) return nil; + + [self.tableView registerClass:UITableViewHeaderFooterView.class forHeaderFooterViewReuseIdentifier:NSStringFromClass(self.class)]; + + return self; +} + +- (UIView *)tableView:(UITableView *)tableView viewForHeaderInSection:(NSInteger)section { + UITableViewHeaderFooterView *headerView = [tableView dequeueReusableHeaderFooterViewWithIdentifier:NSStringFromClass(self.class)]; + return headerView; +} + +- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath { + return [tableView dequeueReusableCellWithIdentifier:NSStringFromClass(self.class)] ?: [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:NSStringFromClass(self.class)]; +} + +- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView { + return 2; +} + +- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section { + return 20; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/ReactiveCocoa-iOS-UIKitTestHost-Info.plist b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/ReactiveCocoa-iOS-UIKitTestHost-Info.plist new file mode 100644 index 0000000..9d6f424 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/ReactiveCocoa-iOS-UIKitTestHost-Info.plist
@@ -0,0 +1,45 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> +<plist version="1.0"> +<dict> + <key>CFBundleDevelopmentRegion</key> + <string>en</string> + <key>CFBundleDisplayName</key> + <string>${PRODUCT_NAME}</string> + <key>CFBundleExecutable</key> + <string>${EXECUTABLE_NAME}</string> + <key>CFBundleIdentifier</key> + <string>com.reactivecocoa.${PRODUCT_NAME:rfc1034identifier}</string> + <key>CFBundleInfoDictionaryVersion</key> + <string>6.0</string> + <key>CFBundleName</key> + <string>${PRODUCT_NAME}</string> + <key>CFBundlePackageType</key> + <string>APPL</string> + <key>CFBundleShortVersionString</key> + <string>1.0</string> + <key>CFBundleSignature</key> + <string>????</string> + <key>CFBundleVersion</key> + <string>1.0</string> + <key>LSRequiresIPhoneOS</key> + <true/> + <key>UIRequiredDeviceCapabilities</key> + <array> + <string>armv7</string> + </array> + <key>UISupportedInterfaceOrientations</key> + <array> + <string>UIInterfaceOrientationPortrait</string> + <string>UIInterfaceOrientationLandscapeLeft</string> + <string>UIInterfaceOrientationLandscapeRight</string> + </array> + <key>UISupportedInterfaceOrientations~ipad</key> + <array> + <string>UIInterfaceOrientationPortrait</string> + <string>UIInterfaceOrientationPortraitUpsideDown</string> + <string>UIInterfaceOrientationLandscapeLeft</string> + <string>UIInterfaceOrientationLandscapeRight</string> + </array> +</dict> +</plist>
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/ReactiveCocoa-iOS-UIKitTestHost-Prefix.pch b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/ReactiveCocoa-iOS-UIKitTestHost-Prefix.pch new file mode 100644 index 0000000..d6ec33c --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/ReactiveCocoa-iOS-UIKitTestHost-Prefix.pch
@@ -0,0 +1,14 @@ +// +// Prefix header for all source files of the 'ReactiveCocoa-iOS-UIKitTestHost' target in the 'ReactiveCocoa-iOS-UIKitTestHost' project +// + +#import <Availability.h> + +#ifndef __IPHONE_3_0 +#warning "This project uses features only available in iOS SDK 3.0 and later." +#endif + +#ifdef __OBJC__ + #import <UIKit/UIKit.h> + #import <Foundation/Foundation.h> +#endif
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/en.lproj/InfoPlist.strings b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/en.lproj/InfoPlist.strings new file mode 100644 index 0000000..477b28f --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/en.lproj/InfoPlist.strings
@@ -0,0 +1,2 @@ +/* Localized versions of Info.plist keys */ +
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/main.m b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/main.m new file mode 100644 index 0000000..7dfdd3f --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTestHost/main.m
@@ -0,0 +1,18 @@ +// +// main.m +// ReactiveCocoa-iOS-UIKitTestHost +// +// Created by Andrew Mackenzie-Ross on 27/06/13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import <UIKit/UIKit.h> + +#import "RACAppDelegate.h" + +int main(int argc, char *argv[]) +{ + @autoreleasepool { + return UIApplicationMain(argc, argv, nil, NSStringFromClass([RACAppDelegate class])); + } +}
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/ReactiveCocoa-iOS-UIKitTest-Prefix.pch b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/ReactiveCocoa-iOS-UIKitTest-Prefix.pch new file mode 100644 index 0000000..97b985e --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/ReactiveCocoa-iOS-UIKitTest-Prefix.pch
@@ -0,0 +1,2 @@ +#import "ReactiveCocoa-iOS-UIKitTest-Prefix.pch" +#import "ReactiveCocoaTests-Prefix.pch"
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/ReactiveCocoa-iOS-UIKitTestHostTests-Info.plist b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/ReactiveCocoa-iOS-UIKitTestHostTests-Info.plist new file mode 100644 index 0000000..efa4ce0 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/ReactiveCocoa-iOS-UIKitTestHostTests-Info.plist
@@ -0,0 +1,22 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> +<plist version="1.0"> +<dict> + <key>CFBundleDevelopmentRegion</key> + <string>en</string> + <key>CFBundleExecutable</key> + <string>${EXECUTABLE_NAME}</string> + <key>CFBundleIdentifier</key> + <string>com.reactivecocoa.${PRODUCT_NAME:rfc1034identifier}</string> + <key>CFBundleInfoDictionaryVersion</key> + <string>6.0</string> + <key>CFBundlePackageType</key> + <string>BNDL</string> + <key>CFBundleShortVersionString</key> + <string>1.0</string> + <key>CFBundleSignature</key> + <string>????</string> + <key>CFBundleVersion</key> + <string>1</string> +</dict> +</plist>
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/UICollectionReusableViewRACSupportSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/UICollectionReusableViewRACSupportSpec.m new file mode 100644 index 0000000..5ffe160 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/UICollectionReusableViewRACSupportSpec.m
@@ -0,0 +1,73 @@ +// +// UICollectionViewCellRACSupportSpec.m +// ReactiveCocoa +// +// Created by Kent Wong on 2013-10-04. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACAppDelegate.h" + +#import "RACSignal.h" +#import "RACUnit.h" +#import "UICollectionReusableView+RACSignalSupport.h" + +@interface TestCollectionViewController : UICollectionViewController +@end + +SpecBegin(UICollectionReusableViewRACSupport) + +__block UICollectionViewFlowLayout *collectionViewFlowLayout; +__block TestCollectionViewController *collectionViewController; + +beforeEach(^{ + collectionViewFlowLayout = [[UICollectionViewFlowLayout alloc] init]; + CGSize screenSize = UIScreen.mainScreen.bounds.size; + collectionViewFlowLayout.itemSize = CGSizeMake(screenSize.width, screenSize.height / 2); + + collectionViewController = [[TestCollectionViewController alloc] initWithCollectionViewLayout:collectionViewFlowLayout]; + expect(collectionViewController).notTo.beNil(); + + [collectionViewController.collectionView registerClass:UICollectionViewCell.class forCellWithReuseIdentifier:NSStringFromClass(collectionViewController.class)]; + + RACAppDelegate.delegate.window.rootViewController = collectionViewController; + expect(collectionViewController.collectionView.visibleCells.count).will.beGreaterThan(0); +}); + +it(@"should send on rac_prepareForReuseSignal", ^{ + UICollectionViewCell *cell = collectionViewController.collectionView.visibleCells[0]; + + __block NSUInteger invocationCount = 0; + [cell.rac_prepareForReuseSignal subscribeNext:^(id value) { + expect(value).to.equal(RACUnit.defaultUnit); + ++invocationCount; + }]; + + expect(invocationCount).to.equal(0); + + // The following two expectations will fail in the iOS 7 simulator, but pass on an iPad 4th gen device running iOS 7. + // This appears to be a known issue with the iOS 7 simulator. See http://openradar.appspot.com/14973972 + // These tests will pass with iOS 6.0 and 6.1. + if ([UIDevice.currentDevice.systemVersion compare:@"7.0" options:NSNumericSearch] == NSOrderedAscending || + (!TARGET_IPHONE_SIMULATOR && UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad)) { + [collectionViewController.collectionView reloadData]; + expect(invocationCount).will.equal(1); + + [collectionViewController.collectionView reloadData]; + expect(invocationCount).will.equal(2); + } +}); + +SpecEnd + +@implementation TestCollectionViewController + +- (UICollectionViewCell *)collectionView:(UICollectionView *)collectionView cellForItemAtIndexPath:(NSIndexPath *)indexPath { + return [collectionView dequeueReusableCellWithReuseIdentifier:NSStringFromClass(self.class) forIndexPath:indexPath]; +} + +- (NSInteger)collectionView:(UICollectionView *)collectionView numberOfItemsInSection:(NSInteger)section { + return 20; +} + +@end
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/UITableViewCellRACSupportSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/UITableViewCellRACSupportSpec.m new file mode 100644 index 0000000..2a69143 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/UITableViewCellRACSupportSpec.m
@@ -0,0 +1,46 @@ +// +// UITableViewCellRACSupportSpec.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-07-23. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACAppDelegate.h" +#import "RACTestTableViewController.h" + +#import "RACSignal.h" +#import "RACUnit.h" +#import "UITableViewCell+RACSignalSupport.h" + +SpecBegin(UITableViewCellRACSupport) + +__block RACTestTableViewController *tableViewController; + +beforeEach(^{ + tableViewController = [[RACTestTableViewController alloc] initWithStyle:UITableViewStylePlain]; + expect(tableViewController).notTo.beNil(); + + RACAppDelegate.delegate.window.rootViewController = tableViewController; + expect(tableViewController.tableView.visibleCells.count).will.beGreaterThan(0); +}); + +it(@"should send on rac_prepareForReuseSignal", ^{ + UITableViewCell *cell = tableViewController.tableView.visibleCells[0]; + + __block NSUInteger invocationCount = 0; + [cell.rac_prepareForReuseSignal subscribeNext:^(id value) { + expect(value).to.equal(RACUnit.defaultUnit); + invocationCount++; + }]; + + expect(invocationCount).to.equal(0); + + [tableViewController.tableView reloadData]; + expect(invocationCount).will.equal(1); + + [tableViewController.tableView reloadData]; + expect(invocationCount).will.equal(2); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/UITableViewHeaderFooterViewRACSupportSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/UITableViewHeaderFooterViewRACSupportSpec.m new file mode 100644 index 0000000..4658ae9 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/UITableViewHeaderFooterViewRACSupportSpec.m
@@ -0,0 +1,51 @@ +// +// UITableViewHeaderFooterViewRACSupportSpec.m +// ReactiveCocoa +// +// Created by Syo Ikeda on 12/30/13. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACAppDelegate.h" +#import "RACTestTableViewController.h" + +#import "RACSignal.h" +#import "RACUnit.h" +#import "UITableViewHeaderFooterView+RACSignalSupport.h" + +SpecBegin(UITableViewHeaderFooterViewRACSupportSpec) + +__block RACTestTableViewController *tableViewController; + +beforeEach(^{ + tableViewController = [[RACTestTableViewController alloc] initWithStyle:UITableViewStylePlain]; + expect(tableViewController).notTo.beNil(); + + RACAppDelegate.delegate.window.rootViewController = tableViewController; + expect([tableViewController.tableView headerViewForSection:0]).notTo.beNil(); +}); + +it(@"should send on rac_prepareForReuseSignal", ^{ + UITableViewHeaderFooterView *headerView = [tableViewController.tableView headerViewForSection:0]; + + __block NSUInteger invocationCount = 0; + [headerView.rac_prepareForReuseSignal subscribeNext:^(id value) { + expect(value).to.equal(RACUnit.defaultUnit); + invocationCount++; + }]; + + expect(invocationCount).to.equal(0); + + void (^scrollToSectionForReuse)(NSInteger) = ^(NSInteger section) { + NSIndexPath *indexPath = [NSIndexPath indexPathForRow:0 inSection:section]; + [tableViewController.tableView scrollToRowAtIndexPath:indexPath atScrollPosition:UITableViewScrollPositionTop animated:NO]; + }; + + scrollToSectionForReuse(tableViewController.tableView.numberOfSections - 1); + expect(invocationCount).will.equal(1); + + scrollToSectionForReuse(0); + expect(invocationCount).will.equal(2); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/UITextFieldRACSupportSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/UITextFieldRACSupportSpec.m new file mode 100644 index 0000000..0aeb49c --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/UITextFieldRACSupportSpec.m
@@ -0,0 +1,53 @@ +// +// UITextFieldRACSupportSpec.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-06-22. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACSignal.h" +#import "RACSignal+Operations.h" +#import "UITextField+RACSignalSupport.h" + +SpecBegin(UITextFieldRACSupport) + +describe(@"-rac_textSignal", ^{ + __block UITextField *textField; + + beforeEach(^{ + textField = [[UITextField alloc] initWithFrame:CGRectMake(0, 0, 100, 20)]; + expect(textField).notTo.beNil(); + }); + + it(@"should start with the initial text", ^{ + textField.text = @"foo"; + + RACSignal *textSignal = textField.rac_textSignal; + expect([textSignal first]).to.equal(@"foo"); + + textField.text = @"bar"; + expect([textSignal first]).to.equal(@"bar"); + }); + + it(@"should clear text upon editing", ^{ + textField.text = @"foo"; + textField.clearsOnBeginEditing = YES; + + UIWindow *win = [UIWindow new]; + [win addSubview:textField]; + + __block NSString *str = @"bar"; + + RACSignal *textSignal = textField.rac_textSignal; + [textSignal subscribeNext:^(id x) { + str = x; + }]; + expect(str).to.equal(@"foo"); + + [textField becomeFirstResponder]; + expect(str).to.equal(@""); + }); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/UITextViewRACSupportSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/UITextViewRACSupportSpec.m new file mode 100644 index 0000000..f46e17a --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/UITextViewRACSupportSpec.m
@@ -0,0 +1,34 @@ +// +// UITextViewRACSupportSpec.m +// ReactiveCocoa +// +// Created by Justin Spahr-Summers on 2013-06-22. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "RACSignal.h" +#import "RACSignal+Operations.h" +#import "UITextView+RACSignalSupport.h" + +SpecBegin(UITextViewRACSupport) + +describe(@"-rac_textSignal", ^{ + __block UITextView *textView; + + beforeEach(^{ + textView = [[UITextView alloc] initWithFrame:CGRectMake(0, 0, 100, 20)]; + expect(textView).notTo.beNil(); + }); + + it(@"should start with the initial text", ^{ + textView.text = @"foo"; + + RACSignal *textSignal = textView.rac_textSignal; + expect([textSignal first]).to.equal(@"foo"); + + textView.text = @"bar"; + expect([textSignal first]).to.equal(@"bar"); + }); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/en.lproj/InfoPlist.strings b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/en.lproj/InfoPlist.strings new file mode 100644 index 0000000..477b28f --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIKit/UIKitTests/en.lproj/InfoPlist.strings
@@ -0,0 +1,2 @@ +/* Localized versions of Info.plist keys */ +
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/UIRefreshControlRACSupportSpec.m b/ReactiveCocoaFramework/ReactiveCocoaTests/UIRefreshControlRACSupportSpec.m new file mode 100644 index 0000000..0a9b651 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/UIRefreshControlRACSupportSpec.m
@@ -0,0 +1,68 @@ +// +// UIRefreshControlRACSupportSpec.m +// ReactiveCocoa +// +// Created by Dave Lee on 2013-10-17. +// Copyright (c) 2013 GitHub, Inc. All rights reserved. +// + +#import "UIRefreshControl+RACCommandSupport.h" +#import "NSObject+RACSelectorSignal.h" +#import "RACControlCommandExamples.h" +#import "RACCommand.h" +#import "RACSignal.h" + +SpecBegin(UIRefreshControlRACSupport) + +describe(@"UIRefreshControl", ^{ + __block UIRefreshControl *refreshControl; + + beforeEach(^{ + refreshControl = [[UIRefreshControl alloc] init]; + expect(refreshControl).notTo.beNil(); + }); + + itShouldBehaveLike(RACControlCommandExamples, ^{ + return @{ + RACControlCommandExampleControl: refreshControl, + RACControlCommandExampleActivateBlock: ^(UIRefreshControl *refreshControl) { + [refreshControl sendActionsForControlEvents:UIControlEventValueChanged]; + } + }; + }); + + describe(@"finishing", ^{ + __block RACSignal *commandSignal; + __block BOOL refreshingEnded; + + beforeEach(^{ + refreshControl.rac_command = [[RACCommand alloc] initWithSignalBlock:^(id _) { + return commandSignal; + }]; + + // Just -rac_signalForSelector: posing as a mock. + refreshingEnded = NO; + [[refreshControl + rac_signalForSelector:@selector(endRefreshing)] + subscribeNext:^(id _) { + refreshingEnded = YES; + }]; + }); + + it(@"should call -endRefreshing upon completion", ^{ + commandSignal = [RACSignal empty]; + + [refreshControl sendActionsForControlEvents:UIControlEventValueChanged]; + expect(refreshingEnded).will.beTruthy(); + }); + + it(@"should call -endRefreshing upon error", ^{ + commandSignal = [RACSignal error:[NSError errorWithDomain:@"" code:1 userInfo:nil]]; + + [refreshControl sendActionsForControlEvents:UIControlEventValueChanged]; + expect(refreshingEnded).will.beTruthy(); + }); + }); +}); + +SpecEnd
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/en.lproj/InfoPlist.strings b/ReactiveCocoaFramework/ReactiveCocoaTests/en.lproj/InfoPlist.strings new file mode 100644 index 0000000..477b28f --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/en.lproj/InfoPlist.strings
@@ -0,0 +1,2 @@ +/* Localized versions of Info.plist keys */ +
diff --git a/ReactiveCocoaFramework/ReactiveCocoaTests/test-data.json b/ReactiveCocoaFramework/ReactiveCocoaTests/test-data.json new file mode 100644 index 0000000..0599ee5 --- /dev/null +++ b/ReactiveCocoaFramework/ReactiveCocoaTests/test-data.json
@@ -0,0 +1,5 @@ +[ + { "item": 1 }, + { "item": 2 }, + { "item": 3 } +]
diff --git a/script/LICENSE.md b/script/LICENSE.md new file mode 100644 index 0000000..8d92384 --- /dev/null +++ b/script/LICENSE.md
@@ -0,0 +1,18 @@ +**Copyright (c) 2013 Justin Spahr-Summers** + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software is furnished to do so, +subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/script/README.md b/script/README.md new file mode 100644 index 0000000..f66206f --- /dev/null +++ b/script/README.md
@@ -0,0 +1,82 @@ +# objc-build-scripts + +This project is a collection of scripts created with two goals: + + 1. To standardize how Objective-C projects are bootstrapped after cloning + 1. To easily build Objective-C projects on continuous integration servers + +## Scripts + +Right now, there are two important scripts: [`bootstrap`](#bootstrap) and +[`cibuild`](#cibuild). Both are Bash scripts, to maximize compatibility and +eliminate pesky system configuration issues (like setting up a working Ruby +environment). + +The structure of the scripts on disk is meant to follow that of a typical Ruby +project: + +``` +script/ + bootstrap + cibuild +``` + +### bootstrap + +This script is responsible for bootstrapping (initializing) your project after +it's been checked out. Here, you should install or clone any dependencies that +are required for a working build and development environment. + +By default, the script will verify that [xctool][] is installed, then initialize +and update submodules recursively. If any submodules contain `script/bootstrap`, +that will be run as well. + +To check that other tools are installed, you can set the `REQUIRED_TOOLS` +environment variable before running `script/bootstrap`, or edit it within the +script directly. Note that no installation is performed automatically, though +this can always be added within your specific project. + +### cibuild + +This script is responsible for building the project, as you would want it built +for continuous integration. This is preferable to putting the logic on the CI +server itself, since it ensures that any changes are versioned along with the +source. + +By default, the script will run [`bootstrap`](#bootstrap), look for any Xcode +workspace or project in the working directory, then build all targets/schemes +(as found by `xcodebuild -list`) using [xctool][]. + +You can also specify the schemes to build by passing them into the script: + +```sh +script/cibuild ReactiveCocoa-Mac ReactiveCocoa-iOS +``` + +As with the `bootstrap` script, there are several environment variables that can +be used to customize behavior. They can be set on the command line before +invoking the script, or the defaults changed within the script directly. + +## Getting Started + +To add the scripts to your project, read the contents of this repository into +a `script` folder: + +``` +$ git remote add objc-build-scripts https://github.com/jspahrsummers/objc-build-scripts.git +$ git fetch objc-build-scripts +$ git read-tree --prefix=script/ -u objc-build-scripts/master +``` + +Then commit the changes, to incorporate the scripts into your own repository's +history. You can also freely tweak the scripts for your specific project's +needs. + +To merge in upstream changes later: + +``` +$ git fetch -p objc-build-scripts +$ git merge --ff --squash -Xsubtree=script objc-build-scripts/master +``` + +[xctool]: https://github.com/facebook/xctool
diff --git a/script/bootstrap b/script/bootstrap new file mode 100755 index 0000000..89cbb8e --- /dev/null +++ b/script/bootstrap
@@ -0,0 +1,80 @@ +#!/bin/bash + +export SCRIPT_DIR=$(dirname "$0") + +## +## Configuration Variables +## + +config () +{ + # A whitespace-separated list of executables that must be present and locatable. + : ${REQUIRED_TOOLS="xctool"} + + export REQUIRED_TOOLS +} + +## +## Bootstrap Process +## + +main () +{ + config + + if [ -n "$REQUIRED_TOOLS" ] + then + echo "*** Checking dependencies..." + check_deps + fi + + local submodules=$(git submodule status) + local result=$? + + if [ "$result" -ne "0" ] + then + exit $result + fi + + if [ -n "$submodules" ] + then + echo "*** Updating submodules..." + update_submodules + fi +} + +check_deps () +{ + for tool in $REQUIRED_TOOLS + do + which -s "$tool" + if [ "$?" -ne "0" ] + then + echo "*** Error: $tool not found. Please install it and bootstrap again." + exit 1 + fi + done +} + +bootstrap_submodule () +{ + local bootstrap="script/bootstrap" + + if [ -e "$bootstrap" ] + then + echo "*** Bootstrapping $name..." + "$bootstrap" >/dev/null + else + update_submodules + fi +} + +update_submodules () +{ + git submodule sync --quiet && git submodule update --init && git submodule foreach --quiet bootstrap_submodule +} + +export -f bootstrap_submodule +export -f update_submodules + +main
diff --git a/script/cibuild b/script/cibuild new file mode 100755 index 0000000..a604019 --- /dev/null +++ b/script/cibuild
@@ -0,0 +1,156 @@ +#!/bin/bash + +export SCRIPT_DIR=$(dirname "$0") + +## +## Configuration Variables +## + +SCHEMES="$@" + +config () +{ + # The workspace to build. + # + # If not set and no workspace is found, the -workspace flag will not be passed + # to `xctool`. + # + # Only one of `XCWORKSPACE` and `XCODEPROJ` needs to be set. The former will + # take precedence. + : ${XCWORKSPACE=} + + # The project to build. + # + # If not set and no project is found, the -project flag will not be passed + # to `xctool`. + # + # Only one of `XCWORKSPACE` and `XCODEPROJ` needs to be set. The former will + # take precedence. + : ${XCODEPROJ="ReactiveCocoaFramework/ReactiveCocoa.xcodeproj"} + + # A bootstrap script to run before building. + # + # If this file does not exist, it is not considered an error. + : ${BOOTSTRAP="$SCRIPT_DIR/bootstrap"} + + # Extra options to pass to xctool. + : ${XCTOOL_OPTIONS="RUN_CLANG_STATIC_ANALYZER=NO"} + + # A whitespace-separated list of default schemes to build. + # + # Individual names can be quoted to avoid word splitting. + : ${SCHEMES:=$(xcodebuild -list -project "$XCODEPROJ" 2>/dev/null | awk -f "$SCRIPT_DIR/schemes.awk")} + + export XCWORKSPACE + export XCODEPROJ + export BOOTSTRAP + export XCTOOL_OPTIONS + export SCHEMES +} + +## +## Build Process +## + +main () +{ + config + + if [ -f "$BOOTSTRAP" ] + then + echo "*** Bootstrapping..." + "$BOOTSTRAP" || exit $? + fi + + echo "*** The following schemes will be built:" + echo "$SCHEMES" | xargs -n 1 echo " " + echo + + echo "$SCHEMES" | xargs -n 1 | ( + local status=0 + + while read scheme + do + build_scheme "$scheme" || status=1 + done + + exit $status + ) +} + +find_pattern () +{ + ls -d $1 2>/dev/null | head -n 1 +} + +run_xctool () +{ + if [ -n "$XCWORKSPACE" ] + then + xctool -workspace "$XCWORKSPACE" $XCTOOL_OPTIONS "$@" 2>&1 + elif [ -n "$XCODEPROJ" ] + then + xctool -project "$XCODEPROJ" $XCTOOL_OPTIONS "$@" 2>&1 + else + echo "*** No workspace or project file found." + exit 1 + fi +} + +parse_build () +{ + awk -f "$SCRIPT_DIR/xctool.awk" 2>&1 >/dev/null +} + +build_scheme () +{ + local scheme=$1 + + echo "*** Cleaning $scheme..." + run_xctool -scheme "$scheme" clean >/dev/null || exit $? + + echo "*** Building and testing $scheme..." + echo + + local sdkflag= + local action=test + + # Determine whether we can run unit tests for this target. + run_xctool -scheme "$scheme" run-tests | parse_build + + local awkstatus=$? + + if [ "$awkstatus" -ne "0" ] + then + # Unit tests aren't supported. + action=build + fi + + if [ "$awkstatus" -eq "1" ] + then + # Build for iOS. + sdkflag="-sdk iphonesimulator" + fi + + run_xctool $sdkflag -scheme "$scheme" $action | awk '{ print; } /Failed to query the list of test cases in the test bundle/ { exit 1; }' + + local awkstatus=$? + local result=${PIPESTATUS[0]} + + if [ "$awkstatus" -eq "1" ] + then + echo + echo "*** Mac application tests are currently buggy, so they have been skipped." + echo "*** See https://github.com/facebook/xctool/issues/243 for more information." + echo + return 0 + fi + + return $result +} + +export -f build_scheme +export -f run_xctool +export -f parse_build + +main
diff --git a/script/schemes.awk b/script/schemes.awk new file mode 100644 index 0000000..d101b4f --- /dev/null +++ b/script/schemes.awk
@@ -0,0 +1,12 @@ +BEGIN { + FS = "\n"; +} + +/Targets:/ { + while (getline && $0 != "") { + if ($0 ~ /Test/) continue; + + sub(/^ +/, ""); + print "'" $0 "'"; + } +}
diff --git a/script/targets.awk b/script/targets.awk new file mode 100644 index 0000000..117660d --- /dev/null +++ b/script/targets.awk
@@ -0,0 +1,12 @@ +BEGIN { + FS = "\n"; +} + +/Targets:/ { + while (getline && $0 != "") { + if ($0 ~ /Tests/) continue; + + sub(/^ +/, ""); + print "'" $0 "'"; + } +}
diff --git a/script/xcodebuild.awk b/script/xcodebuild.awk new file mode 100644 index 0000000..c746b09 --- /dev/null +++ b/script/xcodebuild.awk
@@ -0,0 +1,35 @@ +# Exit statuses: +# +# 0 - No errors found. +# 1 - Build or test failure. Errors will be logged automatically. +# 2 - Untestable target. Retry with the "build" action. + +BEGIN { + status = 0; +} + +{ + print; + fflush(stdout); +} + +/is not valid for Testing/ { + exit 2; +} + +/[0-9]+: (error|warning):/ { + errors = errors $0 "\n"; +} + +/(TEST|BUILD) FAILED/ { + status = 1; +} + +END { + if (length(errors) > 0) { + print "\n*** All errors:\n" errors; + } + + fflush(stdout); + exit status; +}
diff --git a/script/xctool.awk b/script/xctool.awk new file mode 100644 index 0000000..f613258 --- /dev/null +++ b/script/xctool.awk
@@ -0,0 +1,25 @@ +# Exit statuses: +# +# 0 - No errors found. +# 1 - Wrong SDK. Retry with SDK `iphonesimulator`. +# 2 - Missing target. + +BEGIN { + status = 0; +} + +{ + print; +} + +/Testing with the '(.+)' SDK is not yet supported/ { + status = 1; +} + +/does not contain a target named/ { + status = 2; +} + +END { + exit status; +}
