Requester::getFollowRequests() - Code Metrics - Inspection of "Modify .gitignore (doc/ -crlf -diff)" - BaguettePHP/mastodon-api - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 6c2ea7...962f60 )

by Luka

created 2017-05-17 18:24 UTC

Requester::getFollowRequests() B

↳ Parent: Requester

Complexity

Conditions	4
Paths	8

Size

Total Lines	26
Code Lines	16

Duplication

Lines	26
Ratio	100 %

Code Coverage

Tests	0
CRAP Score	20

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	4
eloc	16
c	1
b	0
f	0
nc	8
nop	3
dl	26
loc	26
ccs	0
cts	15
cp	0
crap	20
rs	8.5806

<?php

namespace Baguette\Mastodon;

use Baguette\Mastodon\Client;
use Baguette\Mastodon\Entity;
use Baguette\Mastodon\Service\SessionStorage;
use Baguette\Mastodon\Service\Toot;
use Psr\Http\Message\ResponseInterface;
use Respect\Validation\Validator as v;

/**
 * Mastodon Anthorization object factory
 *
 * @see https://github.com/tootsuite/documentation/blob/master/Using-the-API/API.md
 * @author    USAMI Kenta <[email protected]>
 * @copyright 2017 Baguette HQ
 * @license   https://www.gnu.org/licenses/gpl-3.0.html GPL-3.0
 */
class Requester
{
    //
    // Account API
    //

    /**
     * Fetching an account
     *
     * @see https://github.com/tootsuite/documentation/blob/master/Using-the-API/API.md#fetching-an-account
     * @param  Client         $client
     * @param  SessionStorage $session
     * @param  int            $id
     * @return Entity\Account
     */
    public static function getAccount(Client $client, SessionStorage $session, $id)
    {
        v::intVal()->min(0)->assert($id);

        return static::map(
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
            Entity\Account::class,
            $client->requestAPI('GET', sprintf('/api/v1/accounts/%d', $id), [], $session)
        );
    }

    /**
     * Getting the current user
     *
     * @see https://github.com/tootsuite/documentation/blob/master/Using-the-API/API.md#getting-the-current-user
     * @param  Client         $client
     * @param  SessionStorage $session
     * @return Entity\Account
     */
    public static function getAccountCurrentUser(Client $client, SessionStorage $session)
    {
        return static::map(
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
            Entity\Account::class,
            $client->requestAPI('GET', '/api/v1/accounts/verify_credentials', [], $session)
        );
    }

    /**
     * Updating the current user
     *
     * @see https://github.com/tootsuite/documentation/blob/master/Using-the-API/API.md#updating-the-current-user
     * @param  Client         $client
     * @param  SessionStorage $session
     * @param  array          $update_data
     * @return Entity\Account
     */
    public static function updateAccount(Client $client, SessionStorage $session, $update_data)
    {
        $form_params = [];

        if (isset($update_data['display_name'])) {
            v::stringType()->assert($update_data['display_name']);
            $form_params['display_name'] = (string)$update_data['display_name'];
        }

        if (isset($update_data['note'])) {
            v::stringType()->assert($update_data['note']);
            $form_params['note'] = (string)$update_data['note'];
        }

        return static::map(
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
            Entity\Account::class,
            $client->requestAPI('PATCH', '/api/v1/accounts/update_credentials', [
                'form_params' => $form_params
            ], $session)
        );
    }

    /**
     * Getting an account's followers
     *
     * @see https://github.com/tootsuite/documentation/blob/master/Using-the-API/API.md#updating-the-current-user
     * @param  Client         $client
     * @param  SessionStorage $session
     * @param  int            $account_id
     * @return Entity\Account[]
     */
    public static function getAccountFollowers(Client $client, SessionStorage $session, $account_id)
    {
        v::intVal()->assert($account_id);

        $query = [];

        return static::map(
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
            [Entity\Account::class],
            $client->requestAPI('GET', sprintf('/api/v1/accounts/%d/followers', $account_id), [
                'query' => $query
            ], $session)
        );
    }

    /**
     * Fetching a user's blocks
     *
     * @see https://github.com/tootsuite/documentation/blob/master/Using-the-API/API.md#updating-the-current-user
     * @param  Client         $client
     * @param  SessionStorage $session
     * @param  array          $options
     * @return Entity\Account[]
     */
    public static function getBlocks(Client $client, SessionStorage $session, $options = [])

    {
        $query = [];

        if (isset($options['max_id'])) {
            v::intVal()->min(0)->assert($options['max_id']);
            $query['max_id'] = $options['max_id'];
        }

        if (isset($options['since_id'])) {
            v::intVal()->min(0)->assert($options['since_id']);
            $query['since_id'] = $options['since_id'];
        }

        if (isset($options['limit'])) {
            v::intVal()->min(0)->assert($options['limit']);
            $query['limit'] = $options['limit'];
        }

        return static::map(
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
            [Entity\Account::class],
            $client->requestAPI('GET', '/api/v1/blocks', [
                'query' => $query,
            ], $session)
        );
    }

    /**
     * Fetching a user's favourites
     *
     * @see https://github.com/tootsuite/documentation/blob/master/Using-the-API/API.md#updating-the-current-user
     * @param  Client         $client
     * @param  SessionStorage $session
     * @param  array          $options
     * @return Entity\Status[]
     */
    public static function getFavourites(Client $client, SessionStorage $session, $options = [])

    {
        $query = [];

        if (isset($options['max_id'])) {
            v::intVal()->min(0)->assert($options['max_id']);
            $query['max_id'] = $options['max_id'];
        }

        if (isset($options['since_id'])) {
            v::intVal()->min(0)->assert($options['since_id']);
            $query['since_id'] = $options['since_id'];
        }

        if (isset($options['limit'])) {
            v::intVal()->min(0)->assert($options['limit']);
            $query['limit'] = $options['limit'];
        }

        return static::map(
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
            [Entity\Status::class],
            $client->requestAPI('GET', '/api/v1/favourites', [
                'query' => $query,
            ], $session)
        );
    }

    /**
     * Fetching a list of follow requests
     *
     * @see https://github.com/tootsuite/documentation/blob/master/Using-the-API/API.md#fetching-a-list-of-follow-requests
     * @param  Client         $client
     * @param  SessionStorage $session
     * @param  array          $options
     * @return Entity\Accounts[]
     */
    public static function getFollowRequests(Client $client, SessionStorage $session, $options = [])

    {
        $query = [];

        if (isset($options['max_id'])) {
            v::intVal()->min(0)->assert($options['max_id']);
            $query['max_id'] = $options['max_id'];
        }

        if (isset($options['since_id'])) {
            v::intVal()->min(0)->assert($options['since_id']);
            $query['since_id'] = $options['since_id'];
        }

        if (isset($options['limit'])) {
            v::intVal()->min(0)->assert($options['limit']);
            $query['limit'] = $options['limit'];
        }

        return static::map(
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
            [Entity\Account::class],
            $client->requestAPI('GET', '/api/v1/follow_requests', [
                'query' => $query,
            ], $session)
        );
    }

    //
    // Status API
    //

    /**
     * Posting a new status
     *
     * @see https://github.com/tootsuite/documentation/blob/master/Using-the-API/API.md#posting-a-new-status
     * @param Toot $toot
     * @return Entity\Account
     */
    public static function postStatus(Client $client, SessionStorage $session, Toot $toot)
    {
        $form_params = [
            'status' => $toot->toot_string,
        ];

        if ($toot->sensitive) {
            $form_params['sensitive'] = 'true';
        }

        if ($toot->in_reply_to_id) {
0   == false // true
0   == null  // true
123 == false // false
123 == null  // false

// It is often better to use strict comparison
0 === false // false
0 === null  // false
            $form_params['in_reply_to_id'] = $toot->in_reply_to_id;
        }

        if (count($toot->media_ids) > 0) {
            $form_params['media_ids'] = $toot->media_ids;
        }

        if ($toot->visibility === null) {
            $form_params['visibility'] = $toot->visibility;
        }

        return static::map(
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
            Entity\Status::class,
            $client->requestAPI('POST', '/api/v1/statuses', [
                'form_params' => $form_params
            ], $session)
        );
    }

    //
    // Utility method
    //

    /**
     * @param  string|string[]   $class
     * @param  ResponseInterface $response
     * @return Entity\Entity|Entity\Entity[]
     */
    private static function map($class, ResponseInterface $response)
    {
        return Entity\map(
            $class,
            \GuzzleHttp\json_decode($response->getBody(), true)
        );
    }
}


1			<?php
2
3			namespace Baguette\Mastodon;
4
5			use Baguette\Mastodon\Client;
6			use Baguette\Mastodon\Entity;
7			use Baguette\Mastodon\Service\SessionStorage;
8			use Baguette\Mastodon\Service\Toot;
9			use Psr\Http\Message\ResponseInterface;
10			use Respect\Validation\Validator as v;
11
12			/**
13			* Mastodon Anthorization object factory
14			*
15			* @see https://github.com/tootsuite/documentation/blob/master/Using-the-API/API.md
16			* @author USAMI Kenta <[email protected]>
17			* @copyright 2017 Baguette HQ
18			* @license https://www.gnu.org/licenses/gpl-3.0.html GPL-3.0
19			*/
20			class Requester
21			{
22			//
23			// Account API
24			//
25
26			/**
27			* Fetching an account
28			*
29			* @see https://github.com/tootsuite/documentation/blob/master/Using-the-API/API.md#fetching-an-account
30			* @param Client $client
31			* @param SessionStorage $session
32			* @param int $id
33			* @return Entity\Account
34			*/
35	1		public static function getAccount(Client $client, SessionStorage $session, $id)
36			{
37	1		v::intVal()->min(0)->assert($id);
38
39	1		return static::map(
			0 ignored issues – show Bug introduced 2017-05-05 05:00 UTC by Report Bug Copy Issue Report Since `map()` is declared private, calling it with `static` will lead to errors in possible sub-classes. You can either use `self`, or increase the visibility of `map()` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static function getTemperature() { return "3422 °C"; } public static function getSomeVariable() { return static::getTemperature(); } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { private static function getTemperature() { return "-182 °C"; } } print YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class YourClass { private static function getTemperature() { return "3422 °C"; } public static function getSomeVariable() { return self::getTemperature(); } } Loading history... Bug Compatibility introduced 2017-05-05 05:00 UTC by Report Bug Copy Issue Report The expression `static::map(\Baguette\Ma...), array(), $session));` of type `object\|array` adds the type `array` to the return on line 39 which is incompatible with the return type documented by `Baguette\Mastodon\Requester::getAccount` of type `Baguette\Mastodon\Entity\Account`. Loading history...
40	1		Entity\Account::class,
41	1		$client->requestAPI('GET', sprintf('/api/v1/accounts/%d', $id), [], $session)
42			);
43			}
44
45			/**
46			* Getting the current user
47			*
48			* @see https://github.com/tootsuite/documentation/blob/master/Using-the-API/API.md#getting-the-current-user
49			* @param Client $client
50			* @param SessionStorage $session
51			* @return Entity\Account
52			*/
53			public static function getAccountCurrentUser(Client $client, SessionStorage $session)
54			{
55			return static::map(
			0 ignored issues – show Bug introduced 2017-05-05 05:00 UTC by Report Bug Copy Issue Report Since `map()` is declared private, calling it with `static` will lead to errors in possible sub-classes. You can either use `self`, or increase the visibility of `map()` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static function getTemperature() { return "3422 °C"; } public static function getSomeVariable() { return static::getTemperature(); } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { private static function getTemperature() { return "-182 °C"; } } print YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class YourClass { private static function getTemperature() { return "3422 °C"; } public static function getSomeVariable() { return self::getTemperature(); } } Loading history... Bug Compatibility introduced 2017-05-05 05:00 UTC by Report Bug Copy Issue Report The expression `static::map(\Baguette\Ma...', array(), $session));` of type `object\|array` adds the type `array` to the return on line 55 which is incompatible with the return type documented by `Baguette\Mastodon\Requester::getAccountCurrentUser` of type `Baguette\Mastodon\Entity\Account`. Loading history...
56			Entity\Account::class,
57			$client->requestAPI('GET', '/api/v1/accounts/verify_credentials', [], $session)
58			);
59			}
60
61			/**
62			* Updating the current user
63			*
64			* @see https://github.com/tootsuite/documentation/blob/master/Using-the-API/API.md#updating-the-current-user
65			* @param Client $client
66			* @param SessionStorage $session
67			* @param array $update_data
68			* @return Entity\Account
69			*/
70			public static function updateAccount(Client $client, SessionStorage $session, $update_data)
71			{
72			$form_params = [];
73
74			if (isset($update_data['display_name'])) {
75			v::stringType()->assert($update_data['display_name']);
76			$form_params['display_name'] = (string)$update_data['display_name'];
77			}
78
79			if (isset($update_data['note'])) {
80			v::stringType()->assert($update_data['note']);
81			$form_params['note'] = (string)$update_data['note'];
82			}
83
84			return static::map(
			0 ignored issues – show Bug introduced 2017-05-05 05:00 UTC by Report Bug Copy Issue Report Since `map()` is declared private, calling it with `static` will lead to errors in possible sub-classes. You can either use `self`, or increase the visibility of `map()` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static function getTemperature() { return "3422 °C"; } public static function getSomeVariable() { return static::getTemperature(); } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { private static function getTemperature() { return "-182 °C"; } } print YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class YourClass { private static function getTemperature() { return "3422 °C"; } public static function getSomeVariable() { return self::getTemperature(); } } Loading history... Bug Compatibility introduced 2017-05-05 05:00 UTC by Report Bug Copy Issue Report The expression `static::map(\Baguette\Ma...rm_params), $session));` of type `object\|array` adds the type `array` to the return on line 84 which is incompatible with the return type documented by `Baguette\Mastodon\Requester::updateAccount` of type `Baguette\Mastodon\Entity\Account`. Loading history...
85			Entity\Account::class,
86			$client->requestAPI('PATCH', '/api/v1/accounts/update_credentials', [
87			'form_params' => $form_params
88			], $session)
89			);
90			}
91
92			/**
93			* Getting an account's followers
94			*
95			* @see https://github.com/tootsuite/documentation/blob/master/Using-the-API/API.md#updating-the-current-user
96			* @param Client $client
97			* @param SessionStorage $session
98			* @param int $account_id
99			* @return Entity\Account[]
100			*/
101			public static function getAccountFollowers(Client $client, SessionStorage $session, $account_id)
102			{
103			v::intVal()->assert($account_id);
104
105			$query = [];
106
107			return static::map(
			0 ignored issues – show Bug introduced 2017-05-05 05:00 UTC by Report Bug Copy Issue Report Since `map()` is declared private, calling it with `static` will lead to errors in possible sub-classes. You can either use `self`, or increase the visibility of `map()` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static function getTemperature() { return "3422 °C"; } public static function getSomeVariable() { return static::getTemperature(); } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { private static function getTemperature() { return "-182 °C"; } } print YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class YourClass { private static function getTemperature() { return "3422 °C"; } public static function getSomeVariable() { return self::getTemperature(); } } Loading history...
108			[Entity\Account::class],
109			$client->requestAPI('GET', sprintf('/api/v1/accounts/%d/followers', $account_id), [
110			'query' => $query
111			], $session)
112			);
113			}
114
115			/**
116			* Fetching a user's blocks
117			*
118			* @see https://github.com/tootsuite/documentation/blob/master/Using-the-API/API.md#updating-the-current-user
119			* @param Client $client
120			* @param SessionStorage $session
121			* @param array $options
122			* @return Entity\Account[]
123			*/
124		View Code Duplication	public static function getBlocks(Client $client, SessionStorage $session, $options = [])
			0 ignored issues – show Duplication introduced 2017-05-05 05:00 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
125			{
126			$query = [];
127
128			if (isset($options['max_id'])) {
129			v::intVal()->min(0)->assert($options['max_id']);
130			$query['max_id'] = $options['max_id'];
131			}
132
133			if (isset($options['since_id'])) {
134			v::intVal()->min(0)->assert($options['since_id']);
135			$query['since_id'] = $options['since_id'];
136			}
137
138			if (isset($options['limit'])) {
139			v::intVal()->min(0)->assert($options['limit']);
140			$query['limit'] = $options['limit'];
141			}
142
143			return static::map(
			0 ignored issues – show Bug introduced 2017-05-05 05:00 UTC by Report Bug Copy Issue Report Since `map()` is declared private, calling it with `static` will lead to errors in possible sub-classes. You can either use `self`, or increase the visibility of `map()` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static function getTemperature() { return "3422 °C"; } public static function getSomeVariable() { return static::getTemperature(); } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { private static function getTemperature() { return "-182 °C"; } } print YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class YourClass { private static function getTemperature() { return "3422 °C"; } public static function getSomeVariable() { return self::getTemperature(); } } Loading history...
144			[Entity\Account::class],
145			$client->requestAPI('GET', '/api/v1/blocks', [
146			'query' => $query,
147			], $session)
148			);
149			}
150
151			/**
152			* Fetching a user's favourites
153			*
154			* @see https://github.com/tootsuite/documentation/blob/master/Using-the-API/API.md#updating-the-current-user
155			* @param Client $client
156			* @param SessionStorage $session
157			* @param array $options
158			* @return Entity\Status[]
159			*/
160		View Code Duplication	public static function getFavourites(Client $client, SessionStorage $session, $options = [])
			0 ignored issues – show Duplication introduced 2017-05-05 05:00 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
161			{
162			$query = [];
163
164			if (isset($options['max_id'])) {
165			v::intVal()->min(0)->assert($options['max_id']);
166			$query['max_id'] = $options['max_id'];
167			}
168
169			if (isset($options['since_id'])) {
170			v::intVal()->min(0)->assert($options['since_id']);
171			$query['since_id'] = $options['since_id'];
172			}
173
174			if (isset($options['limit'])) {
175			v::intVal()->min(0)->assert($options['limit']);
176			$query['limit'] = $options['limit'];
177			}
178
179			return static::map(
			0 ignored issues – show Bug introduced 2017-05-05 05:00 UTC by Report Bug Copy Issue Report Since `map()` is declared private, calling it with `static` will lead to errors in possible sub-classes. You can either use `self`, or increase the visibility of `map()` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static function getTemperature() { return "3422 °C"; } public static function getSomeVariable() { return static::getTemperature(); } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { private static function getTemperature() { return "-182 °C"; } } print YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class YourClass { private static function getTemperature() { return "3422 °C"; } public static function getSomeVariable() { return self::getTemperature(); } } Loading history...
180			[Entity\Status::class],
181			$client->requestAPI('GET', '/api/v1/favourites', [
182			'query' => $query,
183			], $session)
184			);
185			}
186
187			/**
188			* Fetching a list of follow requests
189			*
190			* @see https://github.com/tootsuite/documentation/blob/master/Using-the-API/API.md#fetching-a-list-of-follow-requests
191			* @param Client $client
192			* @param SessionStorage $session
193			* @param array $options
194			* @return Entity\Accounts[]
195			*/
196		View Code Duplication	public static function getFollowRequests(Client $client, SessionStorage $session, $options = [])
			0 ignored issues – show Duplication introduced 2017-05-17 18:26 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
197			{
198			$query = [];
199
200			if (isset($options['max_id'])) {
201			v::intVal()->min(0)->assert($options['max_id']);
202			$query['max_id'] = $options['max_id'];
203			}
204
205			if (isset($options['since_id'])) {
206			v::intVal()->min(0)->assert($options['since_id']);
207			$query['since_id'] = $options['since_id'];
208			}
209
210			if (isset($options['limit'])) {
211			v::intVal()->min(0)->assert($options['limit']);
212			$query['limit'] = $options['limit'];
213			}
214
215			return static::map(
			0 ignored issues – show Bug introduced 2017-05-17 18:26 UTC by Report Bug Copy Issue Report Since `map()` is declared private, calling it with `static` will lead to errors in possible sub-classes. You can either use `self`, or increase the visibility of `map()` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static function getTemperature() { return "3422 °C"; } public static function getSomeVariable() { return static::getTemperature(); } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { private static function getTemperature() { return "-182 °C"; } } print YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class YourClass { private static function getTemperature() { return "3422 °C"; } public static function getSomeVariable() { return self::getTemperature(); } } Loading history...
216			[Entity\Account::class],
217			$client->requestAPI('GET', '/api/v1/follow_requests', [
218			'query' => $query,
219			], $session)
220			);
221			}
222
223			//
224			// Status API
225			//
226
227			/**
228			* Posting a new status
229			*
230			* @see https://github.com/tootsuite/documentation/blob/master/Using-the-API/API.md#posting-a-new-status
231			* @param Toot $toot
232			* @return Entity\Account
233			*/
234			public static function postStatus(Client $client, SessionStorage $session, Toot $toot)
235			{
236			$form_params = [
237			'status' => $toot->toot_string,
238			];
239
240			if ($toot->sensitive) {
241			$form_params['sensitive'] = 'true';
242			}
243
244			if ($toot->in_reply_to_id) {
			0 ignored issues – show Bug Best Practice introduced 2017-05-05 05:00 UTC by Report Bug Copy Issue Report The expression `$toot->in_reply_to_id` of type `integer\|null` is loosely compared to `true`; this is ambiguous if the integer can be zero. You might want to explicitly use `!== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `integer` values, zero is a special case, in particular the following results might be unexpected: 0 == false // true 0 == null // true 123 == false // false 123 == null // false // It is often better to use strict comparison 0 === false // false 0 === null // false Loading history...
245			$form_params['in_reply_to_id'] = $toot->in_reply_to_id;
246			}
247
248			if (count($toot->media_ids) > 0) {
249			$form_params['media_ids'] = $toot->media_ids;
250			}
251
252			if ($toot->visibility === null) {
253			$form_params['visibility'] = $toot->visibility;
254			}
255
256			return static::map(
			0 ignored issues – show Bug introduced 2017-05-05 05:00 UTC by Report Bug Copy Issue Report Since `map()` is declared private, calling it with `static` will lead to errors in possible sub-classes. You can either use `self`, or increase the visibility of `map()` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static function getTemperature() { return "3422 °C"; } public static function getSomeVariable() { return static::getTemperature(); } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { private static function getTemperature() { return "-182 °C"; } } print YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class YourClass { private static function getTemperature() { return "3422 °C"; } public static function getSomeVariable() { return self::getTemperature(); } } Loading history... Bug Compatibility introduced 2017-05-05 05:00 UTC by Report Bug Copy Issue Report The expression `static::map(\Baguette\Ma...rm_params), $session));` of type `object\|array` adds the type `array` to the return on line 256 which is incompatible with the return type documented by `Baguette\Mastodon\Requester::postStatus` of type `Baguette\Mastodon\Entity\Account`. Loading history...
257			Entity\Status::class,
258			$client->requestAPI('POST', '/api/v1/statuses', [
259			'form_params' => $form_params
260			], $session)
261			);
262			}
263
264			//
265			// Utility method
266			//
267
268			/**
269			* @param string\|string[] $class
270			* @param ResponseInterface $response
271			* @return Entity\Entity\|Entity\Entity[]
272			*/
273	1		private static function map($class, ResponseInterface $response)
274			{
275	1		return Entity\map(
276			$class,
277	1		\GuzzleHttp\json_decode($response->getBody(), true)
278			);
279			}
280			}
281

BaguettePHP / mastodon-api

Push — master ( 6c2ea7...962f60 )

Requester::getFollowRequests() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like