Pdp\PublicSuffixListManager

Complexity

Total Complexity

52

Size/Duplication

Total Lines	444
Duplicated Lines	1.35 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

94.29%

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	2
A	refreshPublicSuffixList()	0	16	4
A	fetchListFromSource()	0	10	2
A	parseListToArray()	0	32	4
B	buildArray()	0	30	6
A	writePhpCache()	0	6	1
A	varExportToFile()	0	6	1
A	getList()	0	27	5
A	getListFromFile()	0	18	3
A	convertListToArray()	0	25	3
A	convertLineToArray()	0	11	2
A	validateDomainAddition()	0	8	2
A	isValidSection()	6	12	5
B	write()	0	30	8
A	getHttpAdapter()	0	12	3
A	setHttpAdapter()	0	4	1

<?php

declare(strict_types=1);

/**
 * PHP Domain Parser: Public Suffix List based URL parsing.
 *
 * @link      http://github.com/jeremykendall/php-domain-parser for the canonical source repository
 *
 * @copyright Copyright (c) 2014 Jeremy Kendall (http://about.me/jeremykendall)
 * @license   http://github.com/jeremykendall/php-domain-parser/blob/master/LICENSE MIT License
 */

namespace Pdp;

use Pdp\HttpAdapter\HttpAdapterInterface;

/**
 * Public Suffix List Manager.
 *
 * This class obtains, writes, caches, and returns text and PHP representations
 * of the Public Suffix List
 */
class PublicSuffixListManager
{
  const ALL_DOMAINS = 'ALL';

  const PDP_PSL_TEXT_FILE = 'public-suffix-list.txt';
  const PDP_PSL_PHP_FILE  = 'public-suffix-list.php';

  const ICANN_DOMAINS      = 'ICANN';
  const ICANN_PSL_PHP_FILE = 'icann-public-suffix-list.php';

  const PRIVATE_DOMAINS      = 'PRIVATE';
  const PRIVATE_PSL_PHP_FILE = 'private-public-suffix-list.php';

  /**
   * @var string Public Suffix List URL
   */
  protected $publicSuffixListUrl = 'https://publicsuffix.org/list/effective_tld_names.dat';

  /**
   * @var string Directory where text and php versions of list will be cached
   */
  protected $cacheDir;

  /**
   * @var PublicSuffixList Public Suffix List
   */
  protected static $domainList = [
      self::ALL_DOMAINS     => self::PDP_PSL_PHP_FILE,
      self::ICANN_DOMAINS   => self::ICANN_PSL_PHP_FILE,
      self::PRIVATE_DOMAINS => self::PRIVATE_PSL_PHP_FILE,
  ];

  /**
   * @var \Pdp\HttpAdapter\HttpAdapterInterface Http adapter
   */
  protected $httpAdapter;

  /**
   * Public constructor.
   *
   * @param string $cacheDir Optional cache directory
   */
  public function __construct($cacheDir = null)
  {
    if (null === $cacheDir) {
      $cacheDir = realpath(
          dirname(__DIR__, 2) . DIRECTORY_SEPARATOR . 'data'
      );
    }

    $this->cacheDir = $cacheDir;
  }

  /**
   * Downloads Public Suffix List and writes text cache and PHP cache. If these files
   * already exist, they will be overwritten.
   */
  public function refreshPublicSuffixList()
  {
    $this->fetchListFromSource();
    $cacheFile = $this->cacheDir . '/' . self::PDP_PSL_TEXT_FILE;
    $publicSuffixListArray = $this->convertListToArray($cacheFile);
    foreach ($publicSuffixListArray as $domain => $data) {
      // do not empty existing PHP cache file if source TXT is empty
      if (
          \is_array($data)
          &&
          !empty($data)
      ) {
        $this->varExportToFile(self::$domainList[$domain], $data);
      }
    }
  }

  /**
   * Obtain Public Suffix List from its online source and write to cache dir.
   *
   * @return int|bool Number of bytes that were written to the file OR false in case of error
   */
  public function fetchListFromSource()
  {
    $publicSuffixList = $this->getHttpAdapter()->getContent($this->publicSuffixListUrl);

    if ($publicSuffixList === false) {
      return 0;
    }

    return $this->write(self::PDP_PSL_TEXT_FILE, $publicSuffixList);
  }

  /**
   * Parses text representation of list to associative, multidimensional array.
   *
   * This method is based heavily on the code found in generateEffectiveTLDs.php
   *
   * @link https://github.com/usrflo/registered-domain-libs/blob/master/generateEffectiveTLDs.php
   * A copy of the Apache License, Version 2.0, is provided with this
   * distribution
   *
   * @param string $textFile Public Suffix List text filename
   *
   * @return array Associative, multidimensional array representation of the
   *               public suffx list
   *
   * @throws \Exception Throws \Exception if unable to read file
   */
  public function parseListToArray($textFile): array
  {
    /** @noinspection PhpUsageOfSilenceOperatorInspection */
    $fp = @fopen($textFile, 'rb');
    if (!$fp || !flock($fp, LOCK_SH)) {
      throw new \Exception("Cannot read '$textFile'");
    }

    $data = file(
        $textFile,
        FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES
    );

    flock($fp, LOCK_UN);
    fclose($fp);

    $data = array_filter(
        $data,
        function ($line) {
          return false === strpos($line, '//');
        }
    );

    $publicSuffixListArray = [];

    foreach ($data as $line) {
      $ruleParts = explode('.', $line);
      $this->buildArray($publicSuffixListArray, $ruleParts);
    }

    return $publicSuffixListArray;
  }

  /**
   * Recursive method to build the array representation of the Public Suffix List.
   *
   * This method is based heavily on the code found in generateEffectiveTLDs.php
   *
   * @link https://github.com/usrflo/registered-domain-libs/blob/master/generateEffectiveTLDs.php
   * A copy of the Apache License, Version 2.0, is provided with this
   * distribution
   *
   * @param array $publicSuffixListArray Initially an empty array, this eventually
   *                                     becomes the array representation of the Public Suffix List
   * @param array $ruleParts             One line (rule) from the Public Suffix List
   *                                     exploded on '.', or the remaining portion of that array during recursion
   */
  public function buildArray(array &$publicSuffixListArray, array $ruleParts)
  {
    $isDomain = true;

    $part = array_pop($ruleParts);

    // Adheres to canonicalization rule from the "Formal Algorithm" section
    // of https://publicsuffix.org/list/
    // "The domain and all rules must be canonicalized in the normal way
    // for hostnames - lower-case, Punycode (RFC 3492)."
    $punycode = new PunycodeWrapper();
    $part = $punycode->encode($part);

    if (strpos($part, '!') === 0) {
      $part = substr($part, 1);
      $isDomain = false;
    }

    if (!isset($publicSuffixListArray[$part])) {
      if ($isDomain) {
        $publicSuffixListArray[$part] = [];
      } else {
        $publicSuffixListArray[$part] = ['!' => ''];
      }
    }

    if ($isDomain && \count($ruleParts) > 0) {
      $this->buildArray($publicSuffixListArray[$part], $ruleParts);
    }
  }

  /**
   * Writes php array representation of the Public Suffix List to disk.
   *
   * @param array $publicSuffixList Array representation of the Public Suffix List
   *
   * @return int Number of bytes that were written to the file
   */
  public function writePhpCache(array $publicSuffixList): int
  {
    $data = '<?php' . PHP_EOL . 'static $data = ' . var_export($publicSuffixList, true) . '; $result =& $data; unset($data); return $result;';

    return $this->write(self::PDP_PSL_PHP_FILE, $data);
  }

  /**
   * Writes php array representation to disk.
   *
   * @param string $basename file path
   * @param array  $input    input data
   *
   * @return int Number of bytes that were written to the file
   */
  protected function varExportToFile($basename, array $input): int
  {
    $data = '<?php' . PHP_EOL . 'static $data = ' . var_export($input, true) . '; $result =& $data; unset($data); return $result;';

    return $this->write($basename, $data);
  }

  /**
   * Gets Public Suffix List.
   *
   * @param string $list the Public Suffix List type
   * @param bool   $withStaticCache
   *
   * @return PublicSuffixList Instance of Public Suffix List
   *
   * @throws \Exception Throws \Exception if unable to read file
   */
  public function getList($list = self::ALL_DOMAINS, bool $withStaticCache = true): PublicSuffixList
  {
    // init
    static $LIST_STATIC = [];

    $cacheBasename = self::$domainList[$list] ?? self::PDP_PSL_PHP_FILE;
    $cacheFile = $this->cacheDir . '/' . $cacheBasename;
    $cacheKey = md5($cacheFile);

    if (
        $withStaticCache === true
        &&
        isset($LIST_STATIC[$cacheKey])
    ) {
      return $LIST_STATIC[$cacheKey];
    }

    if (!file_exists($cacheFile)) {
      $this->refreshPublicSuffixList();
    }

    if (!isset($LIST_STATIC[$cacheKey])) {
      $LIST_STATIC[$cacheKey] = new PublicSuffixList($cacheFile);
    }

    return $LIST_STATIC[$cacheKey];
  }

  /**
   * Retrieves public suffix list from file after obtaining a shared lock.
   *
   * @param string $phpFile
   *
   * @return PublicSuffixList Instance of Public Suffix List
   *
   * @throws \Exception Throws \Exception if unable to read file
   */
  public function getListFromFile($phpFile): PublicSuffixList
  {
    /** @noinspection PhpUsageOfSilenceOperatorInspection */
    $fp = @fopen($phpFile, 'rb');
    if (!$fp || !flock($fp, LOCK_SH)) {
      throw new \Exception("Cannot read '$phpFile'");
    }

    /** @noinspection PhpIncludeInspection */
    $list = new PublicSuffixList(
        require $phpFile
    );

    flock($fp, LOCK_UN);
    fclose($fp);

    return $list;
  }

  /**
   * Parses text representation of list to associative, multidimensional array.
   *
   * @param string $textFile Public Suffix List text filename
   *
   * @return array Associative, multidimensional array representation of the
   *               public suffx list
   */
  protected function convertListToArray($textFile): array
  {
    $addDomain = [
        self::ICANN_DOMAINS   => false,
        self::PRIVATE_DOMAINS => false,
    ];

    $publicSuffixListArray = [
        self::ALL_DOMAINS     => [],
        self::ICANN_DOMAINS   => [],
        self::PRIVATE_DOMAINS => [],
    ];

    $data = new \SplFileObject($textFile);
    $data->setFlags(\SplFileObject::DROP_NEW_LINE | \SplFileObject::READ_AHEAD | \SplFileObject::SKIP_EMPTY);
    foreach ($data as $line) {
      $addDomain = $this->validateDomainAddition($line, $addDomain);

It seems like $line defined by $line on line 326 can also be of type array; however, Pdp\PublicSuffixListManager::validateDomainAddition() does only seem to accept string, maybe add an additional type check?

      if (false !== strpos($line, '//')) {
        continue;
      }
      $publicSuffixListArray = $this->convertLineToArray($line, $publicSuffixListArray, $addDomain);

It seems like $line defined by $line on line 326 can also be of type array; however, Pdp\PublicSuffixListManager::convertLineToArray() does only seem to accept string, maybe add an additional type check?

    }

    return $publicSuffixListArray;
  }

  /**
   * Convert a line from the Public Suffix list.
   *
   * @param string $textLine              Public Suffix List text line
   * @param array  $publicSuffixListArray Associative, multidimensional array representation of the
   *                                      public suffx list
   * @param array  $addDomain             Tell which section should be converted
   *
   * @return array Associative, multidimensional array representation of the
   *               public suffx list
   */
  protected function convertLineToArray($textLine, array $publicSuffixListArray, array $addDomain): array
  {
    $ruleParts = explode('.', $textLine);
    $this->buildArray($publicSuffixListArray[self::ALL_DOMAINS], $ruleParts);
    $domainNames = array_keys(array_filter($addDomain));
    foreach ($domainNames as $domainName) {
      $this->buildArray($publicSuffixListArray[$domainName], $ruleParts);
    }

    return $publicSuffixListArray;
  }

  /**
   * Update the addition status for a given line against the domain list (ICANN and PRIVATE).
   *
   * @param string $line      the current file line
   * @param array  $addDomain the domain addition status
   *
   * @return array
   */
  protected function validateDomainAddition($line, array $addDomain): array
  {
    foreach ($addDomain as $section => $status) {
      $addDomain[$section] = $this->isValidSection($status, $line, $section);
    }

    return $addDomain;
  }

  /**
   * Tell whether the line can be converted for a given domain.
   *
   * @param bool   $previousStatus the previous status
   * @param string $line           the current file line
   * @param string $section        the section to be considered
   *
   * @return bool
   */
  protected function isValidSection($previousStatus, $line, $section): bool
  {
    if (!$previousStatus && 0 === strpos($line, '// ===BEGIN ' . $section . ' DOMAINS===')) {

This code seems to be duplicated across your project.

      return true;
    }

    if ($previousStatus && 0 === strpos($line, '// ===END ' . $section . ' DOMAINS===')) {

This code seems to be duplicated across your project.

      return false;
    }

    return $previousStatus;
  }

  /**
   * Writes to file after obtaining an exclusive lock.
   *
   * @param string $filename Filename in cache dir where data will be written
   * @param mixed  $data     Data to write
   *
   * @return int Number of bytes that were written to the file
   *
   * @throws \Exception <p>Throws \Exception if unable to write file.</p>
   */
  protected function write($filename, $data): int
  {
    $data = trim($data);
    $filePath = $this->cacheDir . '/' . $filename;

    if (empty($data)) {
      throw new \Exception("No data to write into '{$filePath}'");
    }

    // open with 'c' and truncate file only after obtaining a lock
    /** @noinspection PhpUsageOfSilenceOperatorInspection */
    $fp = @fopen($filePath, 'cb');
    $result = $fp
              && flock($fp, LOCK_EX)
              && ftruncate($fp, 0)
              && fwrite($fp, $data) !== false
              && fflush($fp);

    if (!$result) {
      $fp && fclose($fp);
      throw new \Exception("Cannot write to '$filePath'");
    }

    flock($fp, LOCK_UN);
    fclose($fp);

    $result = (int)$result;

    return $result;
  }

  /**
   * Returns http adapter. Returns default http adapter if one is not set.
   *
   * @return \Pdp\HttpAdapter\HttpAdapterInterface Http adapter
   */
  public function getHttpAdapter(): HttpAdapterInterface
  {
    if (!$this->httpAdapter instanceof HttpAdapterInterface) {
      if (\extension_loaded('curl')) {
        $this->httpAdapter = new HttpAdapter\CurlHttpAdapter();
      } else {
        $this->httpAdapter = new HttpAdapter\PhpHttpAdapter();
      }
    }

    return $this->httpAdapter;
  }

  /**
   * Sets http adapter.
   *
   * @param \Pdp\HttpAdapter\HttpAdapterInterface $httpAdapter
   */
  public function setHttpAdapter(HttpAdapter\HttpAdapterInterface $httpAdapter)
  {
    $this->httpAdapter = $httpAdapter;
  }
}