GherkinParam::getValueFromParam() - Code Metrics - Inspection of "Fix ... ooops" - edno/codeception-gherkin-param - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — master (5c1aa1)

by Greg

created 2016-06-11 18:55 UTC

GherkinParam::getValueFromParam() A

↳ Parent: GherkinParam

Complexity

Conditions	4
Paths	4

Size

Total Lines	15
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Importance

Changes	4
Bugs	0	Features	2

Metric	Value
c	4
b	0
f	2
dl	0
loc	15
rs	9.2
cc	4
eloc	11
nc	4
nop	1

<?php
/**
 * Before step hook that provide parameter syntax notation
 * for accessing fixture data between Gherkin steps/tests
 * example:
 *  I see "{{param}}"
 *  {{param}} will be replaced by the value of Fixtures::get('param')
 *
 */
namespace Codeception\Extension;

use Codeception\Util\Fixtures;
use Behat\Gherkin\Node\TableNode;
use ReflectionProperty;

class GherkinParam extends \Codeception\Platform\Extension
{
  // list events to listen to
  public static $events = array(
    //run before any suite
    'suite.before' => 'beforeSuite',
    //run before any steps
    'step.before' => 'beforeStep'
  );

  private static $suite_config;

  private static $regEx = Array(
                          'match'  => '/^{{[A-z0-9_:-]+}}$/',
                          'filter' => '/[{}]/',
                          'config' => '/(?:^config)?:([A-z0-9_-]+)+(?=:|$)/',
                          'array'  => '/^(?P<var>[A-z0-9_-]+)(?:\[(?P<key>.+)])$/'
                        );

  // parse param and replace {{.*}} by its Fixtures::get() value if exists
  protected function getValueFromParam($param)
  {
    if (preg_match(static::$regEx['match'], $param)) {
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
      $arg = preg_filter(static::$regEx['filter'], '', $param);
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
      if (preg_match(static::$regEx['config'], $arg)) {
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
        return $this->getValueFromConfig($arg);
      } elseif (preg_match(static::$regEx['array'], $arg)) {
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
        return $this->getValueFromArray($arg);
      }else {
        return Fixtures::get($arg);
      }
    } else {
      return $param;
    }
  }

  protected function getValueFromConfig($param)
  {
    $value = null;
    $config = static::$suite_config;
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}

    preg_match_all(static::$regEx['config'], $param, $args, PREG_PATTERN_ORDER);
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
    foreach ($args[1] as $arg) {
      if (array_key_exists($arg, $config)) {
        $value = $config[$arg];
        if (is_array($value)) {
          $config = $value;
        } else {
          break;
        }
      }
    }
    return $value;
  }

  protected function getValueFromArray($param)
  {
    $value = null;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}

    preg_match_all(static::$regEx['array'], $param, $args);
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
    $array = Fixtures::get($args['var'][0]);
    if (array_key_exists($args['key'][0], $array)) {
        $value = $array[$args['key'][0]];
    } else {
      return null;
    }
    return $value;
  }

  /**
   * @codeCoverageIgnore
   */
  public function beforeSuite(\Codeception\Event\SuiteEvent $e)
  {
    static::$suite_config = $e->getSettings();
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
  }

  public function beforeStep(\Codeception\Event\StepEvent $e)
  {
    $step = $e->getStep();
    // access to the protected property using reflection
    $refArgs = new ReflectionProperty(get_class($step), 'arguments');
    // change property accessibility to public
    $refArgs->setAccessible(true);
    // retrieve 'arguments' value
    $args = $refArgs->getValue($step);
    foreach ($args as $index => $arg) {
      if (is_string($arg)) {
      // case if arg is a string
      // e.g. I see "{{param}}"
        $args[$index] = $this->getValueFromParam($arg);
      } elseif (is_a($arg, '\Behat\Gherkin\Node\TableNode')) {
      // case if arg is a table
      // e.g. I see :
      //  | paramater |
      //  | {{param}} |
        $table = Array();
        foreach ($arg->getRows() as $i => $row) {
          foreach ($row as $j => $cell) {
              $table[$i][$j] = $this->getValueFromParam($cell);
          }
        }
        $args[$index] = new TableNode($table);
      }
    }
    // set new arguments value
    $refArgs->setValue($step, $args);
  }

}


1			<?php
2			/**
3			* Before step hook that provide parameter syntax notation
4			* for accessing fixture data between Gherkin steps/tests
5			* example:
6			* I see "{{param}}"
7			* {{param}} will be replaced by the value of Fixtures::get('param')
8			*
9			*/
10			namespace Codeception\Extension;
11
12			use Codeception\Util\Fixtures;
13			use Behat\Gherkin\Node\TableNode;
14			use ReflectionProperty;
15
16			class GherkinParam extends \Codeception\Platform\Extension
17			{
18			// list events to listen to
19			public static $events = array(
20			//run before any suite
21			'suite.before' => 'beforeSuite',
22			//run before any steps
23			'step.before' => 'beforeStep'
24			);
25
26			private static $suite_config;
27
28			private static $regEx = Array(
29			'match' => '/^{{[A-z0-9_:-]+}}$/',
30			'filter' => '/[{}]/',
31			'config' => '/(?:^config)?:([A-z0-9_-]+)+(?=:\|$)/',
32			'array' => '/^(?P<var>[A-z0-9_-]+)(?:\[(?P<key>.+)])$/'
33			);
34
35			// parse param and replace {{.*}} by its Fixtures::get() value if exists
36			protected function getValueFromParam($param)
37			{
38			if (preg_match(static::$regEx['match'], $param)) {
			1 ignored issue – show Bug introduced 2016-06-11 16:35 UTC by Report Bug Copy Issue Report Since `$regEx` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$regEx` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
39			$arg = preg_filter(static::$regEx['filter'], '', $param);
			1 ignored issue – show Bug introduced 2016-06-11 16:35 UTC by Report Bug Copy Issue Report Since `$regEx` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$regEx` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
40			if (preg_match(static::$regEx['config'], $arg)) {
			1 ignored issue – show Bug introduced 2016-06-11 16:35 UTC by Report Bug Copy Issue Report Since `$regEx` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$regEx` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
41			return $this->getValueFromConfig($arg);
42			} elseif (preg_match(static::$regEx['array'], $arg)) {
			1 ignored issue – show Bug introduced 2016-06-11 16:35 UTC by Report Bug Copy Issue Report Since `$regEx` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$regEx` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
43			return $this->getValueFromArray($arg);
44			}else {
45			return Fixtures::get($arg);
46			}
47			} else {
48			return $param;
49			}
50			}
51
52			protected function getValueFromConfig($param)
53			{
54			$value = null;
55			$config = static::$suite_config;
			1 ignored issue – show Bug introduced 2016-06-11 16:35 UTC by Report Bug Copy Issue Report Since `$suite_config` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$suite_config` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
56
57			preg_match_all(static::$regEx['config'], $param, $args, PREG_PATTERN_ORDER);
			1 ignored issue – show Bug introduced 2016-06-11 16:35 UTC by Report Bug Copy Issue Report Since `$regEx` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$regEx` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
58			foreach ($args[1] as $arg) {
59			if (array_key_exists($arg, $config)) {
60			$value = $config[$arg];
61			if (is_array($value)) {
62			$config = $value;
63			} else {
64			break;
65			}
66			}
67			}
68			return $value;
69			}
70
71			protected function getValueFromArray($param)
72			{
73			$value = null;
			0 ignored issues – show Unused Code introduced 2016-06-11 18:57 UTC by Report Bug Copy Issue Report `$value` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history...
74
75			preg_match_all(static::$regEx['array'], $param, $args);
			1 ignored issue – show Bug introduced 2016-06-11 16:35 UTC by Report Bug Copy Issue Report Since `$regEx` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$regEx` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
76			$array = Fixtures::get($args['var'][0]);
77			if (array_key_exists($args['key'][0], $array)) {
78			$value = $array[$args['key'][0]];
79			} else {
80			return null;
81			}
82			return $value;
83			}
84
85			/**
86			* @codeCoverageIgnore
87			*/
88			public function beforeSuite(\Codeception\Event\SuiteEvent $e)
89			{
90			static::$suite_config = $e->getSettings();
			1 ignored issue – show Bug introduced 2016-06-11 16:35 UTC by Report Bug Copy Issue Report Since `$suite_config` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$suite_config` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
91			}
92
93			public function beforeStep(\Codeception\Event\StepEvent $e)
94			{
95			$step = $e->getStep();
96			// access to the protected property using reflection
97			$refArgs = new ReflectionProperty(get_class($step), 'arguments');
98			// change property accessibility to public
99			$refArgs->setAccessible(true);
100			// retrieve 'arguments' value
101			$args = $refArgs->getValue($step);
102			foreach ($args as $index => $arg) {
103			if (is_string($arg)) {
104			// case if arg is a string
105			// e.g. I see "{{param}}"
106			$args[$index] = $this->getValueFromParam($arg);
107			} elseif (is_a($arg, '\Behat\Gherkin\Node\TableNode')) {
108			// case if arg is a table
109			// e.g. I see :
110			// \| paramater \|
111			// \| {{param}} \|
112			$table = Array();
113			foreach ($arg->getRows() as $i => $row) {
114			foreach ($row as $j => $cell) {
115			$table[$i][$j] = $this->getValueFromParam($cell);
116			}
117			}
118			$args[$index] = new TableNode($table);
119			}
120			}
121			// set new arguments value
122			$refArgs->setValue($step, $args);
123			}
124
125			}
126

edno / codeception-gherkin-param

Branch — master (5c1aa1)

GherkinParam::getValueFromParam() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like