AbstractMigration - Code Metrics - PotatoPowered/potatobase - Measure and Improve Code Quality continuously with Scrutinizer

AbstractMigration A
last analyzed 2016-08-05 03:19 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	16
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	2

Importance

Changes

Metric	Value
wmc	1
lcom	0
cbo	2
dl	0
loc	16
rs	10
c	0
b	0
f	0

1 Method

Rating	Name	Duplication	Size	Complexity
A	table()	0	4	1

<?php
/**
 * Potatobase (https://github.com/PotatoPowered/potatobase)
 *
 * Licensed under The MIT License
 * For full copyright and license information, please see the LICENSE
 * Redistributions of files must retain the above copyright notice.
 *
 * @license     http://www.opensource.org/licenses/mit-license.php MIT License
 * @copyright   Copyright (c) Potato Powered Software
 * @link        http://potatopowered.net
 * @author      Blake Sutton <[email protected]>
 */
namespace Potatobase\Migration;

use Migrations\AbstractMigration as BaseAbstractMigration;
use Potatobase\DB\Table;

/**
 * Class AbstractMigration
 *
 * This class is an extension to the CakePHP AbstractMigration class that allows us to specify our own Table Class so
 * that we can use the new functionality that we have added.
 *
 * @package Potatobase\Migrations
 */
class AbstractMigration extends BaseAbstractMigration
{
    /**
     * Returns an instance of the <code>\Table</code> class.
     *
     * You can use this class to create and manipulate tables.
     *
     * @param string $tableName Table Name
     * @param array $options Options
     * @return Table
     */
    public function table($tableName, $options = [])
    {
        return new Table($tableName, $options, $this->getAdapter());
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			* Potatobase (https://github.com/PotatoPowered/potatobase)
4			*
5			* Licensed under The MIT License
6			* For full copyright and license information, please see the LICENSE
7			* Redistributions of files must retain the above copyright notice.
8			*
9			* @license http://www.opensource.org/licenses/mit-license.php MIT License
10			* @copyright Copyright (c) Potato Powered Software
11			* @link http://potatopowered.net
12			* @author Blake Sutton <[email protected]>
13			*/
14			namespace Potatobase\Migration;
15
16			use Migrations\AbstractMigration as BaseAbstractMigration;
17			use Potatobase\DB\Table;
18
19			/**
20			* Class AbstractMigration
21			*
22			* This class is an extension to the CakePHP AbstractMigration class that allows us to specify our own Table Class so
23			* that we can use the new functionality that we have added.
24			*
25			* @package Potatobase\Migrations
26			*/
27			class AbstractMigration extends BaseAbstractMigration
28			{
29			/**
30			* Returns an instance of the <code>\Table</code> class.
31			*
32			* You can use this class to create and manipulate tables.
33			*
34			* @param string $tableName Table Name
35			* @param array $options Options
36			* @return Table
37			*/
38			public function table($tableName, $options = [])
39			{
40			return new Table($tableName, $options, $this->getAdapter());
			0 ignored issues – show Bug Best Practice introduced 2016-07-25 05:01 UTC by Report Bug Copy Issue Report The return type of `return new \Potatobase\D..., $this->getAdapter());` (`Potatobase\DB\Table`) is incompatible with the return type of the parent method `Migrations\AbstractMigration::table` of type `Migrations\Table`. 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...
41			}
42			}
43

PotatoPowered / potatobase

AbstractMigration A last analyzed 2016-08-05 03:19 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Importance

1 Method

Duplication Side-by-Side

Filter issues like

AbstractMigration A
last analyzed 2016-08-05 03:19 UTC