Lechimp\Dicto\Analysis\CompilesVars::compile_var()

Complexity

Conditions	16
Paths	52

Size

Total Lines	96
Code Lines	52

Duplication

Lines	18
Ratio	18.75 %

Code Coverage

Tests	46
CRAP Score	18.7369

Importance

Changes	1
Bugs	0	Features	0

<?php
    public function compile_var($table_name, Vars\Variable $var, $negate = false) {
        $b = $this->builder()->expr();
        // Since SQL does not have a statement for negating while expressions,
        // we need to negate the single conditions in the expression, which
        // most often is the equality operator here.
        if (!$negate) {
            $eq_op = function($l, $r) use ($b) {
                return $b->eq($l, $r);
            };
        }
        else {
            $eq_op = function($l, $r) use ($b) {
                return $b->neq($l, $r);
            };
        }

        // Pattern matching on variable type.

        if ($var instanceof Vars\AsWellAs) {
            // normal case: $left_condition or $right_condition

46% of this comment could be valid code. Did you maybe forget this after debugging?

            if (!$negate) {

This code seems to be duplicated across your project.

                return $b->orX
                    ( $this->compile_var($table_name, $var->left())
                    , $this->compile_var($table_name, $var->right())
                    );
            }
            // negated case: not ($left_condition or $right_condition)

47% of this comment could be valid code. Did you maybe forget this after debugging?

            //             = not $left_condition and not $right_condition
            if ($negate) {

This code seems to be duplicated across your project.

                return $b->andX
                    ( $this->compile_var($table_name, $var->left(), true)
                    , $this->compile_var($table_name, $var->right(), true)
                    );
            }
        }
        if ($var instanceof Vars\ButNot) {

This code seems to be duplicated across your project.

            return $b->andX
                ( $this->compile_var($table_name, $var->left())
                , $this->compile_var($table_name, $var->right(), true)
                );
        }
        if ($var instanceof Vars\Classes) {
            return $eq_op("$table_name.type", $b->literal(Variable::CLASS_TYPE));
        }
        if ($var instanceof Vars\Everything) {
            return $eq_op($b->literal(1), $b->literal(1));
        }
        if ($var instanceof Vars\Files) {
            return $eq_op("$table_name.type", $b->literal(Variable::FILE_TYPE));
        }
        if ($var instanceof Vars\Functions) {
            return $eq_op("$table_name.type", $b->literal(Variable::FUNCTION_TYPE));
        }
        if ($var instanceof Vars\Globals) {
            return $eq_op("$table_name.type", $b->literal(Variable::GLOBAL_TYPE));
        }
        if ($var instanceof Vars\LanguageConstruct) {
            // normal case : language construct and name matches
            if (!$negate) {
                return $b->andX
                    ( $eq_op("$table_name.type", $b->literal(Variable::LANGUAGE_CONSTRUCT_TYPE))
                    , $eq_op("$table_name.name", $b->literal($var->construct_name()))
                    );
            }
            // negated case: not (language construct and name matches)
            //             = not language construct or not name matches
            else {

                return $b->orX
                    ( $eq_op("$table_name.type", $b->literal(Variable::LANGUAGE_CONSTRUCT_TYPE))
                    , $eq_op("$table_name.name", $b->literal($var->construct_name()))
                    );
            }
        }
        if ($var instanceof Vars\Methods) {
            return $eq_op("$table_name.type", $b->literal(Variable::METHOD_TYPE));
        }
        if ($var instanceof Vars\WithName) {
            // normal case : $condition_left AND regexp matches
            if (!$negate) {
                return $b->andX
                    ( $this->compile_var($table_name, $var->variable())
                    , "$table_name.name REGEXP ".$b->literal('^'.$var->regexp().'$')
                    );
            }
            // negated case: not ($condition_left AND regexp matches)

36% of this comment could be valid code. Did you maybe forget this after debugging?

            //             = not $condition_left OR not regexp matches
            else {
                return $b->orX
                    ( $this->compile_var($table_name, $var->variable(), true)
                    , "$table_name.name NOT REGEXP ".$b->literal('^'.$var->regexp().'$')
                    );
            }
        }
        throw new \LogicException("Can't compile var-type '".get_class($var)."'");
    }