Reactive Cocoa - Convert certain signal values into error or completed

Question

Perhaps I'm still struggling on the reactive learning curve but I am having a hard time figuring out how to bridge a non reactive class with the rest of my reactive code. I am using a category to extend the non-reactive class.

The property is just an Enum representing the current state of a network action, states like New, Submitted, Processing and Completed. Right now I have written the following method in my category:

@implementation JRequestBase (RACExtensions)
- (RACSignal*) rac_RequestStateSignal
{
    return  RACAble(self, state);
}
@end

However, when state transitions from Processing -> Completed or from any state to Errored I want this signal to send Completed or Error instead of Next Value. How can I accomplish this in a category? I want to do something like:

@implementation JRequestBase (RACExtensions)
- (RACSignal*) rac_RequestStateSignal
{
    return  [RACAble(self, state) map:^(NSNumber *state){
                 if ([state intValue] == iRequestStateComplete)
                 {    
                     # SEND COMPLETE
                 }
                 else if ([state intValue] == iRequestStateErrored)
                 { 
                     # SEND ERROR
                 }
                 else
                 { 
                     return state;
                 }
            }];
}
@end

edit: I took a look at the GHAPIDemo and have come up with the following:

- (RACSignal*) rac_RequestSignal
{
    RACSubject *subject = [[RACReplaySubject alloc] init];
    [[RACAble(self, state) subscribeNext:^(NSNumber* s){
        if ( [s intValue] == JRequestStateCompleted)
        {
            [subject sendNext:self];
            [subject sendCompleted];
        }
        else if ([s intValue] == JRequestStateErrored)
        {
            NSMutableDictionary *dict = [NSMutableDictionary dictionary];
            // .. Set up dict with necessary values.
            NSError *error = [NSError errorWithDomain:@"blah" code:1 userInfo:dict];

            [subject sendError:error];
        }
    }];
    return subject;
}

I'm not 100% sure this is the right way but it seems to be working.

Answer 1

Whenever you want to map values → signal events, instead of values → values, you should use -flattenMap: to return a signal corresponding to each input value. Then, as the "flatten" in the name implies, they'll be combined into one resulting signal.

However, this case is a little different, because you want to terminate the signal as soon as you get the Complete value. We'll use -takeUntilBlock: to represent that part.

The resulting code looks something like this:

- (RACSignal*) rac_RequestStateSignal
{
    return [[RACObserve(self, state)
        takeUntilBlock:^ BOOL (NSNumber *state){
            return [state intValue] == iRequestStateComplete;
        }]
        flattenMap:^(NSNumber *state){
            if ([state intValue] == iRequestStateErrored)
            { 
                // Create a meaningful NSError here if you can.
                return [RACSignal error:nil];
            }
            else
            { 
                return [RACSignal return:state];
            }
        }];
}

(I used RACObserve because ReactiveCocoa 2.0 is now the only supported version, but you can use RACAble until you're ready to upgrade.)

As a general rule, you should avoid using subjects when possible, since they make code more stateful and reduce laziness.