Cerbere\Model\Hacked\HackedFileGroup

Complexity

Total Complexity

34

Size/Duplication

Total Lines	231
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes	3
Bugs	0	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	2
A	getFiles()	0	4	1
A	getFileHash()	0	8	2
A	fromDirectory()	0	7	1
A	fromList()	0	7	1
A	scanBasePath()	0	14	2
A	computeHashes()	0	5	2
A	isReadable()	0	3	1
A	fileExists()	0	3	1
A	isNotBinary()	0	4	2
A	getFileLocation()	0	3	1
B	isBinary()	0	18	7
C	scanDirectory()	0	32	11

<?php

namespace Cerbere\Model\Hacked;

/**
 * Represents a group of files on the local filesystem.
 */
class HackedFileGroup {
  /**
   * @var string
   */
  protected $base_path = '';

  /**
   * @var array
   */
  protected $files = array();

  /**
   * @var array
   */
  protected $files_hashes = array();

  /**
   * @var array
   */
  protected $file_mtimes = array();

  /**
   * @var HackedFileHasher
   */
  protected $hasher;

  /**
   * Constructor.
   *
   * @param string $base_path
   * @param HackedFileHasher $hasher
   */
  public function __construct($base_path, HackedFileHasher $hasher = null) {
    if (null === $hasher) {
      $hasher = new HackedFileIgnoreEndingsHasher();
    }

    $this->base_path = $base_path;
    $this->hasher = $hasher;
  }

  /**
   * @return array
   */
  public function getFiles()
  {
    return $this->files;
  }

  /**
   * @param string $file
   *
   * @return string|bool
   */
  public function getFileHash($file)
  {
    if (isset($this->files_hashes[$file])) {
      return $this->files_hashes[$file];
    }

    return false;
  }

  /**
   * Return a new hackedFileGroup listing all files inside the given $path.
   *
   * @param string $path
   *
   * @return HackedFileGroup
   */
  public static function fromDirectory($path) {
    $filegroup = new self($path);
    // Find all the files in the path, and add them to the file group.
    $filegroup->scanBasePath();

    return $filegroup;
  }

  /**
   * Return a new hackedFileGroup listing all files specified.
   *
   * @param string $path
   * @param array  $files
   *
   * @return HackedFileGroup
   */
  public static function fromList($path, array $files) {
    $filegroup = new self($path);
    // Find all the files in the path, and add them to the file group.
    $filegroup->files = $files;

    return $filegroup;
  }

  /**
   * Locate all sensible files at the base path of the file group.
   */
  public function scanBasePath() {
    $files = self::scanDirectory($this->base_path, '/.*/', array(
      '.',
      '..',
      'CVS',
      '.svn',
      '.git'
    ));

    foreach ($files as $file) {
      $filename = str_replace($this->base_path . DIRECTORY_SEPARATOR, '', $file->filename);
      $this->files[] = $filename;
    }
  }

  /**
   * Hash all files listed in the file group.
   */
  public function computeHashes() {
    foreach ($this->files as $filename) {
      $this->files_hashes[$filename] = $this->hasher->hash($this->base_path . DIRECTORY_SEPARATOR . $filename);
    }
  }

  /**
   * Determine if the given file is readable.
   * @param string $file
   * @return bool
   */
  public function isReadable($file) {
    return is_readable($this->base_path . DIRECTORY_SEPARATOR . $file);
  }

  /**
   * Determine if a file exists.
   * @param string $file
   * @return bool
   */
  public function fileExists($file) {
    return file_exists($this->base_path . DIRECTORY_SEPARATOR . $file);
  }

  /**
   * Determine if the given file is binary.
   * @param string $file
   * @return bool
   */
  public function isNotBinary($file) {
    return is_readable($this->base_path . DIRECTORY_SEPARATOR . $file)
      && !self::isBinary($this->base_path . DIRECTORY_SEPARATOR . $file);
  }

  /**
   * @param string $file
   * @return string
   */
  public function getFileLocation($file) {
    return $this->base_path . DIRECTORY_SEPARATOR . $file;
  }

  /**
   * Determine if a file is a binary file.
   *
   * Taken from: http://www.ultrashock.com/forums/server-side/checking-if-a-file-is-binary-98391.html
   * and then tweaked in: http://drupal.org/node/760362.
   *
   * @param string $file
   *
   * @return bool
   */
  public static function isBinary($file) {
    if (file_exists($file)) {
      if (!is_file($file)) return 0;
      if (!is_readable($file)) return 1;

      $fh  = fopen($file, "r");
      $blk = fread($fh, 512);
      fclose($fh);
      clearstatcache();

      return (
        0 or substr_count($blk, "^\r\n") / 512 > 0.3

Using logical operators such as or instead of || is generally not recommended.

        or substr_count($blk, "^ -~") / 512 > 0.3

Using logical operators such as or instead of || is generally not recommended.

        or substr_count($blk, "\x00") > 0

Using logical operators such as or instead of || is generally not recommended.

      );
    }
    return 0;
  }

  /**
   * @param string    $dir
   * @param int       $mask
   * @param array     $nomask
   * @param callable  $callback
   * @param bool|true $recurse
   * @param string    $key
   * @param int       $min_depth
   * @param int       $depth
   *
   * @return array
   */
  public static function scanDirectory($dir, $mask, $nomask = array('.', '..', 'CVS'), $callback = null, $recurse = TRUE, $key = 'filename', $min_depth = 0, $depth = 0) {
    $key = (in_array($key, array('filename', 'basename', 'name')) ? $key : 'filename');
    $files = array();

    if (is_dir($dir) && $handle = opendir($dir)) {
      while (FALSE !== ($file = readdir($handle))) {
        if (!in_array($file, $nomask)) {
          if (is_dir($dir . DIRECTORY_SEPARATOR . $file) && $recurse) {
            // Give priority to files in this folder by merging them in after any subdirectory files.
            $files = array_merge(self::scanDirectory($dir . DIRECTORY_SEPARATOR . $file, $mask, $nomask, $callback, $recurse, $key, $min_depth, $depth + 1), $files);
          }
          elseif ($depth >= $min_depth && preg_match($mask, $file)) {
            // Always use this match over anything already set in $files with the same $$key.
            $filename = $dir . DIRECTORY_SEPARATOR . $file;
            $basename = basename($file);
            $name = substr($basename, 0, strrpos($basename, '.'));
            $files[$$key] = new \stdClass();
            $files[$$key]->filename = $filename;
            $files[$$key]->basename = $basename;
            $files[$$key]->name = $name;
            if (is_callable($callback)) {
              $callback($filename);
            }
          }
        }
      }

      closedir($handle);
    }

    return $files;
  }
}