Classes\Update\Content\AbstractContent

Complexity

Total Complexity

33

Size/Duplication

Total Lines	225
Duplicated Lines	13.33 %

Coupling/Cohesion

Components	2
Dependencies	2

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	init()	0	1	1
A	getInstance()	0	9	2
B	getContent()	0	21	5
A	getCurlContent()	0	18	2
A	getFileContent()	14	14	2
A	getStreamContent()	16	16	2
A	putContent()	0	14	4
A	putFileContent()	0	8	2
A	putFopen()	0	6	1
D	stream_notification_callback()	0	31	10
A	progressCallback()	0	10	1

<?php
/**
 * Created by PhpStorm.
 * User: pedro
 * Date: 24/11/16
 * Time: 17:19
 */

namespace Classes\Update\Content;

use Classes\Update\ProgressBar;
use Classes\Update\ProtocolFileContent;

abstract class AbstractContent
{

    private static $opts = array (
        'http' => array (
            'method' => 'GET' ,
            'header' => array (
                'User-Agent: PHP'
            )
        )
    );

    /**
     * @type \Classes\Update\ProtocolFileContent
     */
    protected $objProtocol;
    /**
     * @type Content
     */
    private static $objContent;

    /**
     * @type array
     */
    private $content = array ();

    protected function __construct ()
    {
        $this->objProtocol = ProtocolFileContent::getInstance ();
        $this->init ();
    }

    protected function init (){ }

    /**
     * @return \Classes\Update\Content
     */
    public static function getInstance ()
    {
        if ( empty( self::$objContent ) )
        {
            self::$objContent = new static();

It seems like new static() of type this<Classes\Update\Content\AbstractContent> is incompatible with the declared type object<Classes\Update\Content\Content> of property $objContent.

        }

        return self::$objContent;
    }

    /**
     * @param $url
     *
     * @return string
     */
    public function getContent ( $url , $progress = false )
    {
        if ( ! isset( $this->content[ $url ] ) )
        {
            $this->content[ $url ] = '';
            switch ( $this->objProtocol->getProtocol () )
            {
                case 'curl':
                    $this->content[ $url ] = $this->getCurlContent ( $url , $progress );
                    break;
                case 'file_content':
                    $this->content[ $url ] = $this->getFileContent ( $url , $progress );
                    break;
                case 'steam_content':
                    $this->content[ $url ] = $this->getStreamContent ( $url , $progress );
                    break;
            }
        }

        return $this->content[ $url ];
    }

    /**
     * @param $url
     *
     * @return string
     */
    protected function getCurlContent ( $url , $progress = false )
    {
        $conn = curl_init ( $url );
        curl_setopt ( $conn , CURLOPT_RETURNTRANSFER , true );
        curl_setopt ( $conn , CURLOPT_BINARYTRANSFER , true );
        curl_setopt ( $conn , CURLOPT_USERAGENT , self::$opts[ 'http' ][ 'method' ] );
        if ( $progress )
        {
            curl_setopt ( $conn , CURLOPT_NOPROGRESS , false );
            curl_setopt ( $conn , CURLOPT_PROGRESSFUNCTION , array (
                $this , 'progressCallback'
            ) );
        }
        $url_get_contents_data = ( curl_exec ( $conn ) );
        curl_close ( $conn );

        return $url_get_contents_data;
    }

    /**
     * @param $url
     *
     * @return string
     */
    protected function getFileContent ( $url , $progress = false )

This method seems to be duplicated in your project.

    {
        $context = stream_context_create ( self::$opts );
        if ( $progress )
        {
            stream_context_set_params ( $context , array (
                "notification" => array (
                    $this , 'stream_notification_callback'
                )
            ) );
        }

        return file_get_contents ( $url , false , $context );
    }

    /**
     * @param $url
     *
     * @return string
     */
    protected function getStreamContent ( $url , $progress = false )

This method seems to be duplicated in your project.

    {
        $context = stream_context_create ( self::$opts );
        if ( $progress )
        {
            stream_context_set_params ( $context , array (
                "notification" => array (
                    $this , 'stream_notification_callback'
                )
            ) );
        }

        $handle = fopen ( $url , "r" , null , $context );

        return stream_get_contents ( $handle );
    }

    public function putContent ( $url , $content )
    {
        switch ( $this->objProtocol->getProtocol () )
        {
            case 'curl':
                $this->putFopen ( $url , $content );
                break;
            case 'steam_content':
            case 'file_content':
                $this->putFileContent ( $url , $content );
                break;
        }

    }

    public function putFileContent ( $url , $content )
    {
        // check if all is OK
        if ( file_put_contents ( $url , $content ) )
        {
            ProgressBar::getInstance ()->finish ();
        }
    }

    public function putFopen ( $url , $content )
    {
        $fp = fopen ( $url , "a" );
        fwrite ( $fp , $content );
        fclose ( $fp );
    }

    /**
     * Stream downloading
     *
     * @param $notification_code
     * @param $severity
     * @param $message
     * @param $message_code
     * @param $bytes_transferred
     * @param $bytes_max
     */
    public function stream_notification_callback ( $notificationCode , $severity , $message , $messageCode , $bytesTransferred , $bytesMax )
    {
        $objProgress = ProgressBar::getInstance ();
        switch ( $notificationCode )
        {
            case STREAM_NOTIFY_RESOLVE:
            case STREAM_NOTIFY_AUTH_REQUIRED:
            case STREAM_NOTIFY_FAILURE:
            case STREAM_NOTIFY_AUTH_RESULT:
                var_dump ( $notificationCode , $severity , $message , $messageCode , $bytesTransferred , $bytesMax );

var_dump($notificationCode, $severity, $message, $messageCode, $bytesTransferred, $bytesMax); looks like debug code. Are you sure you do not want to remove it? This might expose sensitive data.

                /* Ignore */
                break;
            case STREAM_NOTIFY_CONNECT:
                echo "\033[1;32mConnected...\033[0m\n";
                break;
            case STREAM_NOTIFY_REDIRECTED:
                $objProgress->clear ();
                break;
            case STREAM_NOTIFY_FILE_SIZE_IS:
                $objProgress->clear ()->setMaxByte ( $bytesMax );
                break;
            case STREAM_NOTIFY_PROGRESS:
                $objProgress->setProgress ( $bytesTransferred )
                            ->render ();
                break;
            case STREAM_NOTIFY_COMPLETED:
                $objProgress->finish ();
                break;
        }

    }

    function progressCallback ( $download_size , $downloaded_size , $upload_size , $uploaded_size )

The parameter $upload_size is not used and could be removed.

The parameter $uploaded_size is not used and could be removed.

It is generally recommended to explicitly declare the visibility for methods.

    {
        ProgressBar::getInstance ()
                   ->clear ()
                   ->setMaxByte ( $download_size )
                   ->setProgress ( $downloaded_size )
                   ->render ()
                   ->finish ();

    }

}