ProjectRepository::getProject() - Code Metrics - Inspection of "Better caching for projects' metadata" - x-tools/xtools - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 80bd76...26106c )

by Sam

created 2017-06-19 05:04 UTC

ProjectRepository::getProject() A

↳ Parent: ProjectRepository

Complexity

Conditions	2
Paths	2

Size

Total Lines	14
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	14
rs	9.4285
c	0
b	0
f	0
cc	2
eloc	10
nc	2
nop	2

<?php
/**
 * This file contains only the ProjectRepository class.
 */

namespace Xtools;

use Mediawiki\Api\MediawikiApi;
use Mediawiki\Api\SimpleRequest;
use Psr\Container\ContainerInterface;

/**
 * This class provides data to the Project class.
 */
class ProjectRepository extends Repository
{

    /** @var array Project metadata. */
    protected $metadata;

    /** @var string[] Metadata if XTools is in single-wiki mode. */
    protected $singleMetadata;

    /** @var string The cache key for the 'all project' metadata.
     */
    protected $cacheKeyAllProjects = 'allprojects';

    /**
     * Convenience method to get a new Project object based on a given identification string.
     * @param string $projectIdent The domain name, database name, or URL of a project.
     * @param ContainerInterface $container Symfony's container.
     * @return Project
     */
    public static function getProject($projectIdent, ContainerInterface $container)
    {
        $project = new Project($projectIdent);
        $projectRepo = new ProjectRepository();
        $projectRepo->setContainer($container);

        if ($container->getParameter('app.single_wiki')) {
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.
    }
}
            $projectRepo->setSingleMetadata([
                'url' => $container->getParameter('wiki_url'),
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.
    }
}
                'dbname' => $container->getParameter('database_replica_name'),
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.
    }
}
            ]);
        }
        $project->setRepository($projectRepo);
        return $project;
    }

    /**
     * Get the XTools default project.
     * @param ContainerInterface $container
     * @return Project
     */
    public static function getDefaultProject(ContainerInterface $container)
    {
        $defaultProjectName = $container->getParameter('default_project');
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 self::getProject($defaultProjectName, $container);
    }

    /**
     * Get the global 'meta' project, which is either Meta (if this is Labs) or the default project.
     * @return Project
     */
    public function getGlobalProject()
    {
        if ($this->isLabs()) {
            return self::getProject('metawiki', $this->container);
        } else {
            return self::getDefaultProject($this->container);
        }
    }

    /**
     * For single-wiki installations, you must manually set the wiki URL and database name
     * (because there's no meta.wiki database to query).
     * @param $metadata
     * @throws \Exception
     */
    public function setSingleMetadata($metadata)
    {
        if (!array_key_exists('url', $metadata) || !array_key_exists('dbname', $metadata)) {
            $error = "Single-wiki metadata should contain 'url' and 'dbname' keys.";
            throw new \Exception($error);
        }
        $this->singleMetadata = array_intersect_key($metadata, ['url' => '', 'dbname' => '']);
    }

    /**
     * Get metadata about all projects.
     * @return string[] Each item has 'dbname' and 'url' keys.
     */
    public function getAll()
    {
        $this->log->debug(__METHOD__." Getting all projects' metadata");
        // Single wiki mode?
        if ($this->singleMetadata) {

            return [$this->getOne('')];
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
        }

        // Maybe we've already fetched it.
        if ($this->cache->hasItem($this->cacheKeyAllProjects)) {
            return $this->cache->getItem($this->cacheKeyAllProjects)->get();
        }

        // Otherwise, fetch all from the database.
        $wikiQuery = $this->getMetaConnection()->createQueryBuilder();
        $wikiQuery->select(['dbname', 'url'])->from('wiki');
        $projects = $wikiQuery->execute()->fetchAll();
        $projectsMetadata = [];
        foreach ($projects as $project) {
            $projectsMetadata[$project['dbname']] = $project;
        }

        // Cache and return.
        $cacheItem = $this->cache->getItem($this->cacheKeyAllProjects);
        $cacheItem->set($projectsMetadata);
        $cacheItem->expiresAfter(new \DateInterval('P1D'));
        $this->cache->save($cacheItem);
        return $projectsMetadata;
    }

    /**
     * Get metadata about one project.
     * @param string $project A project URL, domain name, or database name.
     * @return string[] With 'dbname' and 'url' keys.
     */
    public function getOne($project)
    {
        $this->log->debug(__METHOD__." Getting metadata about $project");
        // For single-wiki setups, every project is the same.
        if ($this->singleMetadata) {

            return $this->singleMetadata;
        }

        // For muli-wiki setups, first check the cache.
        // First the all-projects cache, then the individual one.
        if ($this->cache->hasItem($this->cacheKeyAllProjects)) {
            foreach ($this->cache->getItem($this->cacheKeyAllProjects)->get() as $projMetadata) {
                if ($projMetadata['dbname'] == "$project"
                    || $projMetadata['url'] == "$project"
                    || $projMetadata['url'] == "https://$project") {
                    $this->log->debug(__METHOD__ . " Using cached data for $project");
                    return $projMetadata;
                }
            }
        }
        $cacheKey = "project.$project";
        if ($this->cache->hasItem($cacheKey)) {
            return $this->cache->getItem($cacheKey)->get();
        }

        // Otherwise, fetch the project's metadata from the meta.wiki table.
        $wikiQuery = $this->getMetaConnection()->createQueryBuilder();
        $wikiQuery->select(['dbname', 'url'])
            ->from('wiki')
            ->where($wikiQuery->expr()->eq('dbname', ':project'))
            // The meta database will have the project's URL stored as https://en.wikipedia.org
            // so we need to query for it accordingly, trying different variations the user
            // might have inputted.
            ->orwhere($wikiQuery->expr()->like('url', ':projectUrl'))
            ->orwhere($wikiQuery->expr()
                ->like('url', ':projectUrl2'))
            ->setParameter('project', $project)
            ->setParameter('projectUrl', "https://$project")
            ->setParameter('projectUrl2', "https://$project.org");
        $wikiStatement = $wikiQuery->execute();

        // Fetch and cache the wiki data.
        $projectMetadata = $wikiStatement->fetch();
        $cacheItem = $this->cache->getItem($cacheKey);
        $cacheItem->set($projectMetadata)
            ->expiresAfter(new \DateInterval('PT1H'));
        $this->cache->save($cacheItem);

        return $projectMetadata;
    }

    /**
     * Get metadata about a project.
     *
     * @param string $projectUrl The project's URL.
     * @return array With 'general' and 'namespaces' keys: the former contains 'wikiName',
     * 'wikiId', 'url', 'lang', 'articlePath', 'scriptPath', 'script', 'timezone', and
     * 'timezoneOffset'; the latter contains all namespace names, keyed by their IDs.
     */
    public function getMetadata($projectUrl)
    {
        if ($this->metadata) {

            return $this->metadata;
        }

        $api = MediawikiApi::newFromPage($projectUrl);

        $params = ['meta' => 'siteinfo', 'siprop' => 'general|namespaces'];
        $query = new SimpleRequest('query', $params);

        $this->metadata = [
            'general' => [],
            'namespaces' => [],
        ];

        $res = $api->getRequest($query);

        if (isset($res['query']['general'])) {
            $info = $res['query']['general'];
            $this->metadata['general'] = [
                'wikiName' => $info['sitename'],
                'wikiId' => $info['wikiid'],
                'url' => $info['server'],
                'lang' => $info['lang'],
                'articlePath' => $info['articlepath'],
                'scriptPath' => $info['scriptpath'],
                'script' => $info['script'],
                'timezone' => $info['timezone'],
                'timeOffset' => $info['timeoffset'],
            ];

//            if ($this->container->getParameter('app.is_labs') &&

//                substr($result['general']['dbName'], -2) != '_p'
//            ) {
//                $result['general']['dbName'] .= '_p';
//            }
        }

        if (isset($res['query']['namespaces'])) {

            foreach ($res['query']['namespaces'] as $namespace) {
                if ($namespace['id'] < 0) {
                    continue;
                }

                if (isset($namespace['name'])) {
                    $name = $namespace['name'];
                } elseif (isset($namespace['*'])) {
                    $name = $namespace['*'];
                } else {
                    continue;
                }

                // FIXME: Figure out a way to i18n-ize this
                if ($name === '') {
                    $name = 'Article';
                }

                $this->metadata['namespaces'][$namespace['id']] = $name;
            }
        }

        return $this->metadata;
    }

    /**
     * Get a list of projects that have opted in to having all their users' restricted statistics
     * available to anyone.
     *
     * @return string[]
     */
    public function optedIn()
    {
        $optedIn = $this->container->getParameter('opted_in');
        return $optedIn;
    }

    /**
     * The path to api.php
     *
     * @return string
     */
    public function getApiPath()
    {
        return $this->container->getParameter('api_path');
    }

    /**
     * Get a page from the given Project.
     * @param Project $project The project.
     * @param string $pageName The name of the page.
     * @return Page
     */
    public function getPage(Project $project, $pageName)
    {
        $pageRepo = new PagesRepository();
        $pageRepo->setContainer($this->container);
        $page = new Page($project, $pageName);
        $page->setRepository($pageRepo);
        return $page;
    }

    /**
     * Check to see if a page exists on this project and has some content.
     * @param Project $project The project.
     * @param int $namespaceId The page namespace ID.
     * @param string $pageTitle The page title, without namespace.
     * @return bool
     */
    public function pageHasContent(Project $project, $namespaceId, $pageTitle)
    {
        $conn = $this->getProjectsConnection();
        $pageTable = $this->getTableName($project->getDatabaseName(), 'page');
        $query = "SELECT page_id "
             . " FROM $pageTable "
             . " WHERE page_namespace = :ns AND page_title = :title AND page_len > 0 "
             . " LIMIT 1";
        $params = [
            'ns' => $namespaceId,
            'title' => $pageTitle,
        ];
        $pages = $conn->executeQuery($query, $params)->fetchAll();
        return count($pages) > 0;
    }
}


Push — master ( 80bd76...26106c )

ProjectRepository::getProject() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

x-tools / xtools

Push — master ( 80bd76...26106c )

ProjectRepository::getProject() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like