HubphAPI - Code Metrics - g1a/hubph - Measure and Improve Code Quality continuously with Scrutinizer

HubphAPI A
last analyzed 2020-06-13 02:38 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	294
Duplicated Lines	2.72 %

Coupling/Cohesion

Components	2
Dependencies	6

Importance

Changes

Metric	Value
wmc	41
lcom	2
cbo	6
dl	8
loc	294
rs	9.1199
c	0
b	0
f	0

23 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	startLogging()	0	6	1
A	stopLogging()	0	7	2
A	setAs()	0	8	2
A	whoami()	0	6	1
A	repoCreate()	0	10	1
A	repoDelete()	0	4	1
A	prCreate()	0	12	1
A	prClose()	0	7	2
A	prMerge()	0	22	5
A	prCheck()	0	11	1
A	prStatuses()	0	26	3
A	addTokenAuthentication()	0	12	3
A	projectAndOrgFromUrl()	8	8	1
A	existingPRs()	0	4	1
A	matchingPRs()	0	10	1
A	allPRs()	0	9	1
A	logEvent()	0	6	2
A	gitHubAPI()	0	10	2
A	resultPager()	0	4	1
A	gitHubToken()	0	7	2
A	getGitHubToken()	0	32	5
A	getConfig()	0	4	1

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like HubphAPI often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use HubphAPI, and based on these observations, apply Extract Interface, too.

<?php

namespace Hubph;

use Consolidation\Config\ConfigInterface;
use Hubph\Internal\EventLogger;

class HubphAPI
{
    protected $config;
    protected $token;
    protected $gitHubAPI;
    protected $eventLogger;
    protected $as = 'default';

    /**
     * HubphAPI constructor
     */
    public function __construct(ConfigInterface $config)
    {
        $this->config = $config;
    }

    public function startLogging($filename)
    {
        $this->stopLogging();
        $this->eventLogger = new EventLogger($filename);
        $this->eventLogger->start();
    }

    public function stopLogging()
    {
        if ($this->eventLogger) {
            $this->eventLogger->stop();
        }
        $this->eventLogger = null;
    }

    public function setAs($as)
    {
        if ($as != $this->as) {
            $this->as = $as;
            $this->token = false;
            $this->gitHubAPI = false;
        }
    }

    public function whoami()
    {
        $gitHubAPI = $this->gitHubAPI();
        $authenticated = $gitHubAPI->api('current_user')->show();
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.
    }
}
        return $authenticated;
    }

    public function repoCreate($org, $project)
    {
        return $this->api->gitHubAPI()->api('repo')->create(
class MyClass { }

$x = new MyClass();
$x->foo = true;
            $project,
            '',
            '',
            true,
            $org
        );
    }

    public function repoDelete($org, $project)
    {
        return $this->api->gitHubAPI()->api('repo')->remove($org, $project);
    }

    public function prCreate($org, $project, $title, $body, $base, $head)
    {
        $params = [
            'title' => $title,
            'body' => $body,
            'base' => $base,
            'head' => $head,
        ];
        $response = $this->gitHubAPI()->api('pull_request')->create($org, $project, $params);
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.
    }
}
        $this->logEvent(__FUNCTION__, [$org, $project], $params, $response);
        return $this;
    }

    public function prClose($org, $project, PullRequests $prs)
    {
        foreach ($prs->prNumbers() as $n) {
            $gitHubAPI = $this->gitHubAPI();
            $gitHubAPI->api('pull_request')->update($org, $project, $n, ['state' => 'closed']);
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.
    }
}
        }
    }

    public function prMerge($org, $project, PullRequests $prs, $message, $mergeMethod = 'squash', $title = null)
    {
        // First, check to see if all of the pull requests can be merged,
        // and collect the sha hash of the head of the branch.
        $allClean = true;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $shas = [];
        foreach ($prs->prNumbers() as $n) {
            $pullRequest = $this->gitHubAPI()->api('pull_request')->show($org, $project, $n);
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.
    }
}
            $is_clean = $pullRequest['mergeable'] && $pullRequest['mergeable_state'] == 'clean';
            if (!$is_clean) {
                return false;
            }
            $shas[$n] = $pullRequest['head']['sha'];
        }

        // Merge all of the pull requests
        foreach ($shas as $n => $sha) {
            $response = $this->gitHubAPI()->api('pull_request')->merge($org, $project, $n, $message, $sha, $mergeMethod, $title);
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.
    }
}
            $this->logEvent(__FUNCTION__, [$org, $project], [$n, $message, $sha, $mergeMethod, $title], $response);
        }
        return true;
    }

    /**
     * prCheck determines whether there are any open PRs that already exist
     * that satisfy any of the provided $vids.
     *
     * @param string $projectWithOrg org/project to check
     * @param VersionIdentifiers $vids
     * @return [int $status, PullRequests $prs] status of PRs, and a list of PR numbers

     *   - If $status is 0, then the caller should go ahead and create a new PR.
     *     The existing pull requests that would be superceded by the new PR are
     *     returned in the second parameter. These PRs could all be closed.
     *   - If $status is >0, then there is no need to create a new PR, as there
     *     are already existing PRs that are equivalent to the one that would
     *     be open. The equivalent PRs are returned in the second parameter.
     */
    public function prCheck($projectWithOrg, VersionIdentifiers $vids)
    {
        // Find all of the PRs that contain any vid
        $existingPRs = $this->existingPRs($projectWithOrg, $vids);

        // Check to see if there are PRs matching all of the vids/vvals.
        $titles = $existingPRs->titles();
        $status = $vids->allExist($titles);

        return [$status, $existingPRs];
    }

    public function prStatuses($projectWithOrg, $number)
    {
        list($org, $project) = explode('/', $projectWithOrg, 2);
        $pullRequestStatus = $this->gitHubAPI()->api('pull_request')->status($org, $project, $number);
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.
    }
}

        // Filter out the results based on 'target_url'
        $filteredResults = [];
        foreach (array_reverse($pullRequestStatus) as $id => $item) {
            $filteredResults[$item['target_url']] = $item;
        }
        $pullRequestStatus = [];
        foreach ($filteredResults as $target_url => $item) {
            $pullRequestStatus[$item['id']] = $item;
        }

        // Put the most recently updated statuses at the top of the list
        uasort(

            $pullRequestStatus,
            function ($lhs, $rhs) {
                return abs(strtotime($lhs['updated_at']) - strtotime($rhs['updated_at']));
            }
        );

        return $pullRequestStatus;
    }

    public function addTokenAuthentication($url)
    {
        $token = $this->gitHubToken();
        if (!$token) {
            return $url;
        }
        if (!preg_match('#github\.com[/:]#', $url)) {
            return $url;
        }
        $projectAndOrg = $this->projectAndOrgFromUrl($url);
        return "https://{$token}:[email protected]/{$projectAndOrg}.git";
    }

    protected function projectAndOrgFromUrl($remote)

    {
        $remote = preg_replace('#^git@[^:]*:#', '', $remote);
        $remote = preg_replace('#^[^:]*://[^/]*/#', '', $remote);
        $remote = preg_replace('#\.git$#', '', $remote);

        return $remote;
    }

    protected function existingPRs($projectWithOrg, VersionIdentifiers $vids)
    {
        return $this->matchingPRs($projectWithOrg, $vids->getPreamble(), $vids->pattern());
    }

    public function matchingPRs($projectWithOrg, $preamble, $pattern = '')
    {
        $q = "repo:$projectWithOrg in:title is:pr state:open $preamble";
        $result = new PullRequests();
        $gitHubAPI = $this->gitHubAPI();
        $searchResults = $gitHubAPI->api('search')->issues($q);
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.
    }
}
        $result->addSearchResults($searchResults, $pattern);

        return $result;
    }

    public function allPRs($projectWithOrg)
    {
        $q = "repo:$projectWithOrg in:title is:pr state:open";
        $result = new PullRequests();
        $searchResults = $this->gitHubAPI()->api('search')->issues($q);
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.
    }
}
        $result->addSearchResults($searchResults);

        return $result;
    }

    /**
     * Pass an event of note to the event logger
     * @param string $event_name
     * @param array $args
     * @param array $params
     * @param array $response
     */
    protected function logEvent($event_name, $args, $params, $response)
    {
        if ($this->eventLogger) {
            $this->eventLogger->log($event_name, $args, $params, $response);
        }
    }

    /**
     * Authenticate and then return the gitHub API object.
     */
    public function gitHubAPI()
    {
        if (!$this->gitHubAPI) {
            $token = $this->gitHubToken();

            $this->gitHubAPI = new \Github\Client();
            $this->gitHubAPI->authenticate($token, null, \Github\Client::AUTH_HTTP_TOKEN);
        }
        return $this->gitHubAPI;
    }

    /**
     * Return a result pager object using our cached GitHub API client.
     */
    public function resultPager()
    {
        return new \Github\ResultPager($this->gitHubAPI());
    }

    /**
     * Look up the GitHub token set either via environment variable or in the
     * auth-token cache directory.
     */
    public function gitHubToken()
    {
        if (!$this->token) {
            $this->token = $this->getGitHubToken();
        }
        return $this->token;
    }

    protected function getGitHubToken()
    {
        $as = $this->as;
        $token = null;
        if ($as == 'default') {
            $as = $this->getConfig()->get("github.default-user");
        }

        // First preference: There is a 'path' component in preferences
        // pointing to a file containing the token.
        $github_token_cache = $this->getConfig()->get("github.personal-auth-token.$as.path");
        if (file_exists($github_token_cache)) {
            $token = trim(file_get_contents($github_token_cache));
        }

        // Second preference: There is an environment variable that begins
        // with an uppercased version of the 'as' string followed by '_TOKEN'
        if (!$token) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            $env_name = strtoupper(str_replace('-', '_', $as)) . '_TOKEN';
            $token = getenv($env_name);
        }

        // If we read in a token from one of the preferred locations, then
        // set the GITHUB_TOKEN environment variable and return it.
        if ($token) {
            putenv("GITHUB_TOKEN=$token");
            return $token;
        }

        // Fallback: authenticate to whatever 'GITHUB_TOKEN' is already set to.
        return getenv('GITHUB_TOKEN');
    }

    protected function getConfig()
    {
        return $this->config;
    }
}


HubphAPI A
last analyzed 2020-06-13 02:38 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Importance

23 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

g1a / hubph

HubphAPI A last analyzed 2020-06-13 02:38 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Importance

23 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like

HubphAPI A
last analyzed 2020-06-13 02:38 UTC