ContainText::compile() - Code Metrics - Inspection of "introduced Regexp class in _PropertyMatches and Na..." - lechimp-p/dicto.php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 7bef7a...470c23 )

by Richard

created 2016-11-01 12:56 UTC

ContainText::compile() B

↳ Parent: ContainText

Complexity

Conditions	4
Paths	3

Size

Total Lines	67
Code Lines	47

Duplication

Lines	7
Ratio	10.45 %

Code Coverage

Tests	48
CRAP Score	4.0001

Importance

Changes

Metric	Value
dl	7
loc	67
ccs	48
cts	49
cp	0.9796
rs	8.8076
c	0
b	0
f	0
cc	4
eloc	47
nc	3
nop	2
crap	4.0001

How to fix Long Method

<?php
/******************************************************************************
 * An implementation of dicto (scg.unibe.ch/dicto) in and for PHP.
 *
 * Copyright (c) 2016 Richard Klees <[email protected]>
 *
 * This software is licensed under The MIT License. You should have received
 * a copy of the license along with the code.
 */

namespace Lechimp\Dicto\Rules;

use Lechimp\Dicto\Regexp;
use Lechimp\Dicto\Analysis\Index;
use Lechimp\Dicto\Analysis\Violation;
use Lechimp\Dicto\Definition\ArgumentParser;
use Lechimp\Dicto\Indexer\ListenerRegistry;
use Lechimp\Dicto\Graph\Node;
use Lechimp\Dicto\Graph\PredicateFactory;
use Lechimp\Dicto\Graph;

/**
 * This checks wheather there is some text in some entity.
 */
class ContainText extends Schema {
    /**
     * @inheritdoc
     */
    public function name() {
        return "contain text";
    } 

    /**
     * @inheritdoc
     */
    public function fetch_arguments(ArgumentParser $parser) {
        $regexp = new Regexp($parser->fetch_string());
        return array($regexp);
    }

    /**
     * @inheritdoc
     */
    public function arguments_are_valid(array &$arguments) {
        if (count($arguments) != 1 || !($arguments[0] instanceof Regexp)) {
            return false;
        }
        return true;
    }

    /**
     * @inheritdoc
     */
    public function compile(Index $index, Rule $rule) {
        $mode = $rule->mode();
        $pred_factory = $index->query()->predicate_factory();
        $filter = $rule->checked_on()->compile($pred_factory);
        // ContainText needs to have to kinds of queries, one for files, one
        // for none-files. To make the queries faster, we separate the filters
        // to the different types.
        $filter_non_files = $pred_factory->_and
            ([$pred_factory->_not($pred_factory->_type_is("file"))
            , $filter
            ]);
        $filter_files = $pred_factory->_and
            ([$pred_factory->_type_is("file")
            , $filter
            ]);
        $regexp = $rule->argument(0);
        // TODO: This behaviour might better be encoded as a method on regexp.
        //       This is needed in get_source_location to find the number of
        //       the line the regexp was found.
        $loc_regexp = new Regexp(".*".$rule->argument(0)->raw());

        if ($mode == Rule::MODE_CANNOT || $mode == Rule::MODE_ONLY_CAN) {
            return
                [ $index->query()
                    ->filter($filter_non_files)
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
                    ->expand_relations(["defined in"])
                    ->filter($this->regexp_source_filter($pred_factory, $regexp, false))
                    ->extract(function($e,&$r) use ($regexp, $loc_regexp) {
                        $file = $e->target();
                        $found_at_line = $this->get_source_location($e, $loc_regexp);
                        $start_line = $e->property("start_line");
                        $line = $start_line + $found_at_line - 1;
                        // -1 is for the line where the class starts, this would
                        // count double otherwise.
                        $r["file"] = $file->property("path");
                        $r["line"] = $line;
                        $r["source"] = $file->property("source")[$line-1];
                    })
                , $index->query()
                    ->filter($filter_files)
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
                    ->filter($this->regexp_source_filter($pred_factory, $regexp, false))
                    ->extract(function($e,&$r) use ($regexp, $loc_regexp) {
                        $line = $this->get_source_location($e, $loc_regexp);
                        $r["file"] = $e->property("path");
                        $r["line"] = $line;
                        $r["source"] = $e->property("source")[$line-1];
                    })
                ];
        }
        if ($mode == Rule::MODE_MUST) {
            return
                [ $index->query()
                    ->filter($filter_non_files)
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
                    ->expand_relations(["defined in"])
                    ->filter($this->regexp_source_filter($pred_factory, $regexp, true))
                    ->extract(function($e,&$r) use ($rule) {

                        $file = $e->target();
                        $r["file"] = $file->property("path");
                        $line = $e->property("start_line");
                        $r["line"] = $line;
                        $r["source"] = $file->property("source")[$line - 1];
                    })
                // TODO: add implementation for files here.
                ];
        }
        throw new \LogicException("Unknown rule mode: '$mode'");
    }

    // Helpers for compile

    protected function get_source_for(Graph\Entity $e) {
        if ($e->type() == "defined in") {
            return $this->get_source_for_defined_in($e);

        }
        if ($e->type() == "file") {
            return $this->get_source_for_file($e);

        }
        throw new \LogicException(
            "Can't get source for entity with type '".$e->type()."'");
    }

    protected function get_source_for_defined_in(Graph\Relation $r) {
        assert('$r->type() == "defined in"');
        $start_line = $r->property("start_line");
        $end_line = $r->property("end_line");
        return implode
            ( "\n"
            , array_slice
                ( $r->target()->property("source")
                , $start_line - 1
                , $end_line - $start_line
                )
            );
    }

    protected function get_source_for_file(Graph\Node $f) {
        assert('$f->type() == "file"');
        return implode
            ( "\n"
            , $f->property("source")
            );
    }

    protected function regexp_source_filter(PredicateFactory $f, Regexp $regexp, $negate) {
        assert('is_bool($negate)');
        return $f->_custom(function(Graph\Entity $e) use ($regexp, $negate) {
            $source = $this->get_source_for($e);
            if(!$negate) {
                return $regexp->search($source);
            }
            else {
                return !$regexp->search($source);
            }
        });
    }

    protected function get_source_location(Graph\Entity $e, Regexp $regexp) {
        $matches = [];
        $source = $this->get_source_for($e);
        $regexp->search($source, true, $matches);
        return substr_count($matches[0], "\n") + 1;
    }

    /**
     * @inheritdoc
     */
    public function pprint(Rule $rule) {
        return $this->name().' "'.$rule->argument(0)->raw().'"';
    }

    /**
     * No listeners required for contains text. 
     *
     * @inheritdoc
     */
    public function register_listeners(ListenerRegistry $registry) {
    }
}


1			<?php
2			/******************************************************************************
3			* An implementation of dicto (scg.unibe.ch/dicto) in and for PHP.
4			*
5			* Copyright (c) 2016 Richard Klees <[email protected]>
6			*
7			* This software is licensed under The MIT License. You should have received
8			* a copy of the license along with the code.
9			*/
10
11			namespace Lechimp\Dicto\Rules;
12
13			use Lechimp\Dicto\Regexp;
14			use Lechimp\Dicto\Analysis\Index;
15			use Lechimp\Dicto\Analysis\Violation;
16			use Lechimp\Dicto\Definition\ArgumentParser;
17			use Lechimp\Dicto\Indexer\ListenerRegistry;
18			use Lechimp\Dicto\Graph\Node;
19			use Lechimp\Dicto\Graph\PredicateFactory;
20			use Lechimp\Dicto\Graph;
21
22			/**
23			* This checks wheather there is some text in some entity.
24			*/
25			class ContainText extends Schema {
26			/**
27			* @inheritdoc
28			*/
29	52		public function name() {
30	52		return "contain text";
31			}
32
33			/**
34			* @inheritdoc
35			*/
36	7		public function fetch_arguments(ArgumentParser $parser) {
37	7		$regexp = new Regexp($parser->fetch_string());
38	7		return array($regexp);
39			}
40
41			/**
42			* @inheritdoc
43			*/
44	20		public function arguments_are_valid(array &$arguments) {
45	20		if (count($arguments) != 1 \|\| !($arguments[0] instanceof Regexp)) {
46			return false;
47			}
48	20		return true;
49			}
50
51			/**
52			* @inheritdoc
53			*/
54	12		public function compile(Index $index, Rule $rule) {
55	12		$mode = $rule->mode();
56	12		$pred_factory = $index->query()->predicate_factory();
57	12		$filter = $rule->checked_on()->compile($pred_factory);
58			// ContainText needs to have to kinds of queries, one for files, one
59			// for none-files. To make the queries faster, we separate the filters
60			// to the different types.
61	12		$filter_non_files = $pred_factory->_and
62	12		([$pred_factory->_not($pred_factory->_type_is("file"))
63	12		, $filter
64	12		]);
65	12		$filter_files = $pred_factory->_and
66	12		([$pred_factory->_type_is("file")
67	12		, $filter
68	12		]);
69	12		$regexp = $rule->argument(0);
70			// TODO: This behaviour might better be encoded as a method on regexp.
71			// This is needed in get_source_location to find the number of
72			// the line the regexp was found.
73	12		$loc_regexp = new Regexp(".*".$rule->argument(0)->raw());
74
75	12		if ($mode == Rule::MODE_CANNOT \|\| $mode == Rule::MODE_ONLY_CAN) {
76			return
77	9		[ $index->query()
78	9		->filter($filter_non_files)
			0 ignored issues – show Bug introduced 2016-10-16 18:09 UTC by Report Bug Copy Issue Report It seems like `$filter_non_files` defined by `$pred_factory->_and(arra..._is('file')), $filter))` on line `61` can be `null`; however, `Lechimp\Dicto\Graph\Query::filter()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
79	9		->expand_relations(["defined in"])
80	9		->filter($this->regexp_source_filter($pred_factory, $regexp, false))
81			->extract(function($e,&$r) use ($regexp, $loc_regexp) {
82	1		$file = $e->target();
83	1		$found_at_line = $this->get_source_location($e, $loc_regexp);
84	1		$start_line = $e->property("start_line");
85	1		$line = $start_line + $found_at_line - 1;
86			// -1 is for the line where the class starts, this would
87			// count double otherwise.
88	1		$r["file"] = $file->property("path");
89	1		$r["line"] = $line;
90	1		$r["source"] = $file->property("source")[$line-1];
91	9		})
92	9		, $index->query()
93	9		->filter($filter_files)
			0 ignored issues – show Bug introduced 2016-10-16 18:09 UTC by Report Bug Copy Issue Report It seems like `$filter_files` defined by `$pred_factory->_and(arra...e_is('file'), $filter))` on line `65` can be `null`; however, `Lechimp\Dicto\Graph\Query::filter()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
94	9		->filter($this->regexp_source_filter($pred_factory, $regexp, false))
95			->extract(function($e,&$r) use ($regexp, $loc_regexp) {
96	2		$line = $this->get_source_location($e, $loc_regexp);
97	2		$r["file"] = $e->property("path");
98	2		$r["line"] = $line;
99	2		$r["source"] = $e->property("source")[$line-1];
100	9		})
101	9		];
102			}
103	3		if ($mode == Rule::MODE_MUST) {
104			return
105	3		[ $index->query()
106	3		->filter($filter_non_files)
			0 ignored issues – show Bug introduced 2016-10-16 18:09 UTC by Report Bug Copy Issue Report It seems like `$filter_non_files` defined by `$pred_factory->_and(arra..._is('file')), $filter))` on line `61` can be `null`; however, `Lechimp\Dicto\Graph\Query::filter()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
107	4		->expand_relations(["defined in"])
108	3		->filter($this->regexp_source_filter($pred_factory, $regexp, true))
109		View Code Duplication	->extract(function($e,&$r) use ($rule) {
			0 ignored issues – show Duplication introduced 2016-09-29 20:29 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
110	1		$file = $e->target();
111	1		$r["file"] = $file->property("path");
112	1		$line = $e->property("start_line");
113	1		$r["line"] = $line;
114	1		$r["source"] = $file->property("source")[$line - 1];
115	3		})
116			// TODO: add implementation for files here.
117	3		];
118			}
119			throw new \LogicException("Unknown rule mode: '$mode'");
120			}
121
122			// Helpers for compile
123
124	9		protected function get_source_for(Graph\Entity $e) {
125	9		if ($e->type() == "defined in") {
126	5		return $this->get_source_for_defined_in($e);
			0 ignored issues – show Compatibility introduced 2016-10-16 13:01 UTC by Report Bug Copy Issue Report `$e` of type `object<Lechimp\Dicto\Graph\Entity>` is not a sub-type of `object<Lechimp\Dicto\Graph\Relation>`. It seems like you assume a child class of the class `Lechimp\Dicto\Graph\Entity` to be always present. This check looks for parameters that are defined as one type in their type hint or doc comment but seem to be used as a narrower type, i.e an implementation of an interface or a subclass. Consider changing the type of the parameter or doing an instanceof check before assuming your parameter is of the expected type. Loading history...
127			}
128	5		if ($e->type() == "file") {
129	4		return $this->get_source_for_file($e);
			0 ignored issues – show Compatibility introduced 2016-10-16 13:01 UTC by Report Bug Copy Issue Report `$e` of type `object<Lechimp\Dicto\Graph\Entity>` is not a sub-type of `object<Lechimp\Dicto\Graph\Node>`. It seems like you assume a child class of the class `Lechimp\Dicto\Graph\Entity` to be always present. This check looks for parameters that are defined as one type in their type hint or doc comment but seem to be used as a narrower type, i.e an implementation of an interface or a subclass. Consider changing the type of the parameter or doing an instanceof check before assuming your parameter is of the expected type. Loading history...
130			}
131			throw new \LogicException(
132			"Can't get source for entity with type '".$e->type()."'");
133			}
134
135	5		protected function get_source_for_defined_in(Graph\Relation $r) {
136	5		assert('$r->type() == "defined in"');
137	5		$start_line = $r->property("start_line");
138	5		$end_line = $r->property("end_line");
139			return implode
140	5		( "\n"
141	5		, array_slice
142	5		( $r->target()->property("source")
143	5		, $start_line - 1
144	5		, $end_line - $start_line
145	5		)
146	5		);
147			}
148
149	4		protected function get_source_for_file(Graph\Node $f) {
150	4		assert('$f->type() == "file"');
151			return implode
152	4		( "\n"
153	4		, $f->property("source")
154	4		);
155			}
156
157	12		protected function regexp_source_filter(PredicateFactory $f, Regexp $regexp, $negate) {
158	12		assert('is_bool($negate)');
159	12		return $f->_custom(function(Graph\Entity $e) use ($regexp, $negate) {
160	9		$source = $this->get_source_for($e);
161	9		if(!$negate) {
162	7		return $regexp->search($source);
163			}
164			else {
165	2		return !$regexp->search($source);
166			}
167	12		});
168			}
169
170	3		protected function get_source_location(Graph\Entity $e, Regexp $regexp) {
171	3		$matches = [];
172	3		$source = $this->get_source_for($e);
173	3		$regexp->search($source, true, $matches);
174	3		return substr_count($matches[0], "\n") + 1;
175			}
176
177			/**
178			* @inheritdoc
179			*/
180	12		public function pprint(Rule $rule) {
181	12		return $this->name().' "'.$rule->argument(0)->raw().'"';
182			}
183
184			/**
185			* No listeners required for contains text.
186			*
187			* @inheritdoc
188			*/
189	11		public function register_listeners(ListenerRegistry $registry) {
190	11		}
191			}
192

lechimp-p / dicto.php

Push — master ( 7bef7a...470c23 )

ContainText::compile() B

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like