Lechimp\Dicto\Rules\DependOn

Complexity

Total Complexity

16

Size/Duplication

Total Lines	116
Duplicated Lines	49.14 %

Coupling/Cohesion

Components	1
Dependencies	9

Test Coverage

Coverage

97.78%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	name()	0	3	1
A	register_listeners()	0	7	1
A	register_method_call_listener()	21	21	2
B	register_func_call_listener()	24	24	3
A	register_global_listener()	0	18	4
A	register_array_dim_fetch_listener()	0	17	4
A	register_error_suppressor_listener()	12	12	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\Variables\Variable;
use Lechimp\Dicto\Indexer\Location;
use Lechimp\Dicto\Indexer\Insert;
use Lechimp\Dicto\Indexer\ListenerRegistry;
use PhpParser\Node as N;

/**
 * A class or function is considered do depend on something if its body
 * of definition makes use of the thing. Language constructs, files or globals
 * can't depend on anything.
 */
class DependOn extends Relation {
    /**
     * @inheritdoc
     */
    public function name() {
        return "depend on";
    }

    /**
     * @inheritdoc
     */
    public function register_listeners(ListenerRegistry $registry) {
        $this->register_method_call_listener($registry);
        $this->register_func_call_listener($registry);
        $this->register_global_listener($registry);
        $this->register_array_dim_fetch_listener($registry);
        $this->register_error_suppressor_listener($registry);
    }

    protected function register_method_call_listener(ListenerRegistry $registry) {

This method seems to be duplicated in your project.

        $registry->on_enter_misc
            ( [N\Expr\MethodCall::class]
            , function(Insert $insert, Location $location, N\Expr\MethodCall $node) {
                // The 'name' could also be a variable like in $this->$method();
                if (is_string($node->name)) {
                    $method_reference = $insert->_method_reference
                        ( $node->name
                        , $location->in_entities()[0][1]
                        , $location->line()
                        , $location->column()
                        );
                    $this->insert_relation_into
                        ( $insert
                        , $location
                        , $method_reference
                        , $location->line()

The call to DependOn::insert_relation_into() has too many arguments starting with $location->line().

                        );
                }
            });
    }

    protected function register_func_call_listener(ListenerRegistry $registry) {

This method seems to be duplicated in your project.

        $registry->on_enter_misc
            ( [N\Expr\FuncCall::class]
            , function(Insert $insert, Location $location, N\Expr\FuncCall $node) {
                // Omit calls to closures, we would not be able to
                // analyze them anyway atm.
                // Omit functions in arrays, we would not be able to
                // analyze them anyway atm.
                if (!($node->name instanceof N\Expr\Variable ||
                      $node->name instanceof N\Expr\ArrayDimFetch)) {
                    $function_reference = $insert->_function_reference
                        ( $node->name->parts[0]
                        , $location->in_entities()[0][1]
                        , $location->line()
                        , $location->column()
                        );
                    $this->insert_relation_into
                        ( $insert
                        , $location
                        , $function_reference
                        );
                }
            });
    }

    protected function register_global_listener(ListenerRegistry $registry) {
        $registry->on_enter_misc
            ( [N\Stmt\Global_::class]
            , function(Insert $insert, Location $location, N\Stmt\Global_ $node) {
                foreach ($node->vars as $var) {
                    if (!($var instanceof N\Expr\Variable) || !is_string($var->name)) {
                        throw new \RuntimeException(
                            "Expected Variable with string name, found: ".print_r($var, true));
                    }
                    $global = $insert->_global($var->name);
                    $this->insert_relation_into
                        ( $insert
                        , $location
                        , $global
                        );
                }
            });
    }

    protected function register_array_dim_fetch_listener(ListenerRegistry $registry) {
        $registry->on_enter_misc
            ( [N\Expr\ArrayDimFetch::class]
            , function(Insert $insert, Location $location, N\Expr\ArrayDimFetch $node) {
                if ($node->var instanceof N\Expr\Variable 
                &&  $node->var->name == "GLOBALS"
                // Ignore usage of $GLOBALS with variable index.
                && !($node->dim instanceof N\Expr\Variable)) {
                    $global = $insert->_global($node->dim->value);

The property value does not seem to exist in PhpParser\Node\Expr.

                    $this->insert_relation_into
                        ( $insert
                        , $location
                        , $global
                        );
                }
            });
    }

    protected function register_error_suppressor_listener(ListenerRegistry $registry) {

This method seems to be duplicated in your project.

        $registry->on_enter_misc
            ( [N\Expr\ErrorSuppress::class]
            , function(Insert $insert, Location $location, N\Expr\ErrorSuppress $node) {

The parameter $node is not used and could be removed.

                $language_construct = $insert->_language_construct("@");
                $this->insert_relation_into
                    ( $insert
                    , $location
                    , $language_construct
                    );
            });
        }
}