cocoapods-catalyst-validator 0.1.0.beta.1

data/examples/AExample/Pods/GoogleDataTransport/GoogleDataTransport/GDTCORLibrary/GDTCORReachability.m

@@ -0,0 +1,125 @@
+/*
+ * Copyright 2019 Google
+ *
+ * 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 "GoogleDataTransport/GDTCORLibrary/Internal/GDTCORReachability.h"
+#import "GoogleDataTransport/GDTCORLibrary/Private/GDTCORReachability_Private.h"
+
+#import "GoogleDataTransport/GDTCORLibrary/Public/GoogleDataTransport/GDTCORConsoleLogger.h"
+
+#import <netinet/in.h>
+
+/** Sets the _callbackFlag ivar whenever the network changes.
+ *
+ * @param reachability The reachability object calling back.
+ * @param flags The new flag values.
+ * @param info Any data that might be passed in by the callback.
+ */
+static void GDTCORReachabilityCallback(GDTCORNetworkReachabilityRef reachability,
+                                       GDTCORNetworkReachabilityFlags flags,
+                                       void *info);
+
+@implementation GDTCORReachability {
+  /** The reachability object. */
+  GDTCORNetworkReachabilityRef _reachabilityRef;
+
+  /** The queue on which callbacks and all work will occur. */
+  dispatch_queue_t _reachabilityQueue;
+
+  /** Flags specified by reachability callbacks. */
+  GDTCORNetworkReachabilityFlags _callbackFlags;
+}
+
++ (void)initialize {
+  [self sharedInstance];
+}
+
++ (instancetype)sharedInstance {
+  static GDTCORReachability *sharedInstance;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    sharedInstance = [[GDTCORReachability alloc] init];
+  });
+  return sharedInstance;
+}
+
++ (GDTCORNetworkReachabilityFlags)currentFlags {
+  __block GDTCORNetworkReachabilityFlags currentFlags;
+#if !TARGET_OS_WATCH
+  dispatch_sync([GDTCORReachability sharedInstance] -> _reachabilityQueue, ^{
+    GDTCORReachability *reachability = [GDTCORReachability sharedInstance];
+    currentFlags =
+        reachability->_callbackFlags ? reachability->_callbackFlags : reachability->_flags;
+    GDTCORLogDebug(@"Initial reachability flags determined: %d", currentFlags);
+  });
+#else
+  currentFlags = kGDTCORNetworkReachabilityFlagsReachable;
+#endif
+  return currentFlags;
+}
+
+- (instancetype)init {
+  self = [super init];
+#if !TARGET_OS_WATCH
+  if (self) {
+    struct sockaddr_in zeroAddress;
+    bzero(&zeroAddress, sizeof(zeroAddress));
+    zeroAddress.sin_len = sizeof(zeroAddress);
+    zeroAddress.sin_family = AF_INET;
+
+    _reachabilityQueue =
+        dispatch_queue_create("com.google.GDTCORReachability", DISPATCH_QUEUE_SERIAL);
+    _reachabilityRef = SCNetworkReachabilityCreateWithAddress(
+        kCFAllocatorDefault, (const struct sockaddr *)&zeroAddress);
+    Boolean success = SCNetworkReachabilitySetDispatchQueue(_reachabilityRef, _reachabilityQueue);
+    if (!success) {
+      GDTCORLogWarning(GDTCORMCWReachabilityFailed, @"%@", @"The reachability queue wasn't set.");
+    }
+    success = SCNetworkReachabilitySetCallback(_reachabilityRef, GDTCORReachabilityCallback, NULL);
+    if (!success) {
+      GDTCORLogWarning(GDTCORMCWReachabilityFailed, @"%@",
+                       @"The reachability callback wasn't set.");
+    }
+
+    // Get the initial set of flags.
+    dispatch_async(_reachabilityQueue, ^{
+      Boolean valid = SCNetworkReachabilityGetFlags(self->_reachabilityRef, &self->_flags);
+      if (!valid) {
+        GDTCORLogDebug(@"%@", @"Determining reachability failed.");
+        self->_flags = 0;
+      }
+    });
+  }
+#endif
+  return self;
+}
+
+- (void)setCallbackFlags:(GDTCORNetworkReachabilityFlags)flags {
+  if (_callbackFlags != flags) {
+    self->_callbackFlags = flags;
+  }
+}
+
+@end
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-function"
+static void GDTCORReachabilityCallback(GDTCORNetworkReachabilityRef reachability,
+                                       GDTCORNetworkReachabilityFlags flags,
+                                       void *info) {
+#pragma clang diagnostic pop
+  GDTCORLogDebug(@"Reachability changed, new flags: %d", flags);
+  [[GDTCORReachability sharedInstance] setCallbackFlags:flags];
+}

data/examples/AExample/Pods/GoogleDataTransport/GoogleDataTransport/GDTCORLibrary/GDTCORRegistrar.m

@@ -0,0 +1,157 @@
+/*
+ * Copyright 2018 Google
+ *
+ * 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 "GoogleDataTransport/GDTCORLibrary/Internal/GDTCORRegistrar.h"
+#import "GoogleDataTransport/GDTCORLibrary/Private/GDTCORRegistrar_Private.h"
+
+#import "GoogleDataTransport/GDTCORLibrary/Public/GoogleDataTransport/GDTCORConsoleLogger.h"
+
+id<GDTCORStorageProtocol> _Nullable GDTCORStorageInstanceForTarget(GDTCORTarget target) {
+  return [GDTCORRegistrar sharedInstance].targetToStorage[@(target)];
+}
+
+FOUNDATION_EXPORT
+id<GDTCORStoragePromiseProtocol> _Nullable GDTCORStoragePromiseInstanceForTarget(
+    GDTCORTarget target) {
+  id storage = [GDTCORRegistrar sharedInstance].targetToStorage[@(target)];
+  if ([storage conformsToProtocol:@protocol(GDTCORStoragePromiseProtocol)]) {
+    return storage;
+  } else {
+    return nil;
+  }
+}
+
+@implementation GDTCORRegistrar {
+  /** Backing ivar for targetToUploader property. */
+  NSMutableDictionary<NSNumber *, id<GDTCORUploader>> *_targetToUploader;
+
+  /** Backing ivar for targetToStorage property. */
+  NSMutableDictionary<NSNumber *, id<GDTCORStorageProtocol>> *_targetToStorage;
+}
+
++ (instancetype)sharedInstance {
+  static GDTCORRegistrar *sharedInstance;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    sharedInstance = [[GDTCORRegistrar alloc] init];
+  });
+  return sharedInstance;
+}
+
+- (instancetype)init {
+  self = [super init];
+  if (self) {
+    _registrarQueue = dispatch_queue_create("com.google.GDTCORRegistrar", DISPATCH_QUEUE_SERIAL);
+    _targetToUploader = [[NSMutableDictionary alloc] init];
+    _targetToStorage = [[NSMutableDictionary alloc] init];
+  }
+  return self;
+}
+
+- (void)registerUploader:(id<GDTCORUploader>)backend target:(GDTCORTarget)target {
+  __weak GDTCORRegistrar *weakSelf = self;
+  dispatch_async(_registrarQueue, ^{
+    GDTCORRegistrar *strongSelf = weakSelf;
+    if (strongSelf) {
+      GDTCORLogDebug(@"Registered an uploader: %@ for target:%ld", backend, (long)target);
+      strongSelf->_targetToUploader[@(target)] = backend;
+    }
+  });
+}
+
+- (void)registerStorage:(id<GDTCORStorageProtocol>)storage target:(GDTCORTarget)target {
+  __weak GDTCORRegistrar *weakSelf = self;
+  dispatch_async(_registrarQueue, ^{
+    GDTCORRegistrar *strongSelf = weakSelf;
+    if (strongSelf) {
+      GDTCORLogDebug(@"Registered storage: %@ for target:%ld", storage, (long)target);
+      strongSelf->_targetToStorage[@(target)] = storage;
+    }
+  });
+}
+
+- (NSMutableDictionary<NSNumber *, id<GDTCORUploader>> *)targetToUploader {
+  __block NSMutableDictionary<NSNumber *, id<GDTCORUploader>> *targetToUploader;
+  __weak GDTCORRegistrar *weakSelf = self;
+  dispatch_sync(_registrarQueue, ^{
+    GDTCORRegistrar *strongSelf = weakSelf;
+    if (strongSelf) {
+      targetToUploader = strongSelf->_targetToUploader;
+    }
+  });
+  return targetToUploader;
+}
+
+- (NSMutableDictionary<NSNumber *, id<GDTCORStorageProtocol>> *)targetToStorage {
+  __block NSMutableDictionary<NSNumber *, id<GDTCORStorageProtocol>> *targetToStorage;
+  __weak GDTCORRegistrar *weakSelf = self;
+  dispatch_sync(_registrarQueue, ^{
+    GDTCORRegistrar *strongSelf = weakSelf;
+    if (strongSelf) {
+      targetToStorage = strongSelf->_targetToStorage;
+    }
+  });
+  return targetToStorage;
+}
+
+#pragma mark - GDTCORLifecycleProtocol
+
+- (void)appWillBackground:(nonnull GDTCORApplication *)app {
+  NSArray<id<GDTCORUploader>> *uploaders = [self.targetToUploader allValues];
+  for (id<GDTCORUploader> uploader in uploaders) {
+    if ([uploader respondsToSelector:@selector(appWillBackground:)]) {
+      [uploader appWillBackground:app];
+    }
+  }
+  NSArray<id<GDTCORStorageProtocol>> *storages = [self.targetToStorage allValues];
+  for (id<GDTCORStorageProtocol> storage in storages) {
+    if ([storage respondsToSelector:@selector(appWillBackground:)]) {
+      [storage appWillBackground:app];
+    }
+  }
+}
+
+- (void)appWillForeground:(nonnull GDTCORApplication *)app {
+  NSArray<id<GDTCORUploader>> *uploaders = [self.targetToUploader allValues];
+  for (id<GDTCORUploader> uploader in uploaders) {
+    if ([uploader respondsToSelector:@selector(appWillForeground:)]) {
+      [uploader appWillForeground:app];
+    }
+  }
+  NSArray<id<GDTCORStorageProtocol>> *storages = [self.targetToStorage allValues];
+  for (id<GDTCORStorageProtocol> storage in storages) {
+    if ([storage respondsToSelector:@selector(appWillForeground:)]) {
+      [storage appWillForeground:app];
+    }
+  }
+}
+
+- (void)appWillTerminate:(nonnull GDTCORApplication *)app {
+  NSArray<id<GDTCORUploader>> *uploaders = [self.targetToUploader allValues];
+  for (id<GDTCORUploader> uploader in uploaders) {
+    if ([uploader respondsToSelector:@selector(appWillTerminate:)]) {
+      [uploader appWillTerminate:app];
+    }
+  }
+  NSArray<id<GDTCORStorageProtocol>> *storages = [self.targetToStorage allValues];
+  for (id<GDTCORStorageProtocol> storage in storages) {
+    if ([storage respondsToSelector:@selector(appWillTerminate:)]) {
+      [storage appWillTerminate:app];
+    }
+  }
+}
+
+@end

data/examples/AExample/Pods/GoogleDataTransport/GoogleDataTransport/GDTCORLibrary/GDTCORStorageEventSelector.m

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2020 Google LLC
+ *
+ * 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 "GoogleDataTransport/GDTCORLibrary/Internal/GDTCORStorageEventSelector.h"
+
+@implementation GDTCORStorageEventSelector
+
++ (instancetype)eventSelectorForTarget:(GDTCORTarget)target {
+  return [[self alloc] initWithTarget:target eventIDs:nil mappingIDs:nil qosTiers:nil];
+}
+
+- (instancetype)initWithTarget:(GDTCORTarget)target
+                      eventIDs:(nullable NSSet<NSString *> *)eventIDs
+                    mappingIDs:(nullable NSSet<NSString *> *)mappingIDs
+                      qosTiers:(nullable NSSet<NSNumber *> *)qosTiers {
+  self = [super init];
+  if (self) {
+    _selectedTarget = target;
+    _selectedEventIDs = eventIDs;
+    _selectedMappingIDs = mappingIDs;
+    _selectedQosTiers = qosTiers;
+  }
+  return self;
+}
+
+@end

data/examples/AExample/Pods/GoogleDataTransport/GoogleDataTransport/GDTCORLibrary/GDTCORTransformer.m

@@ -0,0 +1,111 @@
+/*
+ * Copyright 2018 Google
+ *
+ * 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 "GoogleDataTransport/GDTCORLibrary/Private/GDTCORTransformer.h"
+#import "GoogleDataTransport/GDTCORLibrary/Private/GDTCORTransformer_Private.h"
+
+#import "GoogleDataTransport/GDTCORLibrary/Internal/GDTCORAssert.h"
+#import "GoogleDataTransport/GDTCORLibrary/Internal/GDTCORLifecycle.h"
+#import "GoogleDataTransport/GDTCORLibrary/Internal/GDTCORStorageProtocol.h"
+#import "GoogleDataTransport/GDTCORLibrary/Public/GoogleDataTransport/GDTCORConsoleLogger.h"
+#import "GoogleDataTransport/GDTCORLibrary/Public/GoogleDataTransport/GDTCOREvent.h"
+#import "GoogleDataTransport/GDTCORLibrary/Public/GoogleDataTransport/GDTCOREventTransformer.h"
+
+#import "GoogleDataTransport/GDTCORLibrary/Private/GDTCOREvent_Private.h"
+#import "GoogleDataTransport/GDTCORLibrary/Private/GDTCORRegistrar_Private.h"
+
+@implementation GDTCORTransformer
+
++ (instancetype)sharedInstance {
+  static GDTCORTransformer *eventTransformer;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    eventTransformer = [[self alloc] init];
+  });
+  return eventTransformer;
+}
+
+- (instancetype)init {
+  return [self initWithApplication:[GDTCORApplication sharedApplication]];
+}
+
+- (instancetype)initWithApplication:(id<GDTCORApplicationProtocol>)application {
+  self = [super init];
+  if (self) {
+    _eventWritingQueue =
+        dispatch_queue_create("com.google.GDTCORTransformer", DISPATCH_QUEUE_SERIAL);
+    _application = application;
+  }
+  return self;
+}
+
+- (void)transformEvent:(GDTCOREvent *)event
+      withTransformers:(NSArray<id<GDTCOREventTransformer>> *)transformers
+            onComplete:(void (^_Nullable)(BOOL wasWritten, NSError *_Nullable error))completion {
+  GDTCORAssert(event, @"You can't write a nil event");
+
+  __block GDTCORBackgroundIdentifier bgID = GDTCORBackgroundIdentifierInvalid;
+  __auto_type __weak weakApplication = self.application;
+  bgID = [self.application beginBackgroundTaskWithName:@"GDTTransformer"
+                                     expirationHandler:^{
+                                       [weakApplication endBackgroundTask:bgID];
+                                       bgID = GDTCORBackgroundIdentifierInvalid;
+                                     }];
+
+  __auto_type completionWrapper = ^(BOOL wasWritten, NSError *_Nullable error) {
+    if (completion) {
+      completion(wasWritten, error);
+    }
+
+    // The work is done, cancel the background task if it's valid.
+    [weakApplication endBackgroundTask:bgID];
+    bgID = GDTCORBackgroundIdentifierInvalid;
+  };
+
+  dispatch_async(_eventWritingQueue, ^{
+    GDTCOREvent *transformedEvent = event;
+    for (id<GDTCOREventTransformer> transformer in transformers) {
+      if ([transformer respondsToSelector:@selector(transformGDTEvent:)]) {
+        GDTCORLogDebug(@"Applying a transformer to event %@", event);
+        transformedEvent = [transformer transformGDTEvent:event];
+        if (!transformedEvent) {
+          completionWrapper(NO, nil);
+          return;
+        }
+      } else {
+        GDTCORLogError(GDTCORMCETransformerDoesntImplementTransform,
+                       @"Transformer doesn't implement transformGDTEvent: %@", transformer);
+        completionWrapper(NO, nil);
+        return;
+      }
+    }
+
+    id<GDTCORStorageProtocol> storage =
+        [GDTCORRegistrar sharedInstance].targetToStorage[@(event.target)];
+
+    [storage storeEvent:transformedEvent onComplete:completionWrapper];
+  });
+}
+
+#pragma mark - GDTCORLifecycleProtocol
+
+- (void)appWillTerminate:(GDTCORApplication *)application {
+  // Flush the queue immediately.
+  dispatch_sync(_eventWritingQueue, ^{
+                });
+}
+
+@end

data/examples/AExample/Pods/GoogleDataTransport/GoogleDataTransport/GDTCORLibrary/GDTCORTransport.m

@@ -0,0 +1,92 @@
+/*
+ * Copyright 2018 Google
+ *
+ * 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 "GoogleDataTransport/GDTCORLibrary/Public/GoogleDataTransport/GDTCORTransport.h"
+#import "GoogleDataTransport/GDTCORLibrary/Private/GDTCORTransport_Private.h"
+
+#import "GoogleDataTransport/GDTCORLibrary/Internal/GDTCORAssert.h"
+#import "GoogleDataTransport/GDTCORLibrary/Public/GoogleDataTransport/GDTCORClock.h"
+#import "GoogleDataTransport/GDTCORLibrary/Public/GoogleDataTransport/GDTCOREvent.h"
+
+#import "GoogleDataTransport/GDTCORLibrary/Private/GDTCORTransformer.h"
+
+@implementation GDTCORTransport
+
+- (nullable instancetype)initWithMappingID:(NSString *)mappingID
+                              transformers:
+                                  (nullable NSArray<id<GDTCOREventTransformer>> *)transformers
+                                    target:(GDTCORTarget)target {
+  GDTCORAssert(mappingID.length > 0, @"A mapping ID cannot be nil or empty");
+  GDTCORAssert(target > 0, @"A target cannot be negative or 0");
+  if (mappingID == nil || mappingID.length == 0 || target <= 0) {
+    return nil;
+  }
+  self = [super init];
+  if (self) {
+    _mappingID = mappingID;
+    _transformers = transformers;
+    _target = target;
+    _transformerInstance = [GDTCORTransformer sharedInstance];
+  }
+  GDTCORLogDebug(@"Transport object created. mappingID:%@ transformers:%@ target:%ld", mappingID,
+                 transformers, (long)target);
+  return self;
+}
+
+- (void)sendTelemetryEvent:(GDTCOREvent *)event
+                onComplete:
+                    (void (^_Nullable)(BOOL wasWritten, NSError *_Nullable error))completion {
+  event.qosTier = GDTCOREventQoSTelemetry;
+  [self sendEvent:event onComplete:completion];
+}
+
+- (void)sendDataEvent:(GDTCOREvent *)event
+           onComplete:(void (^_Nullable)(BOOL wasWritten, NSError *_Nullable error))completion {
+  GDTCORAssert(event.qosTier != GDTCOREventQoSTelemetry, @"Use -sendTelemetryEvent, please.");
+  [self sendEvent:event onComplete:completion];
+}
+
+- (void)sendTelemetryEvent:(GDTCOREvent *)event {
+  [self sendTelemetryEvent:event onComplete:nil];
+}
+
+- (void)sendDataEvent:(GDTCOREvent *)event {
+  [self sendDataEvent:event onComplete:nil];
+}
+
+- (GDTCOREvent *)eventForTransport {
+  return [[GDTCOREvent alloc] initWithMappingID:_mappingID target:_target];
+}
+
+#pragma mark - Private helper methods
+
+/** Sends the given event through the transport pipeline.
+ *
+ * @param event The event to send.
+ * @param completion A block that will be called when the event has been written or dropped.
+ */
+- (void)sendEvent:(GDTCOREvent *)event
+       onComplete:(void (^_Nullable)(BOOL wasWritten, NSError *_Nullable error))completion {
+  // TODO: Determine if sending an event before registration is allowed.
+  GDTCORAssert(event, @"You can't send a nil event");
+  GDTCOREvent *copiedEvent = [event copy];
+  copiedEvent.clockSnapshot = [GDTCORClock snapshot];
+  [self.transformerInstance transformEvent:copiedEvent
+                          withTransformers:_transformers
+                                onComplete:completion];
+}
+
+@end

data/examples/AExample/Pods/GoogleDataTransport/GoogleDataTransport/GDTCORLibrary/GDTCORUploadBatch.m

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2020 Google LLC
+ *
+ * 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 "GoogleDataTransport/GDTCORLibrary/Private/GDTCORUploadBatch.h"
+
+@implementation GDTCORUploadBatch
+
+- (instancetype)initWithBatchID:(NSNumber *)batchID events:(NSSet<GDTCOREvent *> *)events {
+  self = [super init];
+  if (self) {
+    _batchID = batchID;
+    _events = events;
+  }
+  return self;
+}
+
+@end