ImagineGd - Code Metrics - naturalweb/nwlaravel - Measure and Improve Code Quality continuously with Scrutinizer

ImagineGd A
last analyzed 2021-06-11 16:37 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	203
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

Importance

Changes

Metric	Value
dl	0
loc	203
ccs	0
cts	82
cp	0
rs	10
c	0
b	0
f	0
wmc	28
lcom	1
cbo	2

11 Methods

Rating	Name	Size	Complexity
A	__construct()	5	1
A	filesize()	4	1
B	resize()	22	6
A	opacity()	10	3
B	watermark()	23	7
A	crop()	6	1
A	rotate()	10	3
A	stripProfiles()	4	1
A	isImage()	4	3
A	encode()	4	1
A	save()	6	1

<?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());
}
    }

    /**
     * Rotate Image
     *
     * @param integer $angle
     *
     * @return binary
     */
    public function rotate($angle)
    {
        $angle = intval($angle);

        if ($angle > -360 && $angle < 360) {
            $this->image->rotate($angle);
        }

        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());
}
    }

    /**
     * Strip Profiles
     *
     * @param string $except
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     *
     * @return this
     * @todo Pendente para Criaçãio
     */
    public function stripProfiles()
    {
        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			* Rotate Image
142			*
143			* @param integer $angle
144			*
145			* @return binary
146			*/
147			public function rotate($angle)
148			{
149			$angle = intval($angle);
150
151			if ($angle > -360 && $angle < 360) {
152			$this->image->rotate($angle);
153			}
154
155			return $this;
			0 ignored issues – show Bug Best Practice introduced 2018-09-12 18:07 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::rotate` 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...
156			}
157
158			/**
159			* Strip Profiles
160			*
161			* @param string $except
			0 ignored issues – show Bug introduced 2018-10-23 17:11 UTC by Report Bug Copy Issue Report There is no parameter named `$except`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
162			*
163			* @return this
164			* @todo Pendente para Criaçãio
165			*/
166			public function stripProfiles()
167			{
168			return $this;
			0 ignored issues – show Bug Best Practice introduced 2018-10-23 17:11 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::stripProfiles` of type `NwLaravel\FileStorage\this`. 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...
169			}
170
171			/**
172			* Is Image
173			*
174			* @param string $path
175			*
176			* @return boolean
177			*/
178			protected function isImage($path)
179			{
180			return (bool) ($path && is_file($path) && strpos(mime_content_type($path), 'image/')===0);
181			}
182
183			/**
184			* Encode
185			*
186			* @param string $format
187			* @param integer $quality
188			*
189			* @return binary
190			*/
191			public function encode($format = null, $quality = null)
192			{
193			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...
194			}
195
196			/**
197			* Save
198			*
199			* @param string $path
200			* @param integer $quality
201			*
202			* @return binary
203			*/
204			public function save($path, $quality = null)
205			{
206			$this->image = $this->image->save($path, $quality);
207
208			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...
209			}
210			}
211

naturalweb / nwlaravel

ImagineGd A last analyzed 2021-06-11 16:37 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

11 Methods

Duplication Side-by-Side

Filter issues like

ImagineGd A
last analyzed 2021-06-11 16:37 UTC