vijinho / kohana2-legacy

system/helpers/file.php

<?php defined('SYSPATH') or die('No direct access allowed.');
/**
 * File helper class.
 *
 * $Id: file.php 3769 2008-12-15 00:48:56Z zombor $
 *
 * @package    Core
 * @author     Kohana Team
 * @copyright  (c) 2007-2008 Kohana Team
 * @license    http://kohanaphp.com/license.html
 */
class file_Core
{

    /**
     * Attempt to get the mime type from a file. This method is horribly
     * unreliable, due to PHP being horribly unreliable when it comes to
     * determining the mime-type of a file.
     *
     * @param   string   filename
     * @return  string   mime-type, if found
     * @return  boolean  FALSE, if not found
     */
    public static function mime($filename)
    {
        // Make sure the file is readable
        if (! (is_file($filename) and is_readable($filename))) {
            return false;

The return type of return false; (false) is incompatible with the return type documented by file_Core::mime of type string.

        }

        // Get the extension from the filename
        $extension = strtolower(substr(strrchr($filename, '.'), 1));

        if (preg_match('/^(?:jpe?g|png|[gt]if|bmp|swf)$/', $extension)) {
            // Disable error reporting
            $ER = error_reporting(0);

Avoid variables with short names like $ER. Configured minimum length is 3.

            // Use getimagesize() to find the mime type on images
            $mime = getimagesize($filename);

            // Turn error reporting back on
            error_reporting($ER);

            // Return the mime type
            if (isset($mime['mime'])) {
                return $mime['mime'];
            }
        }

        if (function_exists('finfo_open')) {
            // Use the fileinfo extension
            $finfo = finfo_open(FILEINFO_MIME);
            $mime  = finfo_file($finfo, $filename);
            finfo_close($finfo);

            // Return the mime type
            return $mime;
        }

        if (ini_get('mime_magic.magicfile') and function_exists('mime_content_type')) {
            // Return the mime type using mime_content_type
            return mime_content_type($filename);
        }

        if (! KOHANA_IS_WIN) {
            // Attempt to locate use the file command, checking the return value
            if ($command = trim(exec('which file', $output, $return)) and $return === 0) {
                return trim(exec($command.' -bi '.escapeshellarg($filename)));
            }
        }

        if (! empty($extension) and is_array($mime = Kohana::config('mimes.'.$extension))) {
            // Return the mime-type guess, based on the extension
            return $mime[0];
        }

        // Unable to find the mime-type
        return false;

The return type of return false; (false) is incompatible with the return type documented by file_Core::mime of type string.

    }

    /**
     * Split a file into pieces matching a specific size.
     *
     * @param   string   file to be split
     * @param   string   directory to output to, defaults to the same directory as the file
     * @param   integer  size, in MB, for each chunk to be
     * @return  integer  The number of pieces that were created.
     */
    public static function split($filename, $output_dir = false, $piece_size = 10)
    {
        // Find output dir
        $output_dir = ($output_dir == false) ? pathinfo(str_replace('\\', '/', realpath($filename)), PATHINFO_DIRNAME) : str_replace('\\', '/', realpath($output_dir));

It seems like you are loosely comparing two booleans. Considering using the strict comparison === instead.

        $output_dir = rtrim($output_dir, '/').'/';

$output_dir is not used, you could remove the assignment.

        // Open files for writing
        $input_file = fopen($filename, 'rb');

        // Change the piece size to bytes
        $piece_size = 1024 * 1024 * (int) $piece_size; // Size in bytes

        // Set up reading variables
        $read  = 0; // Number of bytes read
        $piece = 1; // Current piece
        $chunk = 1024 * 8; // Chunk size to read

        // Split the file
        while (! feof($input_file)) {
            // Open a new piece
            $piece_name = $filename.'.'.str_pad($piece, 3, '0', STR_PAD_LEFT);
            $piece_open = @fopen($piece_name, 'wb+') or die('Could not write piece '.$piece_name);

The method split() contains an exit expression.

            // Fill the current piece
            while ($read < $piece_size and $data = fread($input_file, $chunk)) {
                fwrite($piece_open, $data) or die('Could not write to open piece '.$piece_name);

The method split() contains an exit expression.

                $read += $chunk;
            }

            // Close the current piece
            fclose($piece_open);

            // Prepare to open a new piece
            $read = 0;
            $piece++;

            // Make sure that piece is valid
            ($piece < 999) or die('Maximum of 999 pieces exceeded, try a larger piece size');

The method split() contains an exit expression.

        }

        // Close input file
        fclose($input_file);

        // Returns the number of pieces that were created
        return ($piece - 1);
    }

    /**
     * Join a split file into a whole file.
     *
     * @param   string   split filename, without .000 extension
     * @param   string   output filename, if different then an the filename
     * @return  integer  The number of pieces that were joined.
     */
    public static function join($filename, $output = false)
    {
        if ($output == false) {

It seems like you are loosely comparing two booleans. Considering using the strict comparison === instead.

            $output = $filename;
        }

        // Set up reading variables
        $piece = 1; // Current piece
        $chunk = 1024 * 8; // Chunk size to read

        // Open output file
        $output_file = @fopen($output, 'wb+') or die('Could not open output file '.$output);

The method join() contains an exit expression.

        // Read each piece
        while ($piece_open = @fopen(($piece_name = $filename.'.'.str_pad($piece, 3, '0', STR_PAD_LEFT)), 'rb')) {
            // Write the piece into the output file
            while (! feof($piece_open)) {
                fwrite($output_file, fread($piece_open, $chunk));
            }

            // Close the current piece
            fclose($piece_open);

            // Prepare for a new piece
            $piece++;

            // Make sure piece is valid
            ($piece < 999) or die('Maximum of 999 pieces exceeded');

The method join() contains an exit expression.

        }

        // Close the output file
        fclose($output_file);

        // Return the number of pieces joined
        return ($piece - 1);
    }
} // End file