qcubed/framework

View on GitHub
includes/base_controls/QJsTimerBase.class.php

Summary

Maintainability
B
6 hrs
Test Coverage

The class QJsTimerBase has an overall complexity of 63 which is very high. The configured complexity threshold is 50.
Open

    class QJsTimerBase extends QControl {
        // Values determining the state of the timer
        /** Constant used to indicate that the timer has stopped */
        const Stopped = 0;
        /** Constant used to indicate that the timer has started */

The class QJsTimerBase has 13 public methods. Consider refactoring QJsTimerBase to keep number of public methods under 10.
Open

    class QJsTimerBase extends QControl {
        // Values determining the state of the timer
        /** Constant used to indicate that the timer has stopped */
        const Stopped = 0;
        /** Constant used to indicate that the timer has started */

TooManyPublicMethods

Since: 0.1

A class with too many public methods is probably a good suspect for refactoring, in order to reduce its complexity and find a way to have more fine grained objects.

By default it ignores methods starting with 'get' or 'set'.

Example

Source https://phpmd.org/rules/codesize.html#toomanypublicmethods

Function __set has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.
Open

        public function __set($strName, $mixValue) {
            switch ($strName) {
                case "DeltaTime":
                    try {
                        $this->intDeltaTime = QType::Cast($mixValue, QType::Integer);
Severity: Minor
Found in includes/base_controls/QJsTimerBase.class.php - About 1 hr to fix

Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

A method's cognitive complexity is based on a few simple rules:

  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
  • Code is considered more complex for each "break in the linear flow of the code"
  • Code is considered more complex when "flow breaking structures are nested"

Further reading

Method __set has 47 lines of code (exceeds 25 allowed). Consider refactoring.
Open

        public function __set($strName, $mixValue) {
            switch ($strName) {
                case "DeltaTime":
                    try {
                        $this->intDeltaTime = QType::Cast($mixValue, QType::Integer);
Severity: Minor
Found in includes/base_controls/QJsTimerBase.class.php - About 1 hr to fix

    Consider simplifying this complex logical expression.
    Open

                if (($strEventType == 'QTimerExpiredEvent' && $this->blnPeriodic == false) &&
                    (($strActionType == 'QAjaxAction' && $this->objForm->CallType == QCallType::Ajax) ||
                        ($strActionType == 'QServerAction' && $this->objForm->CallType == QCallType::Server))
                ) {
                    //if we are in an ajax or server post and our timer is not periodic
    Severity: Major
    Found in includes/base_controls/QJsTimerBase.class.php - About 40 mins to fix

      Method __construct has 5 arguments (exceeds 4 allowed). Consider refactoring.
      Open

              public function __construct($objParentObject, $intTime = 0, $blnPeriodic = true, $blnStartNow = true, $strTimerId = null) {
      Severity: Minor
      Found in includes/base_controls/QJsTimerBase.class.php - About 35 mins to fix

        Avoid too many return statements within this method.
        Open

                            return true;
        Severity: Major
        Found in includes/base_controls/QJsTimerBase.class.php - About 30 mins to fix

          Avoid too many return statements within this method.
          Open

                                  return parent::__get($strName);
          Severity: Major
          Found in includes/base_controls/QJsTimerBase.class.php - About 30 mins to fix

            Function RenderActionScripts has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
            Open

                    public function RenderActionScripts() {
                        $strToReturn = $this->callbackString() . " = ";
                        if (!count($this->objActionArray)) {
                            return $strToReturn . 'null;';
                        }
            Severity: Minor
            Found in includes/base_controls/QJsTimerBase.class.php - About 25 mins to fix

            Cognitive Complexity

            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

            A method's cognitive complexity is based on a few simple rules:

            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
            • Code is considered more complex for each "break in the linear flow of the code"
            • Code is considered more complex when "flow breaking structures are nested"

            Further reading

            The method __set() has a Cyclomatic Complexity of 11. The configured cyclomatic complexity threshold is 10.
            Open

                    public function __set($strName, $mixValue) {
                        switch ($strName) {
                            case "DeltaTime":
                                try {
                                    $this->intDeltaTime = QType::Cast($mixValue, QType::Integer);

            CyclomaticComplexity

            Since: 0.1

            Complexity is determined by the number of decision points in a method plus one for the method entry. The decision points are 'if', 'while', 'for', and 'case labels'. Generally, 1-4 is low complexity, 5-7 indicates moderate complexity, 8-10 is high complexity, and 11+ is very high complexity.

            Example

            // Cyclomatic Complexity = 11
            class Foo {
            1   public function example() {
            2       if ($a == $b) {
            3           if ($a1 == $b1) {
                            fiddle();
            4           } elseif ($a2 == $b2) {
                            fiddle();
                        } else {
                            fiddle();
                        }
            5       } elseif ($c == $d) {
            6           while ($c == $d) {
                            fiddle();
                        }
            7        } elseif ($e == $f) {
            8           for ($n = 0; $n < $h; $n++) {
                            fiddle();
                        }
                    } else {
                        switch ($z) {
            9               case 1:
                                fiddle();
                                break;
            10              case 2:
                                fiddle();
                                break;
            11              case 3:
                                fiddle();
                                break;
                            default:
                                fiddle();
                                break;
                        }
                    }
                }
            }

            Source https://phpmd.org/rules/codesize.html#cyclomaticcomplexity

            Missing class import via use statement (line '380', column '14').
            Open

                        throw new QCallerException('Do not add child-controls to an instance of QJsTimer!');

            MissingImport

            Since: 2.7.0

            Importing all external classes in a file through use statements makes them clearly visible.

            Example

            function make() {
                return new \stdClass();
            }

            Source http://phpmd.org/rules/cleancode.html#MissingImport

            The method __construct has a boolean flag argument $blnStartNow, which is a certain sign of a Single Responsibility Principle violation.
            Open

                    public function __construct($objParentObject, $intTime = 0, $blnPeriodic = true, $blnStartNow = true, $strTimerId = null) {

            BooleanArgumentFlag

            Since: 1.4.0

            A boolean flag argument is a reliable indicator for a violation of the Single Responsibility Principle (SRP). You can fix this problem by extracting the logic in the boolean flag into its own class or method.

            Example

            class Foo {
                public function bar($flag = true) {
                }
            }

            Source https://phpmd.org/rules/cleancode.html#booleanargumentflag

            Missing class import via use statement (line '164', column '15').
            Open

                            throw new QCallerException('First parameter of QJsTimer::AddAction is expecting an object of type QTimerExpiredEvent');

            MissingImport

            Since: 2.7.0

            Importing all external classes in a file through use statements makes them clearly visible.

            Example

            function make() {
                return new \stdClass();
            }

            Source http://phpmd.org/rules/cleancode.html#MissingImport

            Missing class import via use statement (line '117', column '15').
            Open

                            throw new QCallerException("Can't start the timer: add an Event/Action first!");

            MissingImport

            Since: 2.7.0

            Importing all external classes in a file through use statements makes them clearly visible.

            Example

            function make() {
                return new \stdClass();
            }

            Source http://phpmd.org/rules/cleancode.html#MissingImport

            The method Render has a boolean flag argument $blnDisplayOutput, which is a certain sign of a Single Responsibility Principle violation.
            Open

                    public function Render($blnDisplayOutput = true) {

            BooleanArgumentFlag

            Since: 1.4.0

            A boolean flag argument is a reliable indicator for a violation of the Single Responsibility Principle (SRP). You can fix this problem by extracting the logic in the boolean flag into its own class or method.

            Example

            class Foo {
                public function bar($flag = true) {
                }
            }

            Source https://phpmd.org/rules/cleancode.html#booleanargumentflag

            The method __construct has a boolean flag argument $blnPeriodic, which is a certain sign of a Single Responsibility Principle violation.
            Open

                    public function __construct($objParentObject, $intTime = 0, $blnPeriodic = true, $blnStartNow = true, $strTimerId = null) {

            BooleanArgumentFlag

            Since: 1.4.0

            A boolean flag argument is a reliable indicator for a violation of the Single Responsibility Principle (SRP). You can fix this problem by extracting the logic in the boolean flag into its own class or method.

            Example

            class Foo {
                public function bar($flag = true) {
                }
            }

            Source https://phpmd.org/rules/cleancode.html#booleanargumentflag

            Missing class import via use statement (line '167', column '15').
            Open

                            throw new QCallerException('Second parameter of AddAction is expecting an object of type QAction');

            MissingImport

            Since: 2.7.0

            Importing all external classes in a file through use statements makes them clearly visible.

            Example

            function make() {
                return new \stdClass();
            }

            Source http://phpmd.org/rules/cleancode.html#MissingImport

            Missing class import via use statement (line '370', column '14').
            Open

                        throw new QCallerException('Do not render QJsTimer!');

            MissingImport

            Since: 2.7.0

            Importing all external classes in a file through use statements makes them clearly visible.

            Example

            function make() {
                return new \stdClass();
            }

            Source http://phpmd.org/rules/cleancode.html#MissingImport

            Missing class import via use statement (line '138', column '15').
            Open

                            throw new QCallerException('Can\'t stop the timer: no Event/Action present!');

            MissingImport

            Since: 2.7.0

            Importing all external classes in a file through use statements makes them clearly visible.

            Example

            function make() {
                return new \stdClass();
            }

            Source http://phpmd.org/rules/cleancode.html#MissingImport

            Avoid using static access to class 'QApplication' in method 'Stop'.
            Open

                        QApplication::ExecuteJavaScript($strJS);

            StaticAccess

            Since: 1.4.0

            Static access causes unexchangeable dependencies to other classes and leads to hard to test code. Avoid using static access at all costs and instead inject dependencies through the constructor. The only case when static access is acceptable is when used for factory methods.

            Example

            class Foo
            {
                public function bar()
                {
                    Bar::baz();
                }
            }

            Source https://phpmd.org/rules/cleancode.html#staticaccess

            Avoid using static access to class 'QApplication' in method 'Start'.
            Open

                        QApplication::ExecuteJavaScript($strJS);

            StaticAccess

            Since: 1.4.0

            Static access causes unexchangeable dependencies to other classes and leads to hard to test code. Avoid using static access at all costs and instead inject dependencies through the constructor. The only case when static access is acceptable is when used for factory methods.

            Example

            class Foo
            {
                public function bar()
                {
                    Bar::baz();
                }
            }

            Source https://phpmd.org/rules/cleancode.html#staticaccess

            Avoid using static access to class 'QType' in method '__set'.
            Open

                                    $this->blnRestartOnServerAction = QType::Cast($mixValue, QType::Boolean);

            StaticAccess

            Since: 1.4.0

            Static access causes unexchangeable dependencies to other classes and leads to hard to test code. Avoid using static access at all costs and instead inject dependencies through the constructor. The only case when static access is acceptable is when used for factory methods.

            Example

            class Foo
            {
                public function bar()
                {
                    Bar::baz();
                }
            }

            Source https://phpmd.org/rules/cleancode.html#staticaccess

            Avoid using static access to class 'QType' in method '__set'.
            Open

                                    $this->intDeltaTime = QType::Cast($mixValue, QType::Integer);

            StaticAccess

            Since: 1.4.0

            Static access causes unexchangeable dependencies to other classes and leads to hard to test code. Avoid using static access at all costs and instead inject dependencies through the constructor. The only case when static access is acceptable is when used for factory methods.

            Example

            class Foo
            {
                public function bar()
                {
                    Bar::baz();
                }
            }

            Source https://phpmd.org/rules/cleancode.html#staticaccess

            The method __set uses an else expression. Else clauses are basically not necessary and you can simplify the code by not using them.
            Open

                                        } else {
                                            $this->blnPeriodic = $newMode;
                                        }

            ElseExpression

            Since: 1.4.0

            An if expression with an else branch is basically not necessary. You can rewrite the conditions in a way that the else clause is not necessary and the code becomes simpler to read. To achieve this, use early return statements, though you may need to split the code it several smaller methods. For very simple assignments you could also use the ternary operations.

            Example

            class Foo
            {
                public function bar($flag)
                {
                    if ($flag) {
                        // one branch
                    } else {
                        // another branch
                    }
                }
            }

            Source https://phpmd.org/rules/cleancode.html#elseexpression

            The method GetEndScript uses an else expression. Else clauses are basically not necessary and you can simplify the code by not using them.
            Open

                            else {
                                $this->intState = QJsTimer::Stopped;
                            }

            ElseExpression

            Since: 1.4.0

            An if expression with an else branch is basically not necessary. You can rewrite the conditions in a way that the else clause is not necessary and the code becomes simpler to read. To achieve this, use early return statements, though you may need to split the code it several smaller methods. For very simple assignments you could also use the ternary operations.

            Example

            class Foo
            {
                public function bar($flag)
                {
                    if ($flag) {
                        // one branch
                    } else {
                        // another branch
                    }
                }
            }

            Source https://phpmd.org/rules/cleancode.html#elseexpression

            Avoid using static access to class 'QType' in method '__set'.
            Open

                                    $newMode = QType::Cast($mixValue, QType::Boolean);

            StaticAccess

            Since: 1.4.0

            Static access causes unexchangeable dependencies to other classes and leads to hard to test code. Avoid using static access at all costs and instead inject dependencies through the constructor. The only case when static access is acceptable is when used for factory methods.

            Example

            class Foo
            {
                public function bar()
                {
                    Bar::baz();
                }
            }

            Source https://phpmd.org/rules/cleancode.html#staticaccess

            Avoid using static access to class 'QApplication' in method 'RenderActionScripts'.
            Open

                            if (QApplication::IsBrowser(QBrowserType::InternetExplorer_6_0)) {

            StaticAccess

            Since: 1.4.0

            Static access causes unexchangeable dependencies to other classes and leads to hard to test code. Avoid using static access at all costs and instead inject dependencies through the constructor. The only case when static access is acceptable is when used for factory methods.

            Example

            class Foo
            {
                public function bar()
                {
                    Bar::baz();
                }
            }

            Source https://phpmd.org/rules/cleancode.html#staticaccess

            The method Stop uses an else expression. Else clauses are basically not necessary and you can simplify the code by not using them.
            Open

                        } else {
                            // One-time timer. We should clear the timeout we had set beforehand
                            $strJS = 'window.clearTimeout(' . $this->tidString() . ');';
                        }

            ElseExpression

            Since: 1.4.0

            An if expression with an else branch is basically not necessary. You can rewrite the conditions in a way that the else clause is not necessary and the code becomes simpler to read. To achieve this, use early return statements, though you may need to split the code it several smaller methods. For very simple assignments you could also use the ternary operations.

            Example

            class Foo
            {
                public function bar($flag)
                {
                    if ($flag) {
                        // one branch
                    } else {
                        // another branch
                    }
                }
            }

            Source https://phpmd.org/rules/cleancode.html#elseexpression

            The method Start uses an else expression. Else clauses are basically not necessary and you can simplify the code by not using them.
            Open

                        } else {
                            // timer is not periodic. We will set the timeout
                            $strJS = $this->tidString() . ' = window.setTimeout("' . $this->callbackString() . '()", ' . $this->intDeltaTime . ');';
                        }

            ElseExpression

            Since: 1.4.0

            An if expression with an else branch is basically not necessary. You can rewrite the conditions in a way that the else clause is not necessary and the code becomes simpler to read. To achieve this, use early return statements, though you may need to split the code it several smaller methods. For very simple assignments you could also use the ternary operations.

            Example

            class Foo
            {
                public function bar($flag)
                {
                    if ($flag) {
                        // one branch
                    } else {
                        // another branch
                    }
                }
            }

            Source https://phpmd.org/rules/cleancode.html#elseexpression

            The method RenderActionScripts uses an else expression. Else clauses are basically not necessary and you can simplify the code by not using them.
            Open

                            } else {
                                $strToReturn .= ' return false;';
                            }

            ElseExpression

            Since: 1.4.0

            An if expression with an else branch is basically not necessary. You can rewrite the conditions in a way that the else clause is not necessary and the code becomes simpler to read. To achieve this, use early return statements, though you may need to split the code it several smaller methods. For very simple assignments you could also use the ternary operations.

            Example

            class Foo
            {
                public function bar($flag)
                {
                    if ($flag) {
                        // one branch
                    } else {
                        // another branch
                    }
                }
            }

            Source https://phpmd.org/rules/cleancode.html#elseexpression

            Avoid unused parameters such as '$blnDisplayOutput'.
            Open

                    public function Render($blnDisplayOutput = true) {

            UnusedFormalParameter

            Since: 0.2

            Avoid passing parameters to methods or constructors and then not using those parameters.

            Example

            class Foo
            {
                private function bar($howdy)
                {
                    // $howdy is not used
                }
            }

            Source https://phpmd.org/rules/unusedcode.html#unusedformalparameter

            Avoid unused parameters such as '$blnRemoveFromForm'.
            Open

                    public function RemoveChildControl($strControlId, $blnRemoveFromForm) {

            UnusedFormalParameter

            Since: 0.2

            Avoid passing parameters to methods or constructors and then not using those parameters.

            Example

            class Foo
            {
                private function bar($howdy)
                {
                    // $howdy is not used
                }
            }

            Source https://phpmd.org/rules/unusedcode.html#unusedformalparameter

            Avoid unused parameters such as '$objControl'.
            Open

                    public function  AddChildControl(QControl $objControl) {

            UnusedFormalParameter

            Since: 0.2

            Avoid passing parameters to methods or constructors and then not using those parameters.

            Example

            class Foo
            {
                private function bar($howdy)
                {
                    // $howdy is not used
                }
            }

            Source https://phpmd.org/rules/unusedcode.html#unusedformalparameter

            Avoid unused parameters such as '$strControlId'.
            Open

                    public function RemoveChildControl($strControlId, $blnRemoveFromForm) {

            UnusedFormalParameter

            Since: 0.2

            Avoid passing parameters to methods or constructors and then not using those parameters.

            Example

            class Foo
            {
                private function bar($howdy)
                {
                    // $howdy is not used
                }
            }

            Source https://phpmd.org/rules/unusedcode.html#unusedformalparameter

            Avoid excessively long variable names like $blnRestartOnServerAction. Keep variable name length under 20.
            Open

                    protected $blnRestartOnServerAction = false;

            LongVariable

            Since: 0.2

            Detects when a field, formal or local variable is declared with a long name.

            Example

            class Something {
                protected $reallyLongIntName = -3; // VIOLATION - Field
                public static function main( array $interestingArgumentsList[] ) { // VIOLATION - Formal
                    $otherReallyLongName = -5; // VIOLATION - Local
                    for ($interestingIntIndex = 0; // VIOLATION - For
                         $interestingIntIndex < 10;
                         $interestingIntIndex++ ) {
                    }
                }
            }

            Source https://phpmd.org/rules/naming.html#longvariable

            Constant Stopped should be defined in uppercase
            Open

                    const Stopped = 0;

            ConstantNamingConventions

            Since: 0.2

            Class/Interface constant names should always be defined in uppercase.

            Example

            class Foo {
                const MY_NUM = 0; // ok
                const myTest = ""; // fail
            }

            Source https://phpmd.org/rules/naming.html#constantnamingconventions

            Constant Started should be defined in uppercase
            Open

                    const Started = 1;

            ConstantNamingConventions

            Since: 0.2

            Class/Interface constant names should always be defined in uppercase.

            Example

            class Foo {
                const MY_NUM = 0; // ok
                const myTest = ""; // fail
            }

            Source https://phpmd.org/rules/naming.html#constantnamingconventions

            Constant EventName should be defined in uppercase
            Open

                    const EventName = 'timerexpiredevent';

            ConstantNamingConventions

            Since: 0.2

            Class/Interface constant names should always be defined in uppercase.

            Example

            class Foo {
                const MY_NUM = 0; // ok
                const myTest = ""; // fail
            }

            Source https://phpmd.org/rules/naming.html#constantnamingconventions

            Constant AutoStart should be defined in uppercase
            Open

                    const AutoStart = 2;

            ConstantNamingConventions

            Since: 0.2

            Class/Interface constant names should always be defined in uppercase.

            Example

            class Foo {
                const MY_NUM = 0; // ok
                const myTest = ""; // fail
            }

            Source https://phpmd.org/rules/naming.html#constantnamingconventions

            The method RenderActionScripts is not named in camelCase.
            Open

                    public function RenderActionScripts() {
                        $strToReturn = $this->callbackString() . " = ";
                        if (!count($this->objActionArray)) {
                            return $strToReturn . 'null;';
                        }

            CamelCaseMethodName

            Since: 0.2

            It is considered best practice to use the camelCase notation to name methods.

            Example

            class ClassName {
                public function get_name() {
                }
            }

            Source

            The method RemoveAllActions is not named in camelCase.
            Open

                    public function  RemoveAllActions($strEventName = null) {
                        $this->Stop(); //no actions are registered for this timer stop it
                        parent::RemoveAllActions($strEventName);
                    }

            CamelCaseMethodName

            Since: 0.2

            It is considered best practice to use the camelCase notation to name methods.

            Example

            class ClassName {
                public function get_name() {
                }
            }

            Source

            The method ParsePostData is not named in camelCase.
            Open

                    public function  ParsePostData() {
                    }

            CamelCaseMethodName

            Since: 0.2

            It is considered best practice to use the camelCase notation to name methods.

            Example

            class ClassName {
                public function get_name() {
                }
            }

            Source

            The method AddAction is not named in camelCase.
            Open

                    public function AddAction($objEvent, $objAction) {
                        if (!($objEvent instanceof QTimerExpiredEvent)) {
                            throw new QCallerException('First parameter of QJsTimer::AddAction is expecting an object of type QTimerExpiredEvent');
                        }
                        if (!($objAction instanceof QAction)) {

            CamelCaseMethodName

            Since: 0.2

            It is considered best practice to use the camelCase notation to name methods.

            Example

            class ClassName {
                public function get_name() {
                }
            }

            Source

            The method GetEndScript is not named in camelCase.
            Open

                    public function GetEndScript() {
                        if ($this->objForm->CallType == QCallType::Server) {
                            //this point is not reached on initial rendering
                            if ($this->blnRestartOnServerAction && $this->intState === QJsTimer::Started) {
                                $this->Start();

            CamelCaseMethodName

            Since: 0.2

            It is considered best practice to use the camelCase notation to name methods.

            Example

            class ClassName {
                public function get_name() {
                }
            }

            Source

            The method RemoveChildControl is not named in camelCase.
            Open

                    public function RemoveChildControl($strControlId, $blnRemoveFromForm) {
                    }

            CamelCaseMethodName

            Since: 0.2

            It is considered best practice to use the camelCase notation to name methods.

            Example

            class ClassName {
                public function get_name() {
                }
            }

            Source

            The method GetAllActions is not named in camelCase.
            Open

                    public function GetAllActions($strEventType, $strActionType = null) {
                        if (($strEventType == 'QTimerExpiredEvent' && $this->blnPeriodic == false) &&
                            (($strActionType == 'QAjaxAction' && $this->objForm->CallType == QCallType::Ajax) ||
                                ($strActionType == 'QServerAction' && $this->objForm->CallType == QCallType::Server))
                        ) {

            CamelCaseMethodName

            Since: 0.2

            It is considered best practice to use the camelCase notation to name methods.

            Example

            class ClassName {
                public function get_name() {
                }
            }

            Source

            The method Start is not named in camelCase.
            Open

                    public function Start($intTime = null) {
                        $this->Stop();
                        if ($intTime != null && is_int($intTime)) {
                            $this->intDeltaTime = $intTime;
                        }

            CamelCaseMethodName

            Since: 0.2

            It is considered best practice to use the camelCase notation to name methods.

            Example

            class ClassName {
                public function get_name() {
                }
            }

            Source

            The method Stop is not named in camelCase.
            Open

                    public function Stop() {
                        $event = $this->getEvent();
                        if (!$event) {
                            throw new QCallerException('Can\'t stop the timer: no Event/Action present!');
                        }

            CamelCaseMethodName

            Since: 0.2

            It is considered best practice to use the camelCase notation to name methods.

            Example

            class ClassName {
                public function get_name() {
                }
            }

            Source

            The method GetEvent is not named in camelCase.
            Open

                    public function GetEvent() {
                        if (!count($this->objActionArray)) {
                            return null;
                        }
                        // point to the first action in the list

            CamelCaseMethodName

            Since: 0.2

            It is considered best practice to use the camelCase notation to name methods.

            Example

            class ClassName {
                public function get_name() {
                }
            }

            Source

            The method Validate is not named in camelCase.
            Open

                    public function  Validate() {
                        return true;
                    }

            CamelCaseMethodName

            Since: 0.2

            It is considered best practice to use the camelCase notation to name methods.

            Example

            class ClassName {
                public function get_name() {
                }
            }

            Source

            The method Render is not named in camelCase.
            Open

                    public function Render($blnDisplayOutput = true) {
                        throw new QCallerException('Do not render QJsTimer!');
                    }

            CamelCaseMethodName

            Since: 0.2

            It is considered best practice to use the camelCase notation to name methods.

            Example

            class ClassName {
                public function get_name() {
                }
            }

            Source

            The method AddChildControl is not named in camelCase.
            Open

                    public function  AddChildControl(QControl $objControl) {
                        throw new QCallerException('Do not add child-controls to an instance of QJsTimer!');
                    }

            CamelCaseMethodName

            Since: 0.2

            It is considered best practice to use the camelCase notation to name methods.

            Example

            class ClassName {
                public function get_name() {
                }
            }

            Source

            The method GetControlHtml is not named in camelCase.
            Open

                    protected function GetControlHtml() {
                        // no control html
                        return "";
                    }

            CamelCaseMethodName

            Since: 0.2

            It is considered best practice to use the camelCase notation to name methods.

            Example

            class ClassName {
                public function get_name() {
                }
            }

            Source

            There are no issues that match your filters.

            Category
            Status