Removed ConnectionContext from Connector and AsyncConnector interfaces.

Author: Bilge

src/Connector/AsyncConnector.php

@@ -12,9 +12,8 @@ interface AsyncConnector
      * Fetches data from the specified source.
      *
      * @param string $source Source.
-     * @param ConnectionContext $context Runtime connection settings and methods.
      *
      * @return mixed Async generator function or any return value compatible with Amp\call.
      */
-    public function fetchAsync(string $source, ConnectionContext $context);
+    public function fetchAsync(string $source);
 }

src/Connector/CachingConnector.php

@@ -51,26 +51,23 @@ public function __clone()
 
     /**
      * @param string $source
-     * @param ConnectionContext $context
      *
      * @return mixed
      *
      * @throws InvalidCacheKeyException Cache key contains invalid data.
      */
-    public function fetch(string $source, ConnectionContext $context)
+    public function fetch(string $source)
     {
-        if ($context->mustCache()) {
-            $options = $this->connector instanceof ConnectorOptions ? $this->connector->getOptions()->copy() : [];
-            ksort($options);
+        $options = $this->connector instanceof ConnectorOptions ? $this->connector->getOptions()->copy() : [];
+        ksort($options);
 
-            $this->validateCacheKey($key = $this->cacheKeyGenerator->generateCacheKey($source, $options));
+        $this->validateCacheKey($key = $this->cacheKeyGenerator->generateCacheKey($source, $options));
 
-            if ($this->cache->hasItem($key)) {
-                return $this->cache->getItem($key)->get();
-            }
+        if ($this->cache->hasItem($key)) {
+            return $this->cache->getItem($key)->get();
         }
 
-        $data = $this->connector->fetch($source, $context);
+        $data = $this->connector->fetch($source);
 
         isset($key) && $this->cache->save($this->cache->getItem($key)->set($data));
 

src/Connector/ConnectionContext.php

@@ -12,9 +12,8 @@ interface Connector
      * Fetches data from the specified source optionally augmented by the specified options.
      *
      * @param string $source Source.
-     * @param ConnectionContext $context Runtime connection settings and methods.
      *
      * @return mixed Data.
      */
-    public function fetch(string $source, ConnectionContext $context);
+    public function fetch(string $source);
 }

src/Connector/Connector.php

@@ -8,10 +8,14 @@
 use ScriptFUSION\Porter\Connector\Recoverable\RecoverableException;
 use ScriptFUSION\Porter\Connector\Recoverable\RecoverableExceptionHandler;
 use ScriptFUSION\Porter\Connector\Recoverable\StatelessRecoverableExceptionHandler;
+use function Amp\call;
+use function Amp\Promise\all;
+use function ScriptFUSION\Retry\retry;
+use function ScriptFUSION\Retry\retryAsync;
 
 /**
- * Connector whose lifecycle is synchronised with an import operation. Ensures correct ConnectionContext is delivered
- * to the wrapped connector and intercepts failed connections to facilitate automatic retries.
+ * Connector whose lifecycle is synchronised with an import operation. Intercepts failed connections to facilitate
+ * automatic retries and manages caching.
  *
  * Do not store references to this connector that would prevent it expiring when an import operation ends.
  *
@@ -21,8 +25,6 @@ final class ImportConnector implements ConnectorWrapper
 {
     private $connector;
 
-    private $connectionContext;
-
     /**
      * User-defined exception handler called when a recoverable exception is thrown by Connector::fetch().
      *
@@ -41,45 +43,49 @@ final class ImportConnector implements ConnectorWrapper
 
     /**
      * @param Connector|AsyncConnector $connector Wrapped connector.
-     * @param ConnectionContext $connectionContext Connection context.
      * @param RecoverableExceptionHandler $recoverableExceptionHandler User's recoverable exception handler.
      * @param int $maxFetchAttempts
+     * @param bool $mustCache True if the response must be cached, otherwise false.
      */
     public function __construct(
         $connector,
-        ConnectionContext $connectionContext,
         RecoverableExceptionHandler $recoverableExceptionHandler,
-        int $maxFetchAttempts
+        int $maxFetchAttempts,
+        bool $mustCache
     ) {
-        if ($connectionContext->mustCache() && !$connector instanceof CachingConnector) {
+        if ($mustCache && !$connector instanceof CachingConnector) {
             throw CacheUnavailableException::createUnsupported();
         }
 
-        $this->connector = clone $connector;
-        $this->connectionContext = $connectionContext;
+        $this->connector = clone (
+            $connector instanceof CachingConnector && !$mustCache
+                // Bypass cache when not required.
+                ? $connector->getWrappedConnector()
+                : $connector
+        );
         $this->userExceptionHandler = $recoverableExceptionHandler;
         $this->maxFetchAttempts = $maxFetchAttempts;
     }
 
     public function fetch(string $source)
     {
-        return \ScriptFUSION\Retry\retry(
+        return retry(
             $this->maxFetchAttempts,
             function () use ($source) {
-                return $this->connector->fetch($source, $this->connectionContext);
+                return $this->connector->fetch($source);
             },
             $this->createExceptionHandler()
         );
     }
 
     public function fetchAsync(string $source): Promise
     {
-        return \ScriptFUSION\Retry\retryAsync(
+        return retryAsync(
             $this->maxFetchAttempts,
             function () use ($source): Promise {
-                return \Amp\call(
+                return call(
                     function () use ($source) {
-                        return $this->connector->fetchAsync($source, $this->connectionContext);
+                        return $this->connector->fetchAsync($source);
                     }
                 );
             },
@@ -108,14 +114,15 @@ private function createExceptionHandler(): \Closure
             /*
              * Handlers may return a Promise, but all other return values are discarded. Although the underlying
              * library supports returning false, Porter only allows exceptions to short-circuit. However,
-             * Porter does nothing to restrict promises that return false, although it is discouraged.
+             * Porter does nothing to restrict promises that return false, although it is discouraged and may be
+             * prevented in future. TODO: Mask promise return values.
              */
             return ($promises = array_filter(
                 $results,
                 static function ($value): bool {
                     return $value instanceof Promise;
                 }
-            )) ? \Amp\Promise\all($promises) : null;
+            )) ? all($promises) : null;
         };
     }
 

src/Connector/ImportConnector.php

@@ -20,9 +20,9 @@ public static function create($connector, Specification $specification): ImportC
     {
         return new ImportConnector(
             $connector,
-            new ConnectionContext($specification->mustCache()),
             $specification->getRecoverableExceptionHandler(),
-            $specification->getMaxFetchAttempts()
+            $specification->getMaxFetchAttempts(),
+            $specification->mustCache()
         );
     }
 }

src/Connector/ImportConnectorFactory.php

@@ -5,7 +5,7 @@
 
 final class NullConnector implements Connector
 {
-    public function fetch(string $source, ConnectionContext $context)
+    public function fetch(string $source)
     {
         // Intentionally empty.
     }

src/Connector/NullConnector.php

@@ -147,7 +147,9 @@ private function hasTransformer(AnysyncTransformer $transformer): bool
     }
 
     /**
-     * @return mixed
+     * Gets the context to be passed to transformers.
+     *
+     * @return mixed Context.
      *
      * @deprecated TODO: Evaluate whether context can be removed.
      */
@@ -157,7 +159,9 @@ final public function getContext()
     }
 
     /**
-     * @param mixed $context
+     * Sets the context to be passed transformers.
+     *
+     * @param mixed $context Context.
      *
      * @return $this
      *
@@ -171,14 +175,18 @@ final public function setContext($context): self
     }
 
     /**
-     * @return bool
+     * Gets a value indicating whether raw data caching is enabled for this import.
+     *
+     * @return bool True if caching is enabled, otherwise false.
      */
     final public function mustCache(): bool
     {
         return $this->mustCache;
     }
 
     /**
+     * Enables raw data caching fetched for this import.
+     *
      * @return $this
      */
     final public function enableCache(): self
@@ -189,6 +197,8 @@ final public function enableCache(): self
     }
 
     /**
+     * Disables raw data caching.
+     *
      * @return $this
      */
     final public function disableCache(): self

src/Specification/Specification.php

@@ -3,7 +3,6 @@
 
 namespace ScriptFUSIONTest;
 
-use ScriptFUSION\Porter\Connector\ConnectionContext;
 use ScriptFUSION\Porter\Connector\Connector;
 use ScriptFUSION\Porter\Connector\ImportConnector;
 use ScriptFUSION\Porter\Connector\Recoverable\RecoverableExceptionHandler;
@@ -14,25 +13,17 @@ final class FixtureFactory
 {
     use StaticClass;
 
-    /**
-     * Builds ConnectionContexts with sane defaults for testing.
-     */
-    public static function buildConnectionContext(bool $mustCache = false): ConnectionContext
-    {
-        return new ConnectionContext($mustCache);
-    }
-
     public static function buildImportConnector(
         Connector $connector,
-        ConnectionContext $context = null,
         RecoverableExceptionHandler $recoverableExceptionHandler = null,
-        int $maxFetchAttempts = ImportSpecification::DEFAULT_FETCH_ATTEMPTS
+        int $maxFetchAttempts = ImportSpecification::DEFAULT_FETCH_ATTEMPTS,
+        bool $mustCache = false
     ): ImportConnector {
         return new ImportConnector(
             $connector,
-            $context ?: self::buildConnectionContext(),
             $recoverableExceptionHandler ?: \Mockery::spy(RecoverableExceptionHandler::class),
-            $maxFetchAttempts
+            $maxFetchAttempts,
+            $mustCache
         );
     }
 }