Application - Code Metrics - Inspection of "Merge pull request #20 from getmanenko/master" - samsonos/cms_app_gallery - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 173a0c...14edb3 )

by Vitaly

created 2016-03-10 14:31 UTC

Application B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	473
Duplicated Lines	2.11 %

Coupling/Cohesion

Components	1
Dependencies	9

Importance

Changes	9
Bugs	2	Features	3

Metric	Value
wmc	49
c	9
b	2
f	3
lcom	1
cbo	9
dl	10
loc	473
rs	8.5454

16 Methods

Rating	Name	Duplication	Size	Complexity
A	init()	0	14	1
A	fieldSelectCreate()	0	4	1
A	__async_update()	0	4	1
A	__async_getCount()	0	12	1
B	__async_updateAlt()	0	29	2
B	__async_upload()	0	50	5
A	verifyExtensionFile()	0	17	2
B	__async_priority()	0	26	4
A	__async_show_edit()	0	22	3
B	__async_edit()	10	43	6
A	tabBuilder()	0	17	3
C	__async_delete()	0	39	7
A	humanFileSize()	0	8	2
A	imageExists()	0	14	2
B	formImagePath()	0	22	4
B	getHTML()	0	41	5

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Application often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Application, and based on these observations, apply Extract Interface, too.

<?php
namespace samsoncms\app\gallery;

use samson\activerecord\Field;
use samsoncms\api\CMS;
use samsoncms\api\Material;
use samsoncms\api\MaterialField;
use samsonphp\event\Event;
use samsoncms\app\gallery\tab\Gallery;

/**
 * SamsonCMS application for interacting with material gallery
 * @author [email protected]
 */
class Application extends \samsoncms\Application
{
    /** Application name */
    public $name = 'Галлерея';

    /** Hide application access from main menu */
    public $hide = true;

    /** @var string Entity class name */
    protected $entity = '\samson\activerecord\gallery';

    /** Identifier */
    protected $id = 'gallery';

    /** @var \samsonphp\fs\FileService File service pointer */
    protected $fs;

    /**
     * Initialize module
     * @param array $params Collection of parameters
     * @return bool True if success
     */
    public function init(array $params = array())
    {
        // TODO: Should be change to DI in future
        // Set pointer to file service
        $this->fs = & $this->system->module('fs');

        // Subscribe to material form created event for custom tab rendering
        Event::subscribe('samsoncms.material.form.created', array($this, 'tabBuilder'));

        // Subscribe to event - add gallery field additional field type
        Event::subscribe('cms_field.select_create', array($this, 'fieldSelectCreate'));

        return parent::init($params);
    }

    /**
     * Render all gallery additional fields as material form tabs
     * @param \samsoncms\app\material\form\Form $form Material form insctance
     */
    public function tabBuilder(\samsoncms\app\material\form\Form & $form)
    {
        // If we have related structures
        if (count($form->navigationIDs)) {
            // Get all gallery additional field for material form structures
            $galleryFields = $this->query->entity(\samsoncms\api\Field::class)
                ->where('Type', 9)
                ->join('structurefield')
                ->where('structurefield_StructureID', $form->navigationIDs)
                ->exec();

            // Create tab for each additional gallery field
            foreach ($galleryFields as $field) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
                $form->tabs[] = new Gallery($this, $this->query, $form->entity, $field);
            }
        }
    }

    /** Field select creation event handler */
    public function fieldSelectCreate(&$list)
    {
        $list[t('Галлерея', true)] = 9;
    }

    /**
     * Controller for deleting material image from gallery
     * @param string $imageId Gallery Image identifier
     * @return array Async response array
     */
    public function __async_delete($imageId, $materialFieldID = null)

    {
        // Async response
        $result = array();

        /** @var \samson\activerecord\gallery $image */
        $image = null;

        // Find gallery record in DB
        if ($this->findAsyncEntityByID($imageId, $image, $result)) {
            if ($image->Path != '') {
                // Get image path
                $imagePath = $this->formImagePath($image->Path, $image->Src);
                // Physically remove file from server
                if ($this->imageExists($imagePath)) {
                    $this->fs->delete($imagePath);
                }

                // Delete thumbnails
                if (class_exists('\samson\scale\ScaleController', false)) {
                    /** @var \samson\scale\ScaleController $scale */
                    $scale = $this->system->module('scale');

                    foreach (array_keys($scale->thumnails_sizes) as $folder) {
                        // Form image path for scale module
                        $imageScalePath = $this->formImagePath($image->Path . $folder . '/', $image->Src);
                        if ($this->imageExists($imageScalePath)) {
                            $this->fs->delete($imageScalePath);
                        }
                    }
                }
            }

            // Remove record from DB
            $image->delete();
        }

        return $this->__async_update($materialFieldID);
    }

    /**
     * Controller for rendering gallery images list
     * @param int $materialFieldId Gallery identifier, represented as materialfield id
     * @return array Async response array
     */
    public function __async_update($materialFieldId)

    {
        return array('status' => true, 'html' => $this->getHTML($materialFieldId));
    }

	/**
     * Controller for getting quantity image in gallery.
     *
     * @param integer $materialFieldId identefier Table MaterialField
     * @return array Async response array with additional param count.
     */
    public function __async_getCount($materialFieldId)

    {
        // @var array $result Result of asynchronous controller
        $response = array('status' => 1);
        // Getting quantity from DB by param materialFieldId
        $response['count'] = $this->query
            ->entity(CMS::MATERIAL_IMAGES_RELATION_ENTITY)
            ->where(MaterialField::F_PRIMARY, $materialFieldId)
            ->count();

        return $response;
    }
	
	/**
     *  Controller for update material image properties alt from gallery.
     *
     *  @param int $imageId Gallery image identifier
     *  @return array async response
     */
    public function __async_updateAlt($imageId)

    {
        // @var array $result Result of asynchronous controller
        $result = array('status' => false);
        // @var \samson\activerecord\gallery $image Image to insert into editor
        $image = null;
        //get data from ajax
        $data = json_decode(file_get_contents('php://input'), true);
        //set input value
        $value = trim($data['value']);


        // Getting first field image
        if ($this->query->entity(CMS::MATERIAL_IMAGES_RELATION_ENTITY)
            ->where('PhotoID', $imageId)->first($image)) {
            // Update value alt
            $image->Description = $value;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            // Save result in datebase
            $image->save();
            // Set success status
            $result['status'] = true;
            // Reduce number of characters to 25
            $result['description'] = utf8_limit_string($value, 25, '...');
            // Return result value
            $result['value'] = $value;
        }

        return $result;
    }
	
    /**
     * Controller for image upload
     * @param string $materialFieldId Gallery identifier, represented as materialfield id
     * @return array Async response array
     */
    public function __async_upload($materialFieldId)
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

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

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
    {
        $result = array('status' => false);

        /** @var \samsonphp\upload\Upload $upload Pointer to uploader object */
        $upload = null;
        // Verify extension image
        if ($this->verifyExtensionFile()) {
            // Uploading file to server and path current material identifier
            if (uploadFile($upload, array(), $materialFieldId)) {
                /** @var \samson\activerecord\materialfield $materialField MaterialField object to identify gallery */
                $materialField = null;
//            /** @var array $children List of related materials */
//            $children = null;
                // Check if participant has not uploaded remix yet
                if (
                $this->query->entity(MaterialField::ENTITY)
                    ->where('MaterialFieldID', $materialFieldId)
                    ->where('Active', 1)
                    ->first($materialField)
                ) {
                    // Create empty db record
                    $photo = new \samson\activerecord\gallery(false);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                    $photo->Name = $upload->realName();

                    $photo->Src = $upload->name();

                    $photo->Path = $upload->path();

                    $photo->materialFieldId = $materialField->id;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                    $photo->MaterialID = $materialField->MaterialID;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                    $photo->size = $upload->size();

                    $photo->Active = 1;

                    $photo->save();


                    // Call scale if it is loaded
                    if (class_exists('\samson\scale\ScaleController', false)) {
                        /** @var \samson\scale\ScaleController $scale */
                        $scale = $this->system->module('scale');
                        $scale->resize($upload->fullPath(), $upload->name(), $upload->uploadDir);
                    }

                    $result['status'] = true;
                }
            }
        } else {
            $errorText = "Файл ( " . urldecode($_SERVER['HTTP_X_FILE_NAME']) . " ) не является картинкой!";
            $result = array('status' => false, 'errorText' => $errorText);
        }

        return $result;
    }

    /**
     * method for verify extension file
     * @return boolean true - file is image, false - file not image
     * */
    private function verifyExtensionFile()
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

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

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
    {
        $supported_image = array(
            'gif',
            'jpg',
            'jpeg',
            'png'
        );

        $fileName = $_SERVER['HTTP_X_FILE_NAME'];

        $ext = strtolower(pathinfo($fileName, PATHINFO_EXTENSION));
        if (in_array($ext, $supported_image)) {
            return true;
        }
        return false;
    }

    /**
     * Function to save image priority
     * @return array Async response array
     */
    public function __async_priority()
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

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

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
    {
        $result = array('status' => true);

        // If we have changed priority of images
        if (isset($_POST['ids'])) {
            // For each received image id
            for ($i = 0; $i < count($_POST['ids']); $i++) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
                /** @var \samson\activerecord\gallery $photo Variable to store image info */
                $photo = null;
                // If we have such image in database
                if ($this->query->entity(CMS::MATERIAL_IMAGES_RELATION_ENTITY)->where('PhotoID', $_POST['ids'][$i])->first($photo)) {
                    // Reset it's priority and save it
                    $photo->priority = $i;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                    $photo->save();
                } else {
                    $result['status'] = false;
                    $result['message'] = 'Can not find images with specified ids!';
                }
            }
        } else {
            $result['status'] = false;
            $result['message'] = 'There are no images to sort!';
        }
        return $result;
    }

    /**
     * Asynchronous function to get image editor
     * @param int $imageId Image identifier to insert into editor
     * @return array Result array
     */
    public function __async_show_edit($imageId)

    {
        /** @var array $result Result of asynchronous controller */
        $result = array('status' => false);
        /** @var \samson\activerecord\gallery $image Image to insert into editor */
        $image = null;
        if ($this->query->entity(CMS::MATERIAL_IMAGES_RELATION_ENTITY)->where('PhotoID', $imageId)->first($image)) {

            /** @var string $path Path to image */
            $path = $this->formImagePath($image->Path, $image->Src);
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}

            // If there is image for this path
            if ($this->imageExists($path)) {
                $result['status'] = true;
                $result['html'] = $this->view('editor/index')
                    ->set($image, 'image')
                    ->set($path, 'path')
                    ->output();
            }
        }
        return $result;
    }

    /**
     * Applies all changes with the image and save it
     * @param int $imageId Edit image identifier
     * @return array
     */
    public function __async_edit($imageId)

    {
        /** @var array $result Result of asynchronous controller */
        $result = array('status' => false);
        /** @var \samson\activerecord\gallery $image Image to insert into editor */
        $image = null;
        /** @var resource $imageResource Copy of edit image */
        $imageResource = null;
        /** @var resource $croppedImage Resource of cropped image */
        $croppedImage = null;

        // If there is such image in database
        if ($this->query->entity(CMS::MATERIAL_IMAGES_RELATION_ENTITY)->where('PhotoID', $imageId)->first($image)) {


            // Form proper path
            $path = $this->formImagePath($image->Path, $image->Src);
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}

            // Check image extension
            switch (pathinfo($path, PATHINFO_EXTENSION)) {
                case 'jpeg':
                case 'jpg':
                    $imageResource = imagecreatefromjpeg($path);
                    $croppedImage = $this->cropImage($imageResource);
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
                    $result['status'] = imagejpeg($croppedImage, $path);
                    break;
                case 'png':

                    $imageResource = imagecreatefrompng($path);
                    $croppedImage = $this->cropTransparentImage($imageResource);
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
                    $result['status'] = imagepng($croppedImage, $path);
                    break;
                case 'gif':

                    $imageResource = imagecreatefromgif($path);
                    $croppedImage = $this->cropTransparentImage($imageResource);
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
                    $result['status'] = imagegif($croppedImage, $path);
                    break;
            }

            // delete temporary images
            imagedestroy($croppedImage);
            imagedestroy($imageResource);
        }
        return $result;
    }

    /**
     * Render gallery images list
     * @param string $materialFieldId Material identifier
     * @return string html representation of image list
     */
    public function getHTML($materialFieldId)
    {
        // Get all material images
        $items_html = '';
        /** @var array $images List of gallery images */
        $images = null;
        // there are gallery images
        if ($this->query->entity(CMS::MATERIAL_IMAGES_RELATION_ENTITY)->where('materialFieldId', $materialFieldId)->orderBy('priority')->exec($images)) {
            /** @var \samson\cms\CMSGallery $image */
            foreach ($images as $image) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
                // Get image size string
                $size = ', ';
                // Get image path
                $path = $this->formImagePath($image->Path, $image->Src);

                // if file doesn't exist
                if (!$this->imageExists($path)) {
                    $path = \samson\resourcer\ResourceRouter::url('www/img/no-img.png', $this);
                }

                // set image size string representation, if it is not 0
                $size = ($image->size == 0) ? '' : $size . $this->humanFileSize($image->size);

                // Render gallery image tumb
                $items_html .= $this->view('tumbs/item')
                    ->set($image, 'image')
                    ->set(utf8_limit_string($image->Description, 25, '...'), 'description')
                    ->set(utf8_limit_string($image->Name, 18, '...'), 'name')
                    ->set($path, 'imgpath')
                    ->set($size, 'size')
                    ->set($materialFieldId, 'material_id')
                    ->output();
            }
        }

        // Render content into inner content html
        return $this->view('tumbs/index')
            ->set($items_html, 'images')
            ->set($materialFieldId, 'material_id')
            ->output();
    }

    /**
     * Function to form image size
     * @param int $bytes Bytes count
     * @param int $decimals Decimal part of number(count of numbers)
     * @return string Generated image size
     */
    public function humanFileSize($bytes, $decimals = 2)
    {
        /** @var string $sizeLetters Size shortcuts */
        $sizeLetters = 'BKBMBGBTBPB';
        $factor = (int)(floor((strlen($bytes) - 1) / 3));
        $sizeLetter = ($factor <= 0) ? substr($sizeLetters, 0, 1) : substr($sizeLetters, $factor * 2 - 1, 2);
        return sprintf("%.{$decimals}f", $bytes / pow(1024, $factor)) . $sizeLetter;
    }

    /**
     * Checks if image exists, supports old database structure
     * @param string $imagePath Path to image(Full or not)
     * @param string $imageSrc Image name, if it wasn't in $imagePath
     * @return bool
     */
    private function imageExists($imagePath, $imageSrc = null)
    {
        // If image name is sewhere parameter
        if (isset($imageSrc)) {
            // Form path to the image
            $imageFullPath = $this->formImagePath($imagePath, $imageSrc);
        } else {
            // Path was already set
            $imageFullPath = $imagePath;
        }

        // Call file service existence method
        return $this->fs->exists($imageFullPath);
    }

    /**
     * Function to form image path correctly, also supports old database structure
     * @param string $imagePath Path to the image
     * @param string $imageSrc Image name
     * @return string Full path to image
     */
    private function formImagePath($imagePath, $imageSrc)
    {
        // Get old-way image path, remove full path to check file
        if (empty($imagePath)) {
            $path = $imageSrc;
        } else { // Use new CORRECT way
            $path = $imagePath . $imageSrc;
        }

        // form relative path to the image
        $dir = quotemeta(__SAMSON_BASE__);
        // TODO: WTF? Why do we need this, need comments!!!
        if (strpos($path, 'http://') === false) {
            if ($dir == '/') {
                return substr($path, 1);
            } else {
                return preg_replace('/' . addcslashes($dir, '/') . '/', '', $path);
            }
        }

        return $path;
    }
}


Push — master ( 173a0c...14edb3 )

Application B

Complexity

Size/Duplication

Coupling/Cohesion

Importance

16 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

samsonos / cms_app_gallery

Push — master ( 173a0c...14edb3 )

Application B

Complexity

Size/Duplication

Coupling/Cohesion

Importance

16 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like