cocoapods-catalyst-validator 0.1.0.beta.1

data/examples/AExample/Pods/PromisesObjC/Sources/FBLPromises/FBLPromise+Await.m

@@ -0,0 +1,48 @@
+/**
+ Copyright 2018 Google Inc. All rights reserved.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at:
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+
+#import "FBLPromise+Await.h"
+
+#import "FBLPromisePrivate.h"
+
+id __nullable FBLPromiseAwait(FBLPromise *promise, NSError **outError) {
+  assert(promise);
+
+  static dispatch_once_t onceToken;
+  static dispatch_queue_t queue;
+  dispatch_once(&onceToken, ^{
+    queue = dispatch_queue_create("com.google.FBLPromises.Await", DISPATCH_QUEUE_CONCURRENT);
+  });
+  dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
+  id __block resolution;
+  NSError __block *blockError;
+  [promise chainOnQueue:queue
+      chainedFulfill:^id(id value) {
+        resolution = value;
+        dispatch_semaphore_signal(semaphore);
+        return value;
+      }
+      chainedReject:^id(NSError *error) {
+        blockError = error;
+        dispatch_semaphore_signal(semaphore);
+        return error;
+      }];
+  dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
+  if (outError) {
+    *outError = blockError;
+  }
+  return resolution;
+}

data/examples/AExample/Pods/PromisesObjC/Sources/FBLPromises/FBLPromise+Catch.m

@@ -0,0 +1,55 @@
+/**
+ Copyright 2018 Google Inc. All rights reserved.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at:
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+
+#import "FBLPromise+Catch.h"
+
+#import "FBLPromisePrivate.h"
+
+@implementation FBLPromise (CatchAdditions)
+
+- (FBLPromise *)catch:(FBLPromiseCatchWorkBlock)reject {
+  return [self onQueue:FBLPromise.defaultDispatchQueue catch:reject];
+}
+
+- (FBLPromise *)onQueue:(dispatch_queue_t)queue catch:(FBLPromiseCatchWorkBlock)reject {
+  NSParameterAssert(queue);
+  NSParameterAssert(reject);
+
+  return [self chainOnQueue:queue
+             chainedFulfill:nil
+              chainedReject:^id(NSError *error) {
+                reject(error);
+                return error;
+              }];
+}
+
+@end
+
+@implementation FBLPromise (DotSyntax_CatchAdditions)
+
+- (FBLPromise* (^)(FBLPromiseCatchWorkBlock))catch {
+  return ^(FBLPromiseCatchWorkBlock catch) {
+    return [self catch:catch];
+  };
+}
+
+- (FBLPromise* (^)(dispatch_queue_t, FBLPromiseCatchWorkBlock))catchOn {
+  return ^(dispatch_queue_t queue, FBLPromiseCatchWorkBlock catch) {
+    return [self onQueue:queue catch:catch];
+  };
+}
+
+@end

data/examples/AExample/Pods/PromisesObjC/Sources/FBLPromises/FBLPromise+Delay.m

@@ -0,0 +1,59 @@
+/**
+ Copyright 2018 Google Inc. All rights reserved.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at:
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+
+#import "FBLPromise+Delay.h"
+
+#import "FBLPromisePrivate.h"
+
+@implementation FBLPromise (DelayAdditions)
+
+- (FBLPromise *)delay:(NSTimeInterval)interval {
+  return [self onQueue:FBLPromise.defaultDispatchQueue delay:interval];
+}
+
+- (FBLPromise *)onQueue:(dispatch_queue_t)queue delay:(NSTimeInterval)interval {
+  NSParameterAssert(queue);
+
+  FBLPromise *promise = [[FBLPromise alloc] initPending];
+  [self observeOnQueue:queue
+      fulfill:^(id __nullable value) {
+        dispatch_after(dispatch_time(0, (int64_t)(interval * NSEC_PER_SEC)), queue, ^{
+          [promise fulfill:value];
+        });
+      }
+      reject:^(NSError *error) {
+        [promise reject:error];
+      }];
+  return promise;
+}
+
+@end
+
+@implementation FBLPromise (DotSyntax_DelayAdditions)
+
+- (FBLPromise * (^)(NSTimeInterval))delay {
+  return ^(NSTimeInterval interval) {
+    return [self delay:interval];
+  };
+}
+
+- (FBLPromise * (^)(dispatch_queue_t, NSTimeInterval))delayOn {
+  return ^(dispatch_queue_t queue, NSTimeInterval interval) {
+    return [self onQueue:queue delay:interval];
+  };
+}
+
+@end

data/examples/AExample/Pods/PromisesObjC/Sources/FBLPromises/FBLPromise+Do.m

@@ -0,0 +1,59 @@
+/**
+ Copyright 2018 Google Inc. All rights reserved.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at:
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+
+#import "FBLPromise+Do.h"
+
+#import "FBLPromisePrivate.h"
+
+@implementation FBLPromise (DoAdditions)
+
++ (instancetype)do:(FBLPromiseDoWorkBlock)work {
+  return [self onQueue:self.defaultDispatchQueue do:work];
+}
+
++ (instancetype)onQueue:(dispatch_queue_t)queue do:(FBLPromiseDoWorkBlock)work {
+  NSParameterAssert(queue);
+  NSParameterAssert(work);
+
+  FBLPromise *promise = [[FBLPromise alloc] initPending];
+  dispatch_group_async(FBLPromise.dispatchGroup, queue, ^{
+    id value = work();
+    if ([value isKindOfClass:[FBLPromise class]]) {
+      [(FBLPromise *)value observeOnQueue:queue
+          fulfill:^(id __nullable value) {
+            [promise fulfill:value];
+          }
+          reject:^(NSError *error) {
+            [promise reject:error];
+          }];
+    } else {
+      [promise fulfill:value];
+    }
+  });
+  return promise;
+}
+
+@end
+
+@implementation FBLPromise (DotSyntax_DoAdditions)
+
++ (FBLPromise* (^)(dispatch_queue_t, FBLPromiseDoWorkBlock))doOn {
+  return ^(dispatch_queue_t queue, FBLPromiseDoWorkBlock work) {
+    return [self onQueue:queue do:work];
+  };
+}
+
+@end

data/examples/AExample/Pods/PromisesObjC/Sources/FBLPromises/FBLPromise+Race.m

@@ -0,0 +1,65 @@
+/**
+ Copyright 2018 Google Inc. All rights reserved.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at:
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+
+#import "FBLPromise+Race.h"
+
+#import "FBLPromise+Async.h"
+#import "FBLPromisePrivate.h"
+
+@implementation FBLPromise (RaceAdditions)
+
++ (instancetype)race:(NSArray *)promises {
+  return [self onQueue:self.defaultDispatchQueue race:promises];
+}
+
++ (instancetype)onQueue:(dispatch_queue_t)queue race:(NSArray *)racePromises {
+  NSParameterAssert(queue);
+  NSAssert(racePromises.count > 0, @"No promises to observe");
+
+  NSArray *promises = [racePromises copy];
+  return [FBLPromise onQueue:queue
+                       async:^(FBLPromiseFulfillBlock fulfill, FBLPromiseRejectBlock reject) {
+                         for (id promise in promises) {
+                           if (![promise isKindOfClass:self]) {
+                             fulfill(promise);
+                             return;
+                           }
+                         }
+                         // Subscribe all, but only the first one to resolve will change
+                         // the resulting promise's state.
+                         for (FBLPromise *promise in promises) {
+                           [promise observeOnQueue:queue fulfill:fulfill reject:reject];
+                         }
+                       }];
+}
+
+@end
+
+@implementation FBLPromise (DotSyntax_RaceAdditions)
+
++ (FBLPromise * (^)(NSArray *))race {
+  return ^(NSArray *promises) {
+    return [self race:promises];
+  };
+}
+
++ (FBLPromise * (^)(dispatch_queue_t, NSArray *))raceOn {
+  return ^(dispatch_queue_t queue, NSArray *promises) {
+    return [self onQueue:queue race:promises];
+  };
+}
+
+@end

data/examples/AExample/Pods/PromisesObjC/Sources/FBLPromises/FBLPromise+Recover.m

@@ -0,0 +1,54 @@
+/**
+ Copyright 2018 Google Inc. All rights reserved.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at:
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+
+#import "FBLPromise+Recover.h"
+
+#import "FBLPromisePrivate.h"
+
+@implementation FBLPromise (RecoverAdditions)
+
+- (FBLPromise *)recover:(FBLPromiseRecoverWorkBlock)recovery {
+  return [self onQueue:FBLPromise.defaultDispatchQueue recover:recovery];
+}
+
+- (FBLPromise *)onQueue:(dispatch_queue_t)queue recover:(FBLPromiseRecoverWorkBlock)recovery {
+  NSParameterAssert(queue);
+  NSParameterAssert(recovery);
+
+  return [self chainOnQueue:queue
+             chainedFulfill:nil
+              chainedReject:^id(NSError *error) {
+                return recovery(error);
+              }];
+}
+
+@end
+
+@implementation FBLPromise (DotSyntax_RecoverAdditions)
+
+- (FBLPromise * (^)(FBLPromiseRecoverWorkBlock))recover {
+  return ^(FBLPromiseRecoverWorkBlock recovery) {
+    return [self recover:recovery];
+  };
+}
+
+- (FBLPromise * (^)(dispatch_queue_t, FBLPromiseRecoverWorkBlock))recoverOn {
+  return ^(dispatch_queue_t queue, FBLPromiseRecoverWorkBlock recovery) {
+    return [self onQueue:queue recover:recovery];
+  };
+}
+
+@end

data/examples/AExample/Pods/PromisesObjC/Sources/FBLPromises/FBLPromise+Reduce.m

@@ -0,0 +1,61 @@
+/**
+ Copyright 2018 Google Inc. All rights reserved.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at:
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+
+#import "FBLPromise+Reduce.h"
+
+#import "FBLPromisePrivate.h"
+
+@implementation FBLPromise (ReduceAdditions)
+
+- (FBLPromise *)reduce:(NSArray *)items combine:(FBLPromiseReducerBlock)reducer {
+  return [self onQueue:FBLPromise.defaultDispatchQueue reduce:items combine:reducer];
+}
+
+- (FBLPromise *)onQueue:(dispatch_queue_t)queue
+                 reduce:(NSArray *)items
+                combine:(FBLPromiseReducerBlock)reducer {
+  NSParameterAssert(queue);
+  NSParameterAssert(items);
+  NSParameterAssert(reducer);
+
+  FBLPromise *promise = self;
+  for (id item in items) {
+    promise = [promise chainOnQueue:queue
+                     chainedFulfill:^id(id value) {
+                       return reducer(value, item);
+                     }
+                      chainedReject:nil];
+  }
+  return promise;
+}
+
+@end
+
+@implementation FBLPromise (DotSyntax_ReduceAdditions)
+
+- (FBLPromise * (^)(NSArray *, FBLPromiseReducerBlock))reduce {
+  return ^(NSArray *items, FBLPromiseReducerBlock reducer) {
+    return [self reduce:items combine:reducer];
+  };
+}
+
+- (FBLPromise * (^)(dispatch_queue_t, NSArray *, FBLPromiseReducerBlock))reduceOn {
+  return ^(dispatch_queue_t queue, NSArray *items, FBLPromiseReducerBlock reducer) {
+    return [self onQueue:queue reduce:items combine:reducer];
+  };
+}
+
+@end

data/examples/AExample/Pods/PromisesObjC/Sources/FBLPromises/FBLPromise+Retry.m

@@ -0,0 +1,128 @@
+/**
+ Copyright 2018 Google Inc. All rights reserved.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at:
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+
+#import "FBLPromise+Retry.h"
+
+#import "FBLPromisePrivate.h"
+
+NSInteger const FBLPromiseRetryDefaultAttemptsCount = 1;
+NSTimeInterval const FBLPromiseRetryDefaultDelayInterval = 1.0;
+
+static void FBLPromiseRetryAttempt(FBLPromise *promise, dispatch_queue_t queue, NSInteger count,
+                                   NSTimeInterval interval, FBLPromiseRetryPredicateBlock predicate,
+                                   FBLPromiseRetryWorkBlock work) {
+  __auto_type retrier = ^(id __nullable value) {
+    if ([value isKindOfClass:[NSError class]]) {
+      if (count <= 0 || (predicate && !predicate(count, value))) {
+        [promise reject:value];
+      } else {
+        dispatch_after(dispatch_time(0, (int64_t)(interval * NSEC_PER_SEC)), queue, ^{
+          FBLPromiseRetryAttempt(promise, queue, count - 1, interval, predicate, work);
+        });
+      }
+    } else {
+      [promise fulfill:value];
+    }
+  };
+  id value = work();
+  if ([value isKindOfClass:[FBLPromise class]]) {
+    [(FBLPromise *)value observeOnQueue:queue fulfill:retrier reject:retrier];
+  } else  {
+    retrier(value);
+  }
+}
+
+@implementation FBLPromise (RetryAdditions)
+
++ (FBLPromise *)retry:(FBLPromiseRetryWorkBlock)work {
+  return [self onQueue:FBLPromise.defaultDispatchQueue retry:work];
+}
+
++ (FBLPromise *)onQueue:(dispatch_queue_t)queue retry:(FBLPromiseRetryWorkBlock)work {
+  return [self onQueue:queue attempts:FBLPromiseRetryDefaultAttemptsCount retry:work];
+}
+
++ (FBLPromise *)attempts:(NSInteger)count retry:(FBLPromiseRetryWorkBlock)work {
+  return [self onQueue:FBLPromise.defaultDispatchQueue attempts:count retry:work];
+}
+
++ (FBLPromise *)onQueue:(dispatch_queue_t)queue
+               attempts:(NSInteger)count
+                  retry:(FBLPromiseRetryWorkBlock)work {
+  return [self onQueue:queue
+              attempts:count
+                 delay:FBLPromiseRetryDefaultDelayInterval
+             condition:nil
+                 retry:work];
+}
+
++ (FBLPromise *)attempts:(NSInteger)count
+                   delay:(NSTimeInterval)interval
+               condition:(nullable FBLPromiseRetryPredicateBlock)predicate
+                   retry:(FBLPromiseRetryWorkBlock)work {
+  return [self onQueue:FBLPromise.defaultDispatchQueue
+              attempts:count
+                 delay:interval
+             condition:predicate
+                 retry:work];
+}
+
++ (FBLPromise *)onQueue:(dispatch_queue_t)queue
+               attempts:(NSInteger)count
+                  delay:(NSTimeInterval)interval
+              condition:(nullable FBLPromiseRetryPredicateBlock)predicate
+                  retry:(FBLPromiseRetryWorkBlock)work {
+  NSParameterAssert(queue);
+  NSParameterAssert(work);
+
+  FBLPromise *promise = [[FBLPromise alloc] initPending];
+  FBLPromiseRetryAttempt(promise, queue, count, interval, predicate, work);
+  return promise;
+}
+
+@end
+
+@implementation FBLPromise (DotSyntax_RetryAdditions)
+
++ (FBLPromise * (^)(FBLPromiseRetryWorkBlock))retry {
+  return ^id(FBLPromiseRetryWorkBlock work) {
+    return [self retry:work];
+  };
+}
+
++ (FBLPromise * (^)(dispatch_queue_t, FBLPromiseRetryWorkBlock))retryOn {
+  return ^id(dispatch_queue_t queue, FBLPromiseRetryWorkBlock work) {
+    return [self onQueue:queue retry:work];
+  };
+}
+
++ (FBLPromise * (^)(NSInteger, NSTimeInterval, FBLPromiseRetryPredicateBlock,
+                    FBLPromiseRetryWorkBlock))retryAgain {
+  return ^id(NSInteger count, NSTimeInterval interval, FBLPromiseRetryPredicateBlock predicate,
+             FBLPromiseRetryWorkBlock work) {
+    return [self attempts:count delay:interval condition:predicate retry:work];
+  };
+}
+
++ (FBLPromise * (^)(dispatch_queue_t, NSInteger, NSTimeInterval, FBLPromiseRetryPredicateBlock,
+                    FBLPromiseRetryWorkBlock))retryAgainOn {
+  return ^id(dispatch_queue_t queue, NSInteger count, NSTimeInterval interval,
+             FBLPromiseRetryPredicateBlock predicate, FBLPromiseRetryWorkBlock work) {
+    return [self onQueue:queue attempts:count delay:interval condition:predicate retry:work];
+  };
+}
+
+@end

data/examples/AExample/Pods/PromisesObjC/Sources/FBLPromises/FBLPromise+Testing.m

@@ -0,0 +1,55 @@
+/**
+ Copyright 2018 Google Inc. All rights reserved.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at:
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+
+#import "FBLPromise+Testing.h"
+
+BOOL FBLWaitForPromisesWithTimeout(NSTimeInterval timeout) {
+  BOOL isTimedOut = NO;
+  NSDate *timeoutDate = [NSDate dateWithTimeIntervalSinceNow:timeout];
+  static NSTimeInterval const minimalTimeout = 0.01;
+  static int64_t const minimalTimeToWait = (int64_t)(minimalTimeout * NSEC_PER_SEC);
+  dispatch_time_t waitTime = dispatch_time(DISPATCH_TIME_NOW, minimalTimeToWait);
+  dispatch_group_t dispatchGroup = FBLPromise.dispatchGroup;
+  NSRunLoop *runLoop = NSRunLoop.currentRunLoop;
+  while (dispatch_group_wait(dispatchGroup, waitTime)) {
+    isTimedOut = timeoutDate.timeIntervalSinceNow < 0.0;
+    if (isTimedOut) {
+      break;
+    }
+    [runLoop runUntilDate:[NSDate dateWithTimeIntervalSinceNow:minimalTimeout]];
+  }
+  return !isTimedOut;
+}
+
+@implementation FBLPromise (TestingAdditions)
+
+// These properties are implemented in the FBLPromise class itself.
+@dynamic isPending;
+@dynamic isFulfilled;
+@dynamic isRejected;
+@dynamic value;
+@dynamic error;
+
++ (dispatch_group_t)dispatchGroup {
+  static dispatch_group_t gDispatchGroup;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    gDispatchGroup = dispatch_group_create();
+  });
+  return gDispatchGroup;
+}
+
+@end

data/examples/AExample/Pods/PromisesObjC/Sources/FBLPromises/FBLPromise+Then.m

@@ -0,0 +1,50 @@
+/**
+ Copyright 2018 Google Inc. All rights reserved.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at:
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+
+#import "FBLPromise+Then.h"
+
+#import "FBLPromisePrivate.h"
+
+@implementation FBLPromise (ThenAdditions)
+
+- (FBLPromise *)then:(FBLPromiseThenWorkBlock)work {
+  return [self onQueue:FBLPromise.defaultDispatchQueue then:work];
+}
+
+- (FBLPromise *)onQueue:(dispatch_queue_t)queue then:(FBLPromiseThenWorkBlock)work {
+  NSParameterAssert(queue);
+  NSParameterAssert(work);
+
+  return [self chainOnQueue:queue chainedFulfill:work chainedReject:nil];
+}
+
+@end
+
+@implementation FBLPromise (DotSyntax_ThenAdditions)
+
+- (FBLPromise* (^)(FBLPromiseThenWorkBlock))then {
+  return ^(FBLPromiseThenWorkBlock work) {
+    return [self then:work];
+  };
+}
+
+- (FBLPromise* (^)(dispatch_queue_t, FBLPromiseThenWorkBlock))thenOn {
+  return ^(dispatch_queue_t queue, FBLPromiseThenWorkBlock work) {
+    return [self onQueue:queue then:work];
+  };
+}
+
+@end