Lechimp\Dicto\Rules\ContainText

Complexity

Total Complexity

12

Size/Duplication

Total Lines	129
Duplicated Lines	7.75 %

Coupling/Cohesion

Components	0
Dependencies	7

Test Coverage

Coverage

86.67%

Importance

Changes	7
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	name()	0	3	1
A	fetch_arguments()	0	4	1
A	arguments_are_valid()	10	10	4
B	compile()	0	79	4
A	pprint()	0	3	1
A	register_listeners()	0	2	1

<?php
/******************************************************************************
 * An implementation of dicto (scg.unibe.ch/dicto) in and for PHP.
 *
 * Copyright (c) 2016 Richard Klees <richard.klees@rwth-aachen.de>
 *
 * 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\Analysis\Query;
use Lechimp\Dicto\Analysis\Violation;
use Lechimp\Dicto\Definition\ArgumentParser;
use Lechimp\Dicto\Indexer\ListenerRegistry;

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

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

    /**
     * @inheritdoc
     */
    public function arguments_are_valid(array &$arguments) {

This method seems to be duplicated in your project.

        if (count($arguments) != 1) {
            return false;
        }
        $regexp = $arguments[0];
        if (!is_string($regexp) || @preg_match("%$regexp%", "") === false) {
            return false;
        }
        return true;
    }

    /**
     * @inheritdoc
     */
    public function compile(Query $query, Rule $rule) {
        $builder = $query->builder();
        $b = $builder->expr();
        $mode = $rule->mode();
        $checked_on = $rule->checked_on();
        $regexp = $rule->argument(0);
        if ($mode == Rule::MODE_CANNOT || $mode == Rule::MODE_ONLY_CAN) {
            return $builder

The expression $builder->select('d.name', 'f.path as file', 'src.line', 'src.source')->from($query->definition_table(), 'd')->join('d', $query->file_table(), 'f', $b->eq('d.file', 'f.id'))->join('d', $query->name_table(), 'n', $b->eq('d.name', 'n.id'))->join('d', $query->source_table(), 'src', $b->andX($b->gte('src.line', 'd.start_line'), $b->lte('src.line', 'd.end_line'), $b->eq('src.file', 'd.file'), 'src.source REGEXP ?'))->where($checked_on->compile($b, 'n'))->setParameter(0, $regexp)->execute(); of type Doctrine\DBAL\Driver\Statement|integer adds the type integer to the return on line 63 which is incompatible with the return type declared by the abstract method Lechimp\Dicto\Rules\Schema::compile of type Doctrine\DBAL\Driver\Statement.

                ->select
                    ( "d.name"
                    , "f.path as file"
                    , "src.line"
                    , "src.source"
                    )
                ->from($query->definition_table(), "d")
                ->join
                    ( "d", $query->file_table(), "f"
                    , $b->eq("d.file", "f.id")
                    )
                ->join
                    ( "d", $query->name_table(), "n"
                    , $b->eq("d.name", "n.id")
                    )
                ->join
                    ( "d", $query->source_table(), "src"
                    , $b->andX
                        ( $b->gte("src.line", "d.start_line")
                        , $b->lte("src.line", "d.end_line")
                        , $b->eq("src.file", "d.file")
                        , "src.source REGEXP ?"
                        )
                    )
                ->where
                    ( $checked_on->compile($b, "n")
                    )
                ->setParameter(0, $regexp)
                ->execute();
        }
        if ($mode == Rule::MODE_MUST) {
            return $builder

The expression $builder->select('d.name', 'f.path as file', 'd.start_line as line', 'src.source')->from($query->definition_table(), 'd')->join('d', $query->file_table(), 'f', $b->eq('d.file', 'f.id'))->join('d', $query->name_table(), 'n', $b->eq('d.name', 'n.id'))->join('d', $query->source_table(), 'src', $b->andX($b->eq('src.file', 'd.file'), $b->eq('src.line', 'd.start_line')))->leftJoin('d', $query->source_table(), 'match', $b->andX($b->eq('match.file', 'd.file'), $b->eq('match.line', 'd.start_line'), 'match.source REGEXP ?'))->where($checked_on->compile($b, 'n'), 'match.line IS NULL')->setParameter(0, $regexp)->execute(); of type Doctrine\DBAL\Driver\Statement|integer adds the type integer to the return on line 95 which is incompatible with the return type declared by the abstract method Lechimp\Dicto\Rules\Schema::compile of type Doctrine\DBAL\Driver\Statement.

                ->select
                    ( "d.name"
                    , "f.path as file"
                    , "d.start_line as line"
                    , "src.source"
                    )
                ->from($query->definition_table(), "d")
                ->join
                    ( "d", $query->file_table(), "f"
                    , $b->eq("d.file", "f.id")
                    )
                ->join
                    ( "d", $query->name_table(), "n"
                    , $b->eq("d.name", "n.id")
                    )
                ->join
                    ( "d", $query->source_table(), "src"
                    , $b->andX
                        ( $b->eq("src.file", "d.file")
                        , $b->eq("src.line", "d.start_line")
                        )
                    )
                ->leftJoin
                    ( "d", $query->source_table(), "match"
                    , $b->andX
                        ( $b->eq("match.file", "d.file")
                        , $b->eq("match.line", "d.start_line")
                        , "match.source REGEXP ?"
                        )
                    )
                ->where
                    ( $checked_on->compile($b, "n")
                    , "match.line IS NULL"
                    )
                ->setParameter(0, $regexp)
                ->execute();
        }
        throw new \LogicException("Unknown rule mode: '$mode'");
    }

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

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

}