Repository::disable() - Code Metrics - Inspection of "Move duplicated logic from clients and resources i..." - php-api-clients/travis - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#1)

by Cees-Jan

created 2016-12-23 07:15 UTC

Repository::disable() A

↳ Parent: Repository

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	0

<?php declare(strict_types=1);

namespace ApiClients\Client\Travis\Resource\Async;

use ApiClients\Client\Pusher\CommandBus\Command\SharedAppClientCommand;
use ApiClients\Client\Travis\ApiSettings;
use ApiClients\Client\Travis\CommandBus\Command;
use ApiClients\Client\Travis\Resource\Repository as BaseRepository;
use ApiClients\Foundation\Hydrator\CommandBus\Command\HydrateCommand;
use ApiClients\Foundation\Transport\CommandBus\Command\RequestCommand;
use ApiClients\Foundation\Transport\CommandBus\Command\SimpleRequestCommand;
use ApiClients\Foundation\Transport\JsonStream;
use GuzzleHttp\Psr7\Request;
use Psr\Http\Message\ResponseInterface;
use React\Promise\PromiseInterface;
use Rx\Observable;
use Rx\ObservableInterface;
use Rx\Observer\CallbackObserver;
use Rx\ObserverInterface;
use Rx\React\Promise;
use Rx\SchedulerInterface;
use function ApiClients\Tools\Rx\unwrapObservableFromPromise;
use function React\Promise\reject;
use function React\Promise\resolve;

class Repository extends BaseRepository
{
    public function builds(): Observable
    {
        return unwrapObservableFromPromise($this->handleCommand(
            new Command\BuildsCommand($this->slug())
        ));
    }

    public function jobs(int $buildId): Observable
    {
        return Promise::toObservable($this->build($buildId))->flatMap(function (Build $build) {

            return $build->jobs();
        });
    }

    /**
     * @param int $id
     * @return PromiseInterface
     */
    public function build(int $id): PromiseInterface
    {
        return $this->handleCommand(new BuildCommand($id));
    }

    /**
     * @return ObservableInterface
     */
    public function commits(): ObservableInterface
    {
        return unwrapObservableFromPromise($this->handleCommand(
            new Command\CommitsCommand($this->slug())
        ));
    }

    public function events(): Observable
    {
        return Observable::create(function (
            ObserverInterface $observer,
            SchedulerInterface $scheduler

        ) {
            $this->handleCommand(
                new SharedAppClientCommand(ApiSettings::PUSHER_KEY)
            )->then(function ($pusher) use ($observer) {
                $pusher->channel('repo-' . $this->id)->filter(function ($message) {
                    return in_array($message->event, [
                        'build:created',
                        'build:started',
                        'build:finished',
                    ]);
                })->map(function ($message) {
                    return json_decode($message->data, true);
                })->filter(function ($json) {
                    return isset($json['repository']);
                })->flatMap(function ($json) {
                    return Promise::toObservable(
                        $this->handleCommand(
                            new HydrateCommand('Repository', $json['repository'])
                        )
                    );
                })->subscribe(new CallbackObserver(function ($repository) use ($observer) {
                    $observer->onNext($repository);
                }));
            });
        });
    }

    /**
     * @return PromiseInterface
     */
    public function settings(): PromiseInterface
    {
        return $this->handleCommand(
            new Command\SettingsCommand($this->id())
        );
    }

    /**
     * @return PromiseInterface
     */
    public function isActive(): PromiseInterface
    {
        return $this->handleCommand(new SimpleRequestCommand('hooks'))->then(function (ResponseInterface $response) {
            $active = false;
            foreach ($response->getBody()->getJson()['hooks'] as $hook) {
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
                if ($hook['id'] == $this->id()) {
                    $active = (bool)$hook['active'];
                    break;
                }
            }

            if ($active) {
                return resolve($active);
            }

            return reject($active);
        });
    }

    /**
     * @return PromiseInterface
     */
    public function enable(): PromiseInterface
    {
        return $this->setActiveStatus(true);
    }

    /**
     * @return PromiseInterface
     */
    public function disable(): PromiseInterface
    {
        return $this->setActiveStatus(false);
    }

    /**
     * @param bool $status
     * @return PromiseInterface
     */
    protected function setActiveStatus(bool $status)
    {
        return $this->handleCommand(new RequestCommand(
            new Request(
                'PUT',
                'hooks/' . $this->id(),
                [],
                new JsonStream([
                    'hook' => [
                        'active' => $status,
                    ],
                ])
            )
        ))->then(function () {
            return $this->refresh();
        });
    }

    /**
     * @return ObservableInterface
     */
    public function branches(): ObservableInterface
    {
        return unwrapObservableFromPromise($this->handleCommand(
            new Command\BranchesCommand($this->id())
        ));
    }

    /**
     * @return ObservableInterface
     */
    public function vars(): ObservableInterface
    {
        return unwrapObservableFromPromise($this->handleCommand(
            new Command\VarsCommand($this->id())
        ));
    }

    /**
     * @return ObservableInterface
     */
    public function caches(): ObservableInterface
    {
        return unwrapObservableFromPromise($this->handleCommand(
            new Command\CachesCommand($this->id())
        ));
    }

    /**
     * @return PromiseInterface
     */
    public function key(): PromiseInterface
    {
        return $this->handleCommand(
            new Command\RepositoryKeyCommand($this->slug())
        );
    }

    public function refresh(): PromiseInterface
    {
        return $this->handleCommand(
            new Command\RepositoryCommand($this->slug)
        );
    }
}


GitHub Access Token became invalid

Pull Request — master (#1)

Repository::disable() A

Complexity

Size

Duplication

Importance

Available Fixes

1			<?php declare(strict_types=1);
2
3			namespace ApiClients\Client\Travis\Resource\Async;
4
5			use ApiClients\Client\Pusher\CommandBus\Command\SharedAppClientCommand;
6			use ApiClients\Client\Travis\ApiSettings;
7			use ApiClients\Client\Travis\CommandBus\Command;
8			use ApiClients\Client\Travis\Resource\Repository as BaseRepository;
9			use ApiClients\Foundation\Hydrator\CommandBus\Command\HydrateCommand;
10			use ApiClients\Foundation\Transport\CommandBus\Command\RequestCommand;
11			use ApiClients\Foundation\Transport\CommandBus\Command\SimpleRequestCommand;
12			use ApiClients\Foundation\Transport\JsonStream;
13			use GuzzleHttp\Psr7\Request;
14			use Psr\Http\Message\ResponseInterface;
15			use React\Promise\PromiseInterface;
16			use Rx\Observable;
17			use Rx\ObservableInterface;
18			use Rx\Observer\CallbackObserver;
19			use Rx\ObserverInterface;
20			use Rx\React\Promise;
21			use Rx\SchedulerInterface;
22			use function ApiClients\Tools\Rx\unwrapObservableFromPromise;
23			use function React\Promise\reject;
24			use function React\Promise\resolve;
25
26			class Repository extends BaseRepository
27			{
28			public function builds(): Observable
29			{
30			return unwrapObservableFromPromise($this->handleCommand(
31			new Command\BuildsCommand($this->slug())
32			));
33			}
34
35			public function jobs(int $buildId): Observable
36			{
37			return Promise::toObservable($this->build($buildId))->flatMap(function (Build $build) {
			0 ignored issues – show Compatibility introduced 2016-12-18 00:01 UTC by Report Bug Copy Issue Report `$this->build($buildId)` of type `object<React\Promise\PromiseInterface>` is not a sub-type of `object<React\Promise\CancellablePromiseInterface>`. It seems like you assume a child interface of the interface `React\Promise\PromiseInterface` to be always present. This check looks for parameters that are defined as one type in their type hint or doc comment but seem to be used as a narrower type, i.e an implementation of an interface or a subclass. Consider changing the type of the parameter or doing an instanceof check before assuming your parameter is of the expected type. Loading history...
38			return $build->jobs();
39			});
40			}
41
42			/**
43			* @param int $id
44			* @return PromiseInterface
45			*/
46			public function build(int $id): PromiseInterface
47			{
48			return $this->handleCommand(new BuildCommand($id));
49			}
50
51			/**
52			* @return ObservableInterface
53			*/
54			public function commits(): ObservableInterface
55			{
56			return unwrapObservableFromPromise($this->handleCommand(
57			new Command\CommitsCommand($this->slug())
58			));
59			}
60
61			public function events(): Observable
62			{
63			return Observable::create(function (
64			ObserverInterface $observer,
65			SchedulerInterface $scheduler
			0 ignored issues – show Unused Code introduced 2016-12-04 10:43 UTC by Report Bug Copy Issue Report The parameter `$scheduler` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
66			) {
67			$this->handleCommand(
68			new SharedAppClientCommand(ApiSettings::PUSHER_KEY)
69			)->then(function ($pusher) use ($observer) {
70			$pusher->channel('repo-' . $this->id)->filter(function ($message) {
71			return in_array($message->event, [
72			'build:created',
73			'build:started',
74			'build:finished',
75			]);
76			})->map(function ($message) {
77			return json_decode($message->data, true);
78			})->filter(function ($json) {
79			return isset($json['repository']);
80			})->flatMap(function ($json) {
81			return Promise::toObservable(
82			$this->handleCommand(
83			new HydrateCommand('Repository', $json['repository'])
84			)
85			);
86			})->subscribe(new CallbackObserver(function ($repository) use ($observer) {
87			$observer->onNext($repository);
88			}));
89			});
90			});
91			}
92
93			/**
94			* @return PromiseInterface
95			*/
96			public function settings(): PromiseInterface
97			{
98			return $this->handleCommand(
99			new Command\SettingsCommand($this->id())
100			);
101			}
102
103			/**
104			* @return PromiseInterface
105			*/
106			public function isActive(): PromiseInterface
107			{
108			return $this->handleCommand(new SimpleRequestCommand('hooks'))->then(function (ResponseInterface $response) {
109			$active = false;
110			foreach ($response->getBody()->getJson()['hooks'] as $hook) {
			0 ignored issues – show Bug introduced 2016-12-04 10:43 UTC by Report Bug Copy Issue Report It seems like you code against a concrete implementation and not the interface `Psr\Http\Message\StreamInterface` as the method `getJson()` does only exist in the following implementations of said interface: `ApiClients\Foundation\Transport\JsonStream`. Let’s take a look at an example: interface User { /** @return string / public function getPassword(); } class MyUser implements User { public function getPassword() { // return something } public function getDisplayName() { // return some name. } } class AuthSystem { public function authenticate(User $user) { $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName())); // do something. } } In the above example, the authenticate() method works fine as long as you just pass instances of MyUser. However, if you now also want to pass a different implementation of User which does not have a getDisplayName() method, the code will break. Available Fixes Change the type-hint for the parameter: class AuthSystem { public function authenticate(MyUser $user) { / ... / } } Add an additional type-check: class AuthSystem { public function authenticate(User $user) { if ($user instanceof MyUser) { $this->logger->info(/* ... /); } // or alternatively if ( ! $user instanceof MyUser) { throw new \LogicException( '$user must be an instance of MyUser, ' .'other instances are not supported.' ); } } } Note:* PHP Analyzer uses reverse abstract interpretation to narrow down the types inside the if block in such a case. Add the method to the interface: interface User { /** @return string / public function getPassword(); /* @return string */ public function getDisplayName(); } Loading history...
111			if ($hook['id'] == $this->id()) {
112			$active = (bool)$hook['active'];
113			break;
114			}
115			}
116
117			if ($active) {
118			return resolve($active);
119			}
120
121			return reject($active);
122			});
123			}
124
125			/**
126			* @return PromiseInterface
127			*/
128			public function enable(): PromiseInterface
129			{
130			return $this->setActiveStatus(true);
131			}
132
133			/**
134			* @return PromiseInterface
135			*/
136			public function disable(): PromiseInterface
137			{
138			return $this->setActiveStatus(false);
139			}
140
141			/**
142			* @param bool $status
143			* @return PromiseInterface
144			*/
145			protected function setActiveStatus(bool $status)
146			{
147			return $this->handleCommand(new RequestCommand(
148			new Request(
149			'PUT',
150			'hooks/' . $this->id(),
151			[],
152			new JsonStream([
153			'hook' => [
154			'active' => $status,
155			],
156			])
157			)
158			))->then(function () {
159			return $this->refresh();
160			});
161			}
162
163			/**
164			* @return ObservableInterface
165			*/
166			public function branches(): ObservableInterface
167			{
168			return unwrapObservableFromPromise($this->handleCommand(
169			new Command\BranchesCommand($this->id())
170			));
171			}
172
173			/**
174			* @return ObservableInterface
175			*/
176			public function vars(): ObservableInterface
177			{
178			return unwrapObservableFromPromise($this->handleCommand(
179			new Command\VarsCommand($this->id())
180			));
181			}
182
183			/**
184			* @return ObservableInterface
185			*/
186			public function caches(): ObservableInterface
187			{
188			return unwrapObservableFromPromise($this->handleCommand(
189			new Command\CachesCommand($this->id())
190			));
191			}
192
193			/**
194			* @return PromiseInterface
195			*/
196			public function key(): PromiseInterface
197			{
198			return $this->handleCommand(
199			new Command\RepositoryKeyCommand($this->slug())
200			);
201			}
202
203			public function refresh(): PromiseInterface
204			{
205			return $this->handleCommand(
206			new Command\RepositoryCommand($this->slug)
207			);
208			}
209			}
210

php-api-clients / travis

GitHub Access Token became invalid

Pull Request — master (#1)

Repository::disable() A

Complexity

Size

Duplication

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like