AbstractRule::getTestFilePath() - Code Metrics - jaeger-app/validate - Measure and Improve Code Quality continuously with Scrutinizer

AbstractRule::getTestFilePath() A
last analyzed 2016-07-04 23:34 UTC

↳ Parent: AbstractRule

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
c	0
b	0
f	0
rs	10
cc	1
eloc	2
nc	1
nop	0

<?php
/**
 * Jaeger
 *
 * @copyright	Copyright (c) 2015-2016, mithra62
 * @link		http://jaeger-app.com
 * @version		1.0
 * @filesource 	./Validate/AbstractRule.php
 */
namespace JaegerApp\Validate;

use JaegerApp\Validate\RuleInterface;
use JaegerApp\Exceptions\ValidateException;

/**
 * Jaeger - Abstract Validation Rule
 *
 * Contains useful helper methods for the validators
 *
 * @package Validate
 * @author Eric Lamb <[email protected]>
 */
abstract class AbstractRule implements RuleInterface
{

    /**
     * The shortname of the rule
     * Must be unique!
     * 
     * @var string
     */
    protected $name = '';

    /**
     * The error template
     * 
     * @var string
     */
    protected $error_message = '';

    /**
     * The name of the test file for upload testing
     * 
     * @var string
     */
    protected $test_file = 'test.txt';

    /**
     * The content the test file should contain for comparison testing
     * 
     * @var string
     */
    protected $test_string = 'm62';

    /**
     * Returns the path to the test file
     */
    protected function getTestFilePath()
    {
        return realpath(dirname(__FILE__) . '/' . $this->test_file);
    }

    /**
     * (non-PHPdoc)
     * 
     * @ignore
     *
     * @see \mithra62\Validate\RuleInterface::getErrorMessage()
     */
    public function getErrorMessage()
    {
        if ($this->error_message == '') {
            throw new ValidateException('Error Message is empty!');
        }
        
        return $this->error_message;
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());
}
    }

    /**
     * Sets the error message for the rule
     * 
     * @param string $message            
     * @return RuleInterface
     */
    public function setErrorMessage($message)
    {
        $this->error_message = $message;
        return $this;
    }

    /**
     * Sets the name parameter
     * 
     * @param string $name            
     * @return RuleInterface
     */
    public function setName($name)
    {
        $this->name = $name;
        return $this;
    }

    /**
     * (non-PHPdoc)
     * 
     * @ignore
     *
     * @see \mithra62\Validate\RuleInterface::getName()
     */
    public function getName()
    {
        if ($this->name == '') {
            throw new ValidateException('Rule name is empty!');
        }
        
        return $this->name;
    }
}

1			<?php
2			/**
3			* Jaeger
4			*
5			* @copyright Copyright (c) 2015-2016, mithra62
6			* @link http://jaeger-app.com
7			* @version 1.0
8			* @filesource ./Validate/AbstractRule.php
9			*/
10			namespace JaegerApp\Validate;
11
12			use JaegerApp\Validate\RuleInterface;
13			use JaegerApp\Exceptions\ValidateException;
14
15			/**
16			* Jaeger - Abstract Validation Rule
17			*
18			* Contains useful helper methods for the validators
19			*
20			* @package Validate
21			* @author Eric Lamb <[email protected]>
22			*/
23			abstract class AbstractRule implements RuleInterface
24			{
25
26			/**
27			* The shortname of the rule
28			* Must be unique!
29			*
30			* @var string
31			*/
32			protected $name = '';
33
34			/**
35			* The error template
36			*
37			* @var string
38			*/
39			protected $error_message = '';
40
41			/**
42			* The name of the test file for upload testing
43			*
44			* @var string
45			*/
46			protected $test_file = 'test.txt';
47
48			/**
49			* The content the test file should contain for comparison testing
50			*
51			* @var string
52			*/
53			protected $test_string = 'm62';
54
55			/**
56			* Returns the path to the test file
57			*/
58			protected function getTestFilePath()
59			{
60			return realpath(dirname(__FILE__) . '/' . $this->test_file);
61			}
62
63			/**
64			* (non-PHPdoc)
65			*
66			* @ignore
67			*
68			* @see \mithra62\Validate\RuleInterface::getErrorMessage()
69			*/
70			public function getErrorMessage()
71			{
72			if ($this->error_message == '') {
73			throw new ValidateException('Error Message is empty!');
74			}
75
76			return $this->error_message;
			0 ignored issues – show Bug Best Practice introduced 2016-04-19 04:21 UTC by Report Bug Copy Issue Report The return type of `return $this->error_message;` (`string`) is incompatible with the return type declared by the interface `JaegerApp\Validate\RuleInterface::getErrorMessage` of type `array`. 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...
77			}
78
79			/**
80			* Sets the error message for the rule
81			*
82			* @param string $message
83			* @return RuleInterface
84			*/
85			public function setErrorMessage($message)
86			{
87			$this->error_message = $message;
88			return $this;
89			}
90
91			/**
92			* Sets the name parameter
93			*
94			* @param string $name
95			* @return RuleInterface
96			*/
97			public function setName($name)
98			{
99			$this->name = $name;
100			return $this;
101			}
102
103			/**
104			* (non-PHPdoc)
105			*
106			* @ignore
107			*
108			* @see \mithra62\Validate\RuleInterface::getName()
109			*/
110			public function getName()
111			{
112			if ($this->name == '') {
113			throw new ValidateException('Rule name is empty!');
114			}
115
116			return $this->name;
117			}
118			}

jaeger-app / validate

AbstractRule::getTestFilePath() A last analyzed 2016-07-04 23:34 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

AbstractRule::getTestFilePath() A
last analyzed 2016-07-04 23:34 UTC