ImagineGd::resize() - Code Metrics - Inspection of "Alterado FileStorage para redimensionar Imagens GI..." - naturalweb/nwlaravel - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 5982d9...78edbd )

by Renato

created 2018-06-09 12:28 UTC

ImagineGd::resize() B

↳ Parent: ImagineGd

Complexity

Conditions	6
Paths	9

Size

Total Lines	22
Code Lines	13

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	22
c	0
b	0
f	0
cc	6
eloc	13
nc	9
nop	3
rs	8.6737

<?php

namespace NwLaravel\FileStorage;

use Intervention\Image\ImageManager;
use Intervention\Image\Image;

class ImagineGd implements Imagine
{
    /**
     * @var ImageManager
     */
    protected $manager;

    /**
     * @var Image
     */
    protected $image;

    /**
     * Construct
     *
     * @param string       $path
     * @param ImageManager $manager
     */
    public function __construct($path, ImageManager $manager)
    {
        $this->manager = $manager;
        $this->image = $this->manager->make($path);
    }

    /**
     * Filesize
     *
     * @return int
     */
    public function filesize()
    {
        return $this->image->filesize();

    }

    /**
     * Define Resize
     *
     * @param int     $width
     * @param int     $height
     * @param boolean $force
     *
     * @return Imagine
     */
    public function resize($width, $height, $force = false)
    {
        $width = intval($width);
        $height = intval($height);
        $callback = function () {};

        if ($width > 0 || $height > 0) {
            // AutoScale - aspectRatio
            if (!$force) {
                $callback = function ($constraint) {
                    $constraint->aspectRatio();
                    $constraint->upsize();
                };
            }

            $width = $width?:null;
            $height = $height?:null;
            $this->image->resize($width, $height, $callback);
        }

        return $this;
    }

    /**
     * Opacity
     *
     * @return Imagine
     */
    public function opacity($opacity)
    {
        $opacity = intval($opacity);

        if ($opacity > 0 && $opacity < 100) {
            $this->image->opacity($opacity);
        }

        return $this;
    }

    /**
     * Watermark
     *
     * @param string  $path
     * @param string  $position
     * @param integer $opacity
     *
     * @return Imagine
     */
    public function watermark($path, $position = 'center', $opacity = null)
    {
        if ($this->isImage($path)) {
            $watermark = $this->manager->make($path);

            $width = $this->image->width();
            $height = $this->image->height();
            if ($watermark->width() > $width || $watermark->height() > $height) {
                $watermark->resize($width, $height, function ($constraint) {
                    $constraint->aspectRatio();
                    $constraint->upsize();
                });
            }

            if (!is_null($opacity) && $opacity >= 0 && $opacity <= 100) {
                $watermark->opacity($opacity);
            }

            $this->image->insert($watermark, $position);
        }

        return $this;
    }

    /**
     * Crop
     *
     * @param integer $width
     * @param integer $height
     * @param integer $x
     * @param integer $y
     *
     * @return binary
     */
    public function crop($width, $height, $x, $y)
    {
        $this->image->crop($width, $height, $x, $y);

        return $this;
class Author {
    private $name;

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

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * Is Image
     *
     * @param string $path
     *
     * @return boolean
     */
    protected function isImage($path)
    {
        return (bool) ($path && is_file($path) && strpos(mime_content_type($path), 'image/')===0);
    }

    /**
     * Encode
     *
     * @param string  $format
     * @param integer $quality
     *
     * @return binary
     */
    public function encode($format = null, $quality = null)
    {
        return $this->image->encode($format, $quality);
class Author {
    private $name;

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

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * Save
     *
     * @param string  $path
     * @param integer $quality
     *
     * @return binary
     */
    public function save($path, $quality = null)
    {
        $this->image = $this->image->save($path, $quality);

        return $this;
class Author {
    private $name;

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

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }
}


1			<?php
2
3			namespace NwLaravel\FileStorage;
4
5			use Intervention\Image\ImageManager;
6			use Intervention\Image\Image;
7
8			class ImagineGd implements Imagine
9			{
10			/**
11			* @var ImageManager
12			*/
13			protected $manager;
14
15			/**
16			* @var Image
17			*/
18			protected $image;
19
20			/**
21			* Construct
22			*
23			* @param string $path
24			* @param ImageManager $manager
25			*/
26			public function __construct($path, ImageManager $manager)
27			{
28			$this->manager = $manager;
29			$this->image = $this->manager->make($path);
30			}
31
32			/**
33			* Filesize
34			*
35			* @return int
36			*/
37			public function filesize()
38			{
39			return $this->image->filesize();
			0 ignored issues – show Comprehensibility Best Practice introduced 2018-06-09 12:36 UTC by Report Bug Copy Issue Report The expression `$this->image->filesize();` of type `integer\|false` adds `false` to the return on line 39 which is incompatible with the return type declared by the interface `NwLaravel\FileStorage\Imagine::filesize` of type `integer`. It seems like you forgot to handle an error condition. Loading history...
40			}
41
42			/**
43			* Define Resize
44			*
45			* @param int $width
46			* @param int $height
47			* @param boolean $force
48			*
49			* @return Imagine
50			*/
51			public function resize($width, $height, $force = false)
52			{
53			$width = intval($width);
54			$height = intval($height);
55			$callback = function () {};
56
57			if ($width > 0 \|\| $height > 0) {
58			// AutoScale - aspectRatio
59			if (!$force) {
60			$callback = function ($constraint) {
61			$constraint->aspectRatio();
62			$constraint->upsize();
63			};
64			}
65
66			$width = $width?:null;
67			$height = $height?:null;
68			$this->image->resize($width, $height, $callback);
69			}
70
71			return $this;
72			}
73
74			/**
75			* Opacity
76			*
77			* @return Imagine
78			*/
79			public function opacity($opacity)
80			{
81			$opacity = intval($opacity);
82
83			if ($opacity > 0 && $opacity < 100) {
84			$this->image->opacity($opacity);
85			}
86
87			return $this;
88			}
89
90			/**
91			* Watermark
92			*
93			* @param string $path
94			* @param string $position
95			* @param integer $opacity
96			*
97			* @return Imagine
98			*/
99			public function watermark($path, $position = 'center', $opacity = null)
100			{
101			if ($this->isImage($path)) {
102			$watermark = $this->manager->make($path);
103
104			$width = $this->image->width();
105			$height = $this->image->height();
106			if ($watermark->width() > $width \|\| $watermark->height() > $height) {
107			$watermark->resize($width, $height, function ($constraint) {
108			$constraint->aspectRatio();
109			$constraint->upsize();
110			});
111			}
112
113			if (!is_null($opacity) && $opacity >= 0 && $opacity <= 100) {
114			$watermark->opacity($opacity);
115			}
116
117			$this->image->insert($watermark, $position);
118			}
119
120			return $this;
121			}
122
123			/**
124			* Crop
125			*
126			* @param integer $width
127			* @param integer $height
128			* @param integer $x
129			* @param integer $y
130			*
131			* @return binary
132			*/
133			public function crop($width, $height, $x, $y)
134			{
135			$this->image->crop($width, $height, $x, $y);
136
137			return $this;
			0 ignored issues – show Bug Best Practice introduced 2018-06-09 12:36 UTC by Report Bug Copy Issue Report The return type of `return $this;` (`NwLaravel\FileStorage\ImagineGd`) is incompatible with the return type declared by the interface `NwLaravel\FileStorage\Imagine::crop` of type `NwLaravel\FileStorage\binary`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
138			}
139
140			/**
141			* Is Image
142			*
143			* @param string $path
144			*
145			* @return boolean
146			*/
147			protected function isImage($path)
148			{
149			return (bool) ($path && is_file($path) && strpos(mime_content_type($path), 'image/')===0);
150			}
151
152			/**
153			* Encode
154			*
155			* @param string $format
156			* @param integer $quality
157			*
158			* @return binary
159			*/
160			public function encode($format = null, $quality = null)
161			{
162			return $this->image->encode($format, $quality);
			0 ignored issues – show Bug Best Practice introduced 2018-06-09 12:36 UTC by Report Bug Copy Issue Report The return type of `return $this->image->encode($format, $quality);` (`Intervention\Image\Image`) is incompatible with the return type declared by the interface `NwLaravel\FileStorage\Imagine::encode` of type `NwLaravel\FileStorage\binary`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
163			}
164
165			/**
166			* Save
167			*
168			* @param string $path
169			* @param integer $quality
170			*
171			* @return binary
172			*/
173			public function save($path, $quality = null)
174			{
175			$this->image = $this->image->save($path, $quality);
176
177			return $this;
			0 ignored issues – show Bug Best Practice introduced 2018-06-09 12:36 UTC by Report Bug Copy Issue Report The return type of `return $this;` (`NwLaravel\FileStorage\ImagineGd`) is incompatible with the return type declared by the interface `NwLaravel\FileStorage\Imagine::save` of type `NwLaravel\FileStorage\binary`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
178			}
179			}
180

naturalweb / nwlaravel

Push — master ( 5982d9...78edbd )

ImagineGd::resize() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like