Subversion-Projekte lars-tiefland.laravel_shop

<?php namespace Clockwork;

use Clockwork\Authentication\AuthenticatorInterface;
use Clockwork\Authentication\NullAuthenticator;
use Clockwork\DataSource\DataSourceInterface;
use Clockwork\Helpers\Serializer;
use Clockwork\Request\Log;
use Clockwork\Request\Request;
use Clockwork\Request\RequestType;
use Clockwork\Request\ShouldCollect;
use Clockwork\Request\ShouldRecord;
use Clockwork\Storage\StorageInterface;

// A central class implementing the core flow of the library
class Clockwork
{
        // Clockwork library version
        const VERSION = '5.1.12';

        // Array of data sources, these objects collect metadata for the current application run
        protected $dataSources = [];

        // Request object, data structure which stores metadata about the current application run
        protected $request;

        // Storage object, provides implementation for storing and retrieving request objects
        protected $storage;

        // Authenticator implementation, authenticates requests for clockwork metadata
        protected $authenticator;

        // An object specifying the rules for collecting requests
        protected $shouldCollect;

        // An object specifying the rules for recording requests
        protected $shouldRecord;

        // Create a new Clockwork instance with default request object, a storage implementation has to be additionally set
        public function __construct()
        {
                $this->request = new Request;
                $this->authenticator = new NullAuthenticator;

                $this->shouldCollect = new ShouldCollect;
                $this->shouldRecord = new ShouldRecord;
        }

        // Add a new data source
        public function addDataSource(DataSourceInterface $dataSource)
        {
                $this->dataSources[] = $dataSource;
                return $this;
        }

        // Resolve the current request, sending it through all data sources, finalizing log and timeline
        public function resolveRequest()
        {
                foreach ($this->dataSources as $dataSource) {
                        $dataSource->resolve($this->request);
                }

                $this->request->log()->sort();
                $this->request->timeline()->finalize($this->request->time);

                return $this;
        }

        // Resolve the current request as a "command" type request with command-specific data
        public function resolveAsCommand($name, $exitCode = null, $arguments = [], $options = [], $argumentsDefaults = [], $optionsDefaults = [], $output = null)
        {
                $this->resolveRequest();

                $this->request->type = RequestType::COMMAND;
                $this->request->commandName = $name;
                $this->request->commandArguments = $arguments;
                $this->request->commandArgumentsDefaults = $argumentsDefaults;
                $this->request->commandOptions = $options;
                $this->request->commandOptionsDefaults = $optionsDefaults;
                $this->request->commandExitCode = $exitCode;
                $this->request->commandOutput = $output;

                return $this;
        }

        // Resolve the current request as a "queue-job" type request with queue-job-specific data
        public function resolveAsQueueJob($name, $description = null, $status = 'processed', $payload = [], $queue = null, $connection = null, $options = [])
        {
                $this->resolveRequest();

                $this->request->type = RequestType::QUEUE_JOB;
                $this->request->jobName = $name;
                $this->request->jobDescription = $description;
                $this->request->jobStatus = $status;
                $this->request->jobPayload = (new Serializer)->normalize($payload);
                $this->request->jobQueue = $queue;
                $this->request->jobConnection = $connection;
                $this->request->jobOptions = (new Serializer)->normalizeEach($options);

                return $this;
        }

        // Resolve the current request as a "test" type request with test-specific data, accepts test name, status, status
        // message in case of failure and array of ran asserts
        public function resolveAsTest($name, $status = 'passed', $statusMessage = null, $asserts = [])
        {
                $this->resolveRequest();

                $this->request->type = RequestType::TEST;
                $this->request->testName = $name;
                $this->request->testStatus = $status;
                $this->request->testStatusMessage = $statusMessage;

                foreach ($asserts as $assert) {
                        $this->request->addTestAssert($assert['name'], $assert['arguments'], $assert['passed'], $assert['trace']);
                }

                return $this;
        }

        // Extends the request with an additional data form all data sources, which is not required for normal use
        public function extendRequest(Request $request = null)
        {
                foreach ($this->dataSources as $dataSource) {
                        $dataSource->extend($request ?: $this->request);
                }

                return $this;
        }

        // Store the current request via configured storage implementation
        public function storeRequest()
        {
                return $this->storage->store($this->request);
        }

        // Reset all data sources to an empty state, clearing any collected data
        public function reset()
        {
                foreach ($this->dataSources as $dataSource) {
                        $dataSource->reset();
                }

                return $this;
        }

        // Get or set the current request instance
        public function request(Request $request = null)
        {
                if (! $request) return $this->request;

                $this->request = $request;
                return $this;
        }

        // Get the log instance for the current request or log a new message
        public function log($level = null, $message = null, array $context = [])
        {
                if ($level) {
                        return $this->request->log()->log($level, $message, $context);
                }

                return $this->request->log();
        }

        // Get the timeline instance for the current request
        public function timeline()
        {
                return $this->request->timeline();
        }

        // Shortcut to create a new event on the current timeline instance
        public function event($description, $data = [])
        {
                return $this->request->timeline()->event($description, $data);
        }

        // Configure which requests should be collected, can be called with arrey of options, a custom closure or with no
        // arguments for a fluent configuration api
        public function shouldCollect($shouldCollect = null)
        {
                if ($shouldCollect instanceof Closure) return $this->shouldCollect->callback($shouldCollect);

                if (is_array($shouldCollect)) return $this->shouldCollect->merge($shouldCollect);

                return $this->shouldCollect;
        }

        // Configure which requests should be recorded, can be called with arrey of options, a custom closure or with no
        // arguments for a fluent configuration api
        public function shouldRecord($shouldRecord = null)
        {
                if ($shouldRecord instanceof Closure) return $this->shouldRecord->callback($shouldRecord);

                if (is_array($shouldRecord)) return $this->shouldRecord->merge($shouldRecord);

                return $this->shouldRecord;
        }

        // Get or set all data sources at once
        public function dataSources($dataSources = null)
        {
                if (! $dataSources) return $this->dataSources;

                $this->dataSources = $dataSources;
                return $this;
        }

        // Get or set a storage implementation
        public function storage(StorageInterface $storage = null)
        {
                if (! $storage) return $this->storage;

                $this->storage = $storage;
                return $this;
        }

        // Get or set an authenticator implementation
        public function authenticator(AuthenticatorInterface $authenticator = null)
        {
                if (! $authenticator) return $this->authenticator;

                $this->authenticator = $authenticator;
                return $this;
        }

        // Forward any other method calls to the current request and log instances
        public function __call($method, $args)
        {
                if (in_array($method, [ 'emergency', 'alert', 'critical', 'error', 'warning', 'notice', 'info', 'debug' ])) {
                        return $this->request->log()->$method(...$args);
                }

                return $this->request->$method(...$args);
        }

        // DEPRECATED The following apis are deprecated and will be removed in a future version

        // Get all added data sources
        public function getDataSources()
        {
                return $this->dataSources;
        }

        // Get the current request instance
        public function getRequest()
        {
                return $this->request;
        }

        // Set the current request instance
        public function setRequest(Request $request)
        {
                $this->request = $request;
                return $this;
        }

        // Get a storage implementation
        public function getStorage()
        {
                return $this->storage;
        }

        // Set a storage implementation
        public function setStorage(StorageInterface $storage)
        {
                $this->storage = $storage;
                return $this;
        }

        // Get an authenticator implementation
        public function getAuthenticator()
        {
                return $this->authenticator;
        }

        // Set an authenticator implementation
        public function setAuthenticator(AuthenticatorInterface $authenticator)
        {
                $this->authenticator = $authenticator;
                return $this;
        }
}